Test_model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Test_model.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPhMaqihwXjq29w8meljOYD",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/imenebak/VisDrone_CC/blob/master/Test_model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "raL3W_J7UTzH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.python.client import device_lib \n",
        "device_lib.list_local_devices()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uvHUOeOlUVQf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cv2\n",
        "import h5py\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib import cm as c\n",
        "from keras.models import model_from_json\n",
        "import os\n",
        "import glob"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lEG7z-d2Ubg3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YX4RM8lTAIHZ",
        "colab_type": "text"
      },
      "source": [
        "# **Image 2 video**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-cd36GL-UiFV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!unzip \"/content/VisDrone2020-CC-test.zip\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nburA94sVSQF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "import glob\n",
        "\n",
        "nom_dossier = '/content/VisDrone2020-CC-test/00112'\n",
        "img_array = []\n",
        "for i in range(1, 31):\n",
        "  if i > 9 :\n",
        "      nom = \"000\"\n",
        "  else : \n",
        "      nom = \"0000\"\n",
        "  #print(nom_dossier+'/'+nom+str(i)+\".jpg\")\n",
        "  img = cv2.imread(nom_dossier+'/'+nom+str(i)+\".jpg\")\n",
        "  height, width, layers = img.shape\n",
        "  size = (width,height)\n",
        "  #print(filename)\n",
        "  img_array.append(img)\n",
        " \n",
        " \n",
        "out = cv2.VideoWriter('project.mp4',cv2.VideoWriter_fourcc(*'DIVX'), 20, size)\n",
        " \n",
        "for i in range(len(img_array)):\n",
        "    out.write(img_array[i])\n",
        "out.release()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "17td58K5ARP5",
        "colab_type": "text"
      },
      "source": [
        "# **Video 2 images**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H5R-9u2kV9qv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!rm -r \"/content/image\" \n",
        "os.mkdir(\"/content/image\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IQnbtAsWWCXT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cv2\n",
        "vidcap = cv2.VideoCapture('/content/project.mp4')\n",
        "def getFrame(sec):\n",
        "    vidcap.set(cv2.CAP_PROP_POS_MSEC,sec*1000)\n",
        "    hasFrames,image = vidcap.read()\n",
        "    if hasFrames:\n",
        "        cv2.imwrite(\"/content/image/image\"+str(count)+\".jpg\", image)     # save frame as JPG file\n",
        "    return hasFrames\n",
        "sec = 0\n",
        "frameRate = 0.1 #//it will capture image in each 0.1 second\n",
        "count=1\n",
        "success = getFrame(sec)\n",
        "while success:\n",
        "    count = count + 1\n",
        "    sec = sec + frameRate\n",
        "    sec = round(sec, 2)\n",
        "    success = getFrame(sec)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_ViJJN56AYGS",
        "colab_type": "text"
      },
      "source": [
        "# **Crowd Counting** (images)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dcv9vB4rWL9s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!cp \"/content/drive/My Drive/ValTrain/visdr2020/best_weights.h5\" \"/content/\"\n",
        "!cp \"/content/drive/My Drive/ValTrain/visdr2020/Model.json\" \"/content/\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SfioXz4DWZga",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def load_model():\n",
        "    # Function to load and return neural network model \n",
        "    json_file = open('/content/Model.json', 'r')\n",
        "    loaded_model_json = json_file.read()\n",
        "    json_file.close()\n",
        "    loaded_model = model_from_json(loaded_model_json)\n",
        "    loaded_model.load_weights(\"/content/best_weights.h5\")\n",
        "    return loaded_model\n",
        "\n",
        "def create_img(path):\n",
        "    #Function to load,normalize and return image \n",
        "    print(path)\n",
        "    im = Image.open(path).convert('RGB')\n",
        "    width, height = im.size \n",
        "    newsize = (int(width * .5), int(height * .5))\n",
        "    #im = im.resize(newsize)\n",
        "    im = np.array(im)\n",
        "    \n",
        "    im = im/255.0\n",
        "    \n",
        "    im[:,:,0]=(im[:,:,0]-0.485)/0.229\n",
        "    im[:,:,1]=(im[:,:,1]-0.456)/0.224\n",
        "    im[:,:,2]=(im[:,:,2]-0.406)/0.225\n",
        "\n",
        "\n",
        "    im = np.expand_dims(im,axis  = 0)\n",
        "    return im"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WaE_y5ucWfdn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = load_model()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gtcXYWQjWiO5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "root = \"/content/\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ltC3qs7TWj7w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def predict(path):\n",
        "    os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
        "    #Function to load image,predict heat map, generate count and return (count , image , heat map)\n",
        "    model = load_model()\n",
        "    image = create_img(path)\n",
        "    start_time = time.time()\n",
        "    ans = model.predict(image)\n",
        "    print(\"--- %s seconds ---\" % (time.time() - start_time))\n",
        "    count = np.sum(ans)\n",
        "    return count,image,ans"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7FWySEZoWl9K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import time, matplotlib"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MiIWbf5FWooM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "path_sets = os.path.join(root,'image')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7qDeAyHoWr2o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "img_paths_test = []\n",
        "for img_path in glob.glob(os.path.join(path_sets, '*.jpg')):\n",
        "        img_paths_test.append(str(img_path))\n",
        "print(\"Test image importation .. Total images : \",len(img_paths_test))\n",
        "end = len(img_paths_test)+1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b-pjxZoAWuDp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cv2\n",
        "from google.colab.patches import cv2_imshow"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GXpiHeZrWxyL",
        "colab_type": "text"
      },
      "source": [
        "Density Estimation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_396wLJNW23g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!rm -r \"/content/resultat_comptage\"\n",
        "!rm -r \"/content/resultat_density\"\n",
        "\n",
        "os.mkdir(\"/content/resultat_comptage\")\n",
        "os.mkdir(\"/content/resultat_density\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1McQ51shW6gb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m4MGE_AbW8MR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def norm_image(img):\n",
        "    img = (img - np.min(img)) / (np.max(img) - np.min(img))\n",
        "    return img"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m-K9cjDcW-A7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def opencv_plot(densmap_name):\n",
        "\n",
        "    densmap = np.array(densmap_name, np.float32)\n",
        "\n",
        "    densmap = cv2.resize(densmap, (int(densmap.shape[1]*8), int(densmap.shape[0]*8)))\n",
        "    densmap = cv2.blur(densmap, (10, 10))\n",
        "    \n",
        "    densmap[densmap >1 ] = 1\n",
        "    densmap = norm_image(densmap) * 255\n",
        "    densmap = densmap.astype(np.uint8)\n",
        "    \n",
        "    zmar = cv2.applyColorMap(densmap, cv2.COLORMAP_JET)\n",
        "    \n",
        "    return zmar\n",
        "    #cv2.imshow(\"im\", im_color)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rjOwS5f7XEyJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "name = []\n",
        "y_true = []\n",
        "y_pred = []\n",
        "tim = []\n",
        "from matplotlib import cm as CM\n",
        "for im in img_paths_test:\n",
        "  name.append(im)\n",
        "  nom = im.replace(\"/content/image/\", \"\")\n",
        "  frame = cv2.imread(im)   #image originale\n",
        "  w, h,_ = frame.shape\n",
        "  print(frame.shape)\n",
        "  img = create_img(im)     #image entrainement\n",
        "  #print(img.shape)\n",
        "  start_time = time.time()\n",
        "  data = model.predict(img)   #density map\n",
        "  tim.append(float(time.time() - start_time))\n",
        "  num = np.sum(data)\n",
        "  y_pred.append(num)\n",
        "  #print(data.shape, img.shape)\n",
        "  ground_truth = data\n",
        "  data = data.reshape(data.shape[1], data.shape[2], data.shape[3])\n",
        "  #print(data.shape, img.shape)\n",
        "  data = opencv_plot(data)\n",
        "  frame = cv2.resize(frame,(data.shape[1], data.shape[0]))\n",
        "  #print(data.shape, frame.shape)\n",
        "  data = cv2.addWeighted(data, 0.3, frame , 1 - 0.3, 0, data)\n",
        "  #print(data.shape)\n",
        "  #cv2_imshow(data)\n",
        "  \n",
        "  #print(float(time.time() - start_time))\n",
        "  fontface = cv2.FONT_HERSHEY_DUPLEX\n",
        "  fontscale = 1\n",
        "  fontcolor = (255, 255, 255)\n",
        "  fr = cv2.putText(frame, \"Count : \"+str(int(num)+1), (50,50), fontface, fontscale, fontcolor) \n",
        "  frr = cv2.putText(data, \"Count : \"+str(int(num)+1), (50,50), fontface, fontscale, fontcolor) \n",
        "  #plt.imshow(fr)\n",
        "  #fr = cv2.putText(frame,\"Hello World!!!\", (100,5), cv2.CV_FONT_HERSHEY_SIMPLEX, 2, 255)\n",
        "  #print(num)\n",
        "  #cv2_imshow(fr)\n",
        "  \n",
        "  cv2.imwrite(\"/content/resultat_comptage/\"+nom, fr)\n",
        "  cv2.imwrite(\"/content/resultat_density/\"+nom, data)\n",
        "  \n",
        "dat = pd.DataFrame({'name': name,'y_pred': y_pred,\"temp-ex\": tim})\n",
        "dat.to_csv('/content/resultat.csv', sep=',')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qXcXR_r0A3Ic",
        "colab_type": "text"
      },
      "source": [
        "# **Resultats2videos**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ugd1goNXZlc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "import glob\n",
        " \n",
        "nom_dossier = '/content/resultat_comptage'\n",
        "img_array = []\n",
        "for i in range(1, end):\n",
        "  nom = \"image\"\n",
        "  print(nom_dossier+'/'+nom+str(i)+\".jpg\")\n",
        "  img = cv2.imread(nom_dossier+'/'+nom+str(i)+\".jpg\")\n",
        "  height, width, layers = img.shape\n",
        "  size = (width,height)\n",
        "  #print(filename)\n",
        "  img_array.append(img)\n",
        " \n",
        " \n",
        "out = cv2.VideoWriter('resltat_comptage.mp4',cv2.VideoWriter_fourcc(*'DIVX'), 10, size)\n",
        " \n",
        "for i in range(len(img_array)):\n",
        "    out.write(img_array[i])\n",
        "out.release()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xacjMIaOXadA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "import glob\n",
        " \n",
        "nom_dossier = '/content/resultat_density'\n",
        "img_array = []\n",
        "for i in range(1, end):\n",
        "  nom = \"image\"\n",
        "  print(nom_dossier+'/'+nom+str(i)+\".jpg\")\n",
        "  img = cv2.imread(nom_dossier+'/'+nom+str(i)+\".jpg\")\n",
        "  height, width, layers = img.shape\n",
        "  size = (width,height)\n",
        "  #print(filename)\n",
        "  img_array.append(img)\n",
        " \n",
        " \n",
        "out = cv2.VideoWriter('resltat_density.mp4',cv2.VideoWriter_fourcc(*'DIVX'), 10, size)\n",
        " \n",
        "for i in range(len(img_array)):\n",
        "    out.write(img_array[i])\n",
        "out.release()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}