├── .ipynb_checkpoints
    ├── test_img-checkpoint.ipynb
    └── train_mobilenetv2-checkpoint.ipynb
├── CombineGIF.gif
├── Densenet_depth_model
    ├── Densenet.ipynb
    ├── DepthData.py
    ├── DepthImageVisualize.ipynb
    ├── Depthestimation.ipynb
    ├── UtilityTest.py
    ├── model_dense.py
    ├── test_img.ipynb
    ├── test_video.ipynb
    └── video.avi
├── DepthData_mob.py
├── Example generated images
    ├── 10_depth.jpg
    ├── 10_image.jpg
    ├── 11_depth.jpg
    ├── 11_image.jpg
    ├── 12_depth.jpg
    ├── 12_image.jpg
    ├── 13_depth.jpg
    ├── 13_image.jpg
    ├── 14_depth.jpg
    ├── 14_image.jpg
    ├── 15_depth.jpg
    ├── 15_image.jpg
    ├── 16_depth.jpg
    ├── 16_image.jpg
    ├── 17_depth.jpg
    ├── 17_image.jpg
    ├── 18_depth.jpg
    ├── 18_image.jpg
    ├── 2_depth.jpg
    ├── 2_image.jpg
    ├── 3_depth.jpg
    ├── 3_image.jpg
    ├── 4_depth.jpg
    ├── 4_image.jpg
    ├── 6_depth.jpg
    ├── 6_image.jpg
    ├── 7_depth.jpg
    ├── 7_image.jpg
    ├── 8_depth.jpg
    ├── 8_image.jpg
    ├── 9_depth.jpg
    └── 9_image.jpg
├── LICENSE
├── Mobile_model.py
├── README.md
├── UtilityTest.py
├── movie_depth.gif
├── movie_real.gif
├── test_img.ipynb
├── test_video.ipynb
└── train_mobilenetv2.ipynb


/CombineGIF.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/CombineGIF.gif


--------------------------------------------------------------------------------
/Densenet_depth_model/Densenet.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nbformat": 4,
  3 |   "nbformat_minor": 0,
  4 |   "metadata": {
  5 |     "colab": {
  6 |       "name": "Densenet.ipynb",
  7 |       "provenance": []
  8 |     },
  9 |     "kernelspec": {
 10 |       "name": "python3",
 11 |       "display_name": "Python 3"
 12 |     }
 13 |   },
 14 |   "cells": [
 15 |     {
 16 |       "cell_type": "code",
 17 |       "metadata": {
 18 |         "id": "JIivNnSwyODH",
 19 |         "colab_type": "code",
 20 |         "colab": {
 21 |           "base_uri": "https://localhost:8080/",
 22 |           "height": 461
 23 |         },
 24 |         "outputId": "514e38dd-86d7-49dc-c238-aeb814b574f8"
 25 |       },
 26 |       "source": [
 27 |         "import torch\n",
 28 |         "import torchvision.models as models\n",
 29 |         "import torch.nn as nn\n",
 30 |         "from torch.autograd import Variable\n",
 31 |         "import torch.nn.functional as F\n",
 32 |         "model_ft = models.densenet161(pretrained=True)\n",
 33 |         "x = torch.randn([1,3,640 , 480])\n",
 34 |         "\n",
 35 |         "model_ft.features._modules.items()\n",
 36 |         "features = [x]\n",
 37 |         "i=-2;\n",
 38 |         "for k, v in (model_ft.features._modules.items()): \n",
 39 |         "  print(i)\n",
 40 |         "  i+=1\n",
 41 |         "  features.append( v(features[-1]) )\n",
 42 |         "  # print(k)\n",
 43 |         "  # print(v)\n",
 44 |         "  # print(features[-1].shape)\n",
 45 |         "\n",
 46 |         "for i,x in enumerate(features):\n",
 47 |         "    print(i,x.shape)"
 48 |       ],
 49 |       "execution_count": 14,
 50 |       "outputs": [
 51 |         {
 52 |           "output_type": "stream",
 53 |           "text": [
 54 |             "-2\n",
 55 |             "-1\n",
 56 |             "0\n",
 57 |             "1\n",
 58 |             "2\n",
 59 |             "3\n",
 60 |             "4\n",
 61 |             "5\n",
 62 |             "6\n",
 63 |             "7\n",
 64 |             "8\n",
 65 |             "9\n",
 66 |             "0 torch.Size([1, 3, 640, 480])\n",
 67 |             "1 torch.Size([1, 96, 320, 240])\n",
 68 |             "2 torch.Size([1, 96, 320, 240])\n",
 69 |             "3 torch.Size([1, 96, 320, 240])\n",
 70 |             "4 torch.Size([1, 96, 160, 120])\n",
 71 |             "5 torch.Size([1, 384, 160, 120])\n",
 72 |             "6 torch.Size([1, 192, 80, 60])\n",
 73 |             "7 torch.Size([1, 768, 80, 60])\n",
 74 |             "8 torch.Size([1, 384, 40, 30])\n",
 75 |             "9 torch.Size([1, 2112, 40, 30])\n",
 76 |             "10 torch.Size([1, 1056, 20, 15])\n",
 77 |             "11 torch.Size([1, 2208, 20, 15])\n",
 78 |             "12 torch.Size([1, 2208, 20, 15])\n"
 79 |           ],
 80 |           "name": "stdout"
 81 |         }
 82 |       ]
 83 |     },
 84 |     {
 85 |       "cell_type": "code",
 86 |       "metadata": {
 87 |         "id": "eoGzvGeB2mgp",
 88 |         "colab_type": "code",
 89 |         "colab": {}
 90 |       },
 91 |       "source": [
 92 |         "import torch\n",
 93 |         "import torch.nn as nn\n",
 94 |         "import torch.nn.functional as F\n",
 95 |         "\n",
 96 |         "class UpSample(nn.Sequential):\n",
 97 |         "    def __init__(self, skip_input, output_features):\n",
 98 |         "        super(UpSample, self).__init__()        \n",
 99 |         "        self.convA = nn.Conv2d(skip_input, output_features, kernel_size=3, stride=1, padding=1)\n",
100 |         "        self.leakyreluA = nn.LeakyReLU(0.2)\n",
101 |         "        self.convB = nn.Conv2d(output_features, output_features, kernel_size=3, stride=1, padding=1)\n",
102 |         "        self.leakyreluB = nn.LeakyReLU(0.2)\n",
103 |         "\n",
104 |         "    def forward(self, x, concat_with):\n",
105 |         "        up_x = F.interpolate(x, size=[concat_with.size(2), concat_with.size(3)], mode='bilinear', align_corners=True)\n",
106 |         "        return self.leakyreluB( self.convB( self.leakyreluA(self.convA( torch.cat([up_x, concat_with], dim=1) ) ) )  )\n",
107 |         "\n",
108 |         "class Decoder(nn.Module):\n",
109 |         "    def __init__(self, num_features=2208, decoder_width = 0.5):\n",
110 |         "        super(Decoder, self).__init__()\n",
111 |         "        features = int(num_features * decoder_width)\n",
112 |         "\n",
113 |         "        self.conv2 = nn.Conv2d(num_features, features, kernel_size=1, stride=1, padding=1)\n",
114 |         "\n",
115 |         "        self.up1 = UpSample(skip_input=features//1 + 384, output_features=features//2)\n",
116 |         "        self.up2 = UpSample(skip_input=features//2 + 192, output_features=features//4)\n",
117 |         "        self.up3 = UpSample(skip_input=features//4 +  96, output_features=features//8)\n",
118 |         "        self.up4 = UpSample(skip_input=features//8 +  96, output_features=features//16)\n",
119 |         "\n",
120 |         "        self.conv3 = nn.Conv2d(features//16, 1, kernel_size=3, stride=1, padding=1)\n",
121 |         "\n",
122 |         "    def forward(self, features):\n",
123 |         "        x_block0, x_block1, x_block2, x_block3, x_block4 = features[3], features[4], features[6], features[8], features[11]\n",
124 |         "        x_d0 = self.conv2(x_block4)\n",
125 |         "        x_d1 = self.up1(x_d0, x_block3)\n",
126 |         "        x_d2 = self.up2(x_d1, x_block2)\n",
127 |         "        x_d3 = self.up3(x_d2, x_block1)\n",
128 |         "        x_d4 = self.up4(x_d3, x_block0)\n",
129 |         "        return self.conv3(x_d4)\n",
130 |         "\n",
131 |         "class Encoder(nn.Module):\n",
132 |         "    def __init__(self):\n",
133 |         "        super(Encoder, self).__init__()       \n",
134 |         "        import torchvision.models as models\n",
135 |         "        self.original_model = models.densenet161( pretrained=True )\n",
136 |         "\n",
137 |         "    def forward(self, x):\n",
138 |         "        features = [x]\n",
139 |         "        for k, v in self.original_model.features._modules.items(): features.append( v(features[-1]) )\n",
140 |         "        return features\n",
141 |         "\n",
142 |         "class Model(nn.Module):\n",
143 |         "    def __init__(self):\n",
144 |         "        super(Model, self).__init__()\n",
145 |         "        self.encoder = Encoder()\n",
146 |         "        self.decoder = Decoder()\n",
147 |         "\n",
148 |         "    def forward(self, x):\n",
149 |         "        return self.decoder( self.encoder(x) )"
150 |       ],
151 |       "execution_count": 0,
152 |       "outputs": []
153 |     }
154 |   ]
155 | }


--------------------------------------------------------------------------------
/Densenet_depth_model/DepthData.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Created on Sun Dec 29 23:17:26 2019
  3 | 
  4 | @author: alin
  5 | """
  6 | 
  7 | # from torch.utils.data import Dataset, DataLoader
  8 | from torch.utils.data import Dataset, DataLoader
  9 | import os 
 10 | from PIL import Image
 11 | import random
 12 | import numpy as np
 13 | import torch
 14 | 
 15 | #Depth Datasetclass
 16 | 
 17 | def _is_pil_image(img):
 18 |     return isinstance(img, Image.Image)
 19 | 
 20 | def _is_numpy_image(img):
 21 |     return isinstance(img, np.ndarray) and (img.ndim in {2, 3})
 22 | 
 23 | 
 24 | class DepthDataset(Dataset):
 25 |     os = __import__('os')
 26 |     def __init__(self, traincsv, root_dir, transform=None):
 27 |         self.traincsv = traincsv
 28 |         self.root_dir = root_dir
 29 |         self.transform = transform
 30 | 
 31 |     def __len__(self):
 32 |         return len(self.traincsv)
 33 | 
 34 |     def __getitem__(self, idx):
 35 |         
 36 |         sample = self.traincsv[idx]
 37 |         img_name = os.path.join(self.root_dir,sample[0])
 38 |         image = (Image.open(img_name))
 39 |         depth_name = os.path.join(self.root_dir,sample[1])
 40 |         depth =(Image.open(depth_name))
 41 | #         depth = depth[..., np.newaxis]
 42 |         sample1={'image': image, 'depth': depth}
 43 | 
 44 |         if self.transform:  sample1 = self.transform({'image': image, 'depth': depth})
 45 |         return sample1
 46 |     
 47 |     
 48 |     
 49 | class Augmentation(object):
 50 |     def __init__(self, probability):
 51 |         from itertools import permutations
 52 |         self.probability = probability
 53 |         #generate some output like this [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
 54 |         self.indices = list(permutations(range(3), 3))
 55 |         #followed by randomly picking one channel in the list above
 56 |     
 57 |     def __call__(self, sample):
 58 |         image, depth = sample['image'], sample['depth']
 59 | 
 60 |         if not _is_pil_image(image):
 61 |             raise TypeError(
 62 |                 'img should be PIL Image. Got {}'.format(type(image)))
 63 |         if not _is_pil_image(depth):
 64 |             raise TypeError(
 65 |                 'img should be PIL Image. Got {}'.format(type(depth)))
 66 |         
 67 |         # flipping the image
 68 |         if random.random() < 0.5:
 69 |             #random number generated is less than 0.5 then flip image and depth
 70 |             image = image.transpose(Image.FLIP_LEFT_RIGHT)
 71 |             depth = depth.transpose(Image.FLIP_LEFT_RIGHT)
 72 |         
 73 |         # rearranging the channels    
 74 |         if random.random() < self.probability:
 75 |             image = np.asarray(image)
 76 |             image = Image.fromarray(image[...,list(self.indices[random.randint(0, len(self.indices) - 1)])])    
 77 | 
 78 |         return {'image': image, 'depth': depth}
 79 |     
 80 | 
 81 | 
 82 | class ToTensor(object):
 83 |     def __init__(self,is_test=False):
 84 |         self.is_test = is_test
 85 | 
 86 |     def __call__(self, sample):
 87 |         image, depth = sample['image'], sample['depth']
 88 |         
 89 | 
 90 |         image = self.to_tensor(image)
 91 | 
 92 |         depth = depth.resize((160, 120))
 93 | 
 94 |         if self.is_test:
 95 |             depth = self.to_tensor(depth).float() / 1000
 96 |         else:            
 97 |             depth = self.to_tensor(depth).float() * 1000
 98 |         
 99 |         # put in expected range
100 |         depth = torch.clamp(depth, 10, 1000)
101 | 
102 |         return {'image': image, 'depth': depth}
103 | 
104 |     def to_tensor(self, pic):
105 |         pic = np.array(pic)
106 |         if not (_is_numpy_image(pic) or _is_pil_image(pic)):
107 |                 raise TypeError(  'pic should be PIL Image or ndarray. Got {}'.format(type(pic)))
108 |              
109 |         if isinstance(pic, np.ndarray):
110 |             if pic.ndim==2:
111 |                 pic=pic[..., np.newaxis]
112 |                 
113 |             img = torch.from_numpy(pic.transpose((2, 0, 1)))
114 | 
115 |             return img.float().div(255)


--------------------------------------------------------------------------------
/Densenet_depth_model/DepthImageVisualize.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 19,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import pandas as pd\n",
 10 |     "import os\n",
 11 |     "from sklearn.utils import shuffle\n",
 12 |     "from skimage import io, transform\n",
 13 |     "import matplotlib.pyplot as plt"
 14 |    ]
 15 |   },
 16 |   {
 17 |    "cell_type": "code",
 18 |    "execution_count": 20,
 19 |    "metadata": {},
 20 |    "outputs": [
 21 |     {
 22 |      "name": "stdout",
 23 |      "output_type": "stream",
 24 |      "text": [
 25 |       "0.5843137254901961\n",
 26 |       "0.14901960784313725\n"
 27 |      ]
 28 |     },
 29 |     {
 30 |      "data": {
 31 |       "text/plain": [
 32 |        "<matplotlib.image.AxesImage at 0x7f9e537dbda0>"
 33 |       ]
 34 |      },
 35 |      "execution_count": 20,
 36 |      "metadata": {},
 37 |      "output_type": "execute_result"
 38 |     },
 39 |     {
 40 |      "data": {
 41 |       "image/png": "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\n",
 42 |       "text/plain": [
 43 |        "<Figure size 432x288 with 1 Axes>"
 44 |       ]
 45 |      },
 46 |      "metadata": {
 47 |       "needs_background": "light"
 48 |      },
 49 |      "output_type": "display_data"
 50 |     },
 51 |     {
 52 |      "data": {
 53 |       "image/png": "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\n",
 54 |       "text/plain": [
 55 |        "<Figure size 432x288 with 1 Axes>"
 56 |       ]
 57 |      },
 58 |      "metadata": {
 59 |       "needs_background": "light"
 60 |      },
 61 |      "output_type": "display_data"
 62 |     }
 63 |    ],
 64 |    "source": [
 65 |     "#for testing image\n",
 66 |     "traincsv=pd.read_csv('/workspace/data/nyu2_train.csv')\n",
 67 |     "traincsv = traincsv.rename(columns={'data/nyu2_train/living_room_0038_out/37.jpg': 'image', 'data/nyu2_train/living_room_0038_out/37.png': 'depth'})\n",
 68 |     "traincsv = shuffle(traincsv, random_state=1)\n",
 69 |     "root_dir='/workspace/'\n",
 70 |     "img_name = os.path.join(root_dir,traincsv.iloc[2,0])\n",
 71 |     "image = io.imread(img_name)\n",
 72 |     "depth_name = os.path.join(root_dir,traincsv.iloc[2,1])\n",
 73 |     "depth_image = io.imread((depth_name))\n",
 74 |     "from skimage import img_as_float\n",
 75 |     "depth_float = img_as_float(depth_image)\n",
 76 |     "print(depth_float.max())\n",
 77 |     "print(depth_float.min())\n",
 78 |     "\n",
 79 |     "plt.imshow(image)\n",
 80 |     "plt.figure()\n",
 81 |     "plt.imshow(depth_image)"
 82 |    ]
 83 |   }
 84 |  ],
 85 |  "metadata": {
 86 |   "kernelspec": {
 87 |    "display_name": "Python 3",
 88 |    "language": "python",
 89 |    "name": "python3"
 90 |   },
 91 |   "language_info": {
 92 |    "codemirror_mode": {
 93 |     "name": "ipython",
 94 |     "version": 3
 95 |    },
 96 |    "file_extension": ".py",
 97 |    "mimetype": "text/x-python",
 98 |    "name": "python",
 99 |    "nbconvert_exporter": "python",
100 |    "pygments_lexer": "ipython3",
101 |    "version": "3.6.9"
102 |   }
103 |  },
104 |  "nbformat": 4,
105 |  "nbformat_minor": 2
106 | }
107 | 


--------------------------------------------------------------------------------
/Densenet_depth_model/UtilityTest.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import glob
 3 | import time
 4 | from PIL import Image
 5 | import numpy as np
 6 | import PIL
 7 | import random
 8 | import torch
 9 | import matplotlib.pyplot as plt
10 | from torch.utils.data import Dataset, DataLoader
11 | from torchvision import transforms, utils
12 | 
13 | def _is_pil_image(img):
14 |     return isinstance(img, Image.Image)
15 | 
16 | def _is_numpy_image(img):
17 |     return isinstance(img, np.ndarray) and (img.ndim in {2, 3})
18 | 
19 | class DepthDataset(Dataset):
20 |     def __init__(self, root_dir, transform=None):
21 |         
22 |         self.root_dir = root_dir
23 |         self.transform = transform
24 | 
25 |     def __len__(self):
26 |         return len(os.listdir(self.root_dir))
27 | 
28 |     def __getitem__(self, idx):
29 |         
30 |         img_name = os.path.join(self.root_dir,os.listdir(self.root_dir)[idx])
31 |         image = (Image.open(img_name))
32 | 
33 |         sample1={'image': image}
34 | 
35 |         if self.transform:  sample1 = self.transform({'image': image})
36 |         return sample1
37 |     
38 |     
39 | 
40 | class ToTensor(object):
41 |     def __init__(self,is_test=False):
42 |         self.is_test = is_test
43 | 
44 |     def __call__(self, sample):
45 |         image= sample['image']
46 |         
47 |         image = image.resize((640, 480))
48 |         image = self.to_tensor(image)
49 | 
50 |         return {'image': image}
51 | 
52 |     def to_tensor(self, pic):
53 |         pic = np.array(pic)
54 |         if not (_is_numpy_image(pic) or _is_pil_image(pic)):
55 |                 raise TypeError(  'pic should be PIL Image or ndarray. Got {}'.format(type(pic)))
56 |                              
57 |         if isinstance(pic, np.ndarray):
58 |             if pic.ndim==2:
59 |                 pic=pic[..., np.newaxis]
60 |                 
61 |             img = torch.from_numpy(pic.transpose((2, 0, 1)))
62 | 
63 |             return img.float().div(255)


--------------------------------------------------------------------------------
/Densenet_depth_model/model_dense.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Created on Sun Dec 29 23:17:26 2019
 3 | 
 4 | @author: alin
 5 | """
 6 | 
 7 | import torch
 8 | import torch.nn as nn
 9 | import torch.nn.functional as F
10 | 
11 | class UpSample(nn.Sequential):
12 |     def __init__(self, skip_input, output_features):
13 |         super(UpSample, self).__init__()        
14 |         self.convA = nn.Conv2d(skip_input, output_features, kernel_size=3, stride=1, padding=1)
15 |         self.leakyreluA = nn.LeakyReLU(0.2)
16 |         self.convB = nn.Conv2d(output_features, output_features, kernel_size=3, stride=1, padding=1)
17 |         self.leakyreluB = nn.LeakyReLU(0.2)
18 | 
19 |     def forward(self, x, concat_with):
20 |         #interpolate x from x.size to larger size(concat_with.shape=(C,H,W))
21 |         up_x = F.interpolate(x, size=[concat_with.size(2), concat_with.size(3)], mode='bilinear', align_corners=True)
22 |         return self.leakyreluB( self.convB( self.leakyreluA(self.convA( torch.cat([up_x, concat_with], dim=1) ) ) )  )
23 | 
24 | class Decoder(nn.Module):
25 |     def __init__(self, num_features=2208, decoder_width = 0.25):
26 |         super(Decoder, self).__init__()
27 |         features = int(num_features * decoder_width)
28 | 
29 |         self.conv2 = nn.Conv2d(num_features, features, kernel_size=1, stride=1, padding=1)
30 | 
31 |         self.up1 = UpSample(skip_input=features//1 + 384, output_features=features//2)
32 |         self.up2 = UpSample(skip_input=features//2 + 192, output_features=features//4)
33 | #         self.up3 = UpSample(skip_input=features//4 +  96, output_features=features//8)
34 |         self.up3 = UpSample(skip_input=features//4 +  96, output_features=features//16)
35 |         self.up4 = UpSample(skip_input=features//8 +  96, output_features=features//16)
36 | 
37 |         self.conv3 = nn.Conv2d(features//16, 1, kernel_size=3, stride=1, padding=1)
38 | 
39 |     def forward(self, features):
40 |         x_block0, x_block1, x_block2, x_block3, x_block4 = features[3], features[4], features[6], features[8], features[11]
41 |         x_d0 = self.conv2(x_block4)
42 |         #15x20 to 15x20
43 |         x_d1 = self.up1(x_d0, x_block3)
44 |         #15x20 to 30x40
45 |         x_d2 = self.up2(x_d1, x_block2)
46 |         #30x40 to 60x80
47 |         x_d3 = self.up3(x_d2, x_block1)
48 |         #60x80 to 120x160
49 | #         x_d4 = self.up4(x_d3, x_block0)
50 |         #120x160 to 240x320
51 |         return self.conv3(x_d3)
52 |        # return self.conv3(x_d4)
53 | 
54 | #Encoder uses the densenet_161 pretrained model
55 | #following encoder encodes the image and store the features output from each output of layer
56 | class Encoder(nn.Module):
57 |     def __init__(self):
58 |         super(Encoder, self).__init__()       
59 |         import torchvision.models as models
60 |         self.original_model = models.densenet161( pretrained=True )
61 | 
62 |     def forward(self, x):
63 |         features = [x]
64 |         for k, v in self.original_model.features._modules.items(): features.append( v(features[-1]) )
65 |         return features
66 | 
67 | class Model(nn.Module):
68 |     def __init__(self):
69 |         super(Model, self).__init__()
70 |         self.encoder = Encoder()
71 |         self.decoder = Decoder()
72 | 
73 |     def forward(self, x):
74 |         return self.decoder( self.encoder(x) )


--------------------------------------------------------------------------------
/Densenet_depth_model/video.avi:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Densenet_depth_model/video.avi


--------------------------------------------------------------------------------
/DepthData_mob.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Created on Sun Dec 29 23:17:26 2019
  3 | 
  4 | @author: alin
  5 | """
  6 | 
  7 | # from torch.utils.data import Dataset, DataLoader
  8 | from torch.utils.data import Dataset, DataLoader
  9 | import os 
 10 | from PIL import Image
 11 | import random
 12 | import numpy as np
 13 | import torch
 14 | 
 15 | #Depth Datasetclass
 16 | 
 17 | def _is_pil_image(img):
 18 |     return isinstance(img, Image.Image)
 19 | 
 20 | def _is_numpy_image(img):
 21 |     return isinstance(img, np.ndarray) and (img.ndim in {2, 3})
 22 | 
 23 | 
 24 | class DepthDataset(Dataset):
 25 |     os = __import__('os')
 26 |     def __init__(self, traincsv, root_dir, transform=None):
 27 |         self.traincsv = traincsv
 28 |         self.root_dir = root_dir
 29 |         self.transform = transform
 30 | 
 31 |     def __len__(self):
 32 |         return len(self.traincsv)
 33 | 
 34 |     def __getitem__(self, idx):
 35 |         
 36 |         sample = self.traincsv[idx]
 37 |         img_name = os.path.join(self.root_dir,sample[0])
 38 |         image = (Image.open(img_name))
 39 |         depth_name = os.path.join(self.root_dir,sample[1])
 40 |         depth =(Image.open(depth_name))
 41 | #         depth = depth[..., np.newaxis]
 42 |         sample1={'image': image, 'depth': depth}
 43 | 
 44 |         if self.transform:  sample1 = self.transform({'image': image, 'depth': depth})
 45 |         return sample1
 46 |     
 47 |     
 48 |     
 49 | class Augmentation(object):
 50 |     def __init__(self, probability):
 51 |         from itertools import permutations
 52 |         self.probability = probability
 53 |         #generate some output like this [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
 54 |         self.indices = list(permutations(range(3), 3))
 55 |         #followed by randomly picking one channel in the list above
 56 |     
 57 |     def __call__(self, sample):
 58 |         image, depth = sample['image'], sample['depth']
 59 | 
 60 |         if not _is_pil_image(image):
 61 |             raise TypeError(
 62 |                 'img should be PIL Image. Got {}'.format(type(image)))
 63 |         if not _is_pil_image(depth):
 64 |             raise TypeError(
 65 |                 'img should be PIL Image. Got {}'.format(type(depth)))
 66 |         
 67 |         # flipping the image
 68 |         if random.random() < 0.5:
 69 |             #random number generated is less than 0.5 then flip image and depth
 70 |             image = image.transpose(Image.FLIP_LEFT_RIGHT)
 71 |             depth = depth.transpose(Image.FLIP_LEFT_RIGHT)
 72 |         
 73 |         # rearranging the channels    
 74 |         if random.random() < self.probability:
 75 |             image = np.asarray(image)
 76 |             image = Image.fromarray(image[...,list(self.indices[random.randint(0, len(self.indices) - 1)])])    
 77 | 
 78 |         return {'image': image, 'depth': depth}
 79 |     
 80 | 
 81 | 
 82 | class ToTensor(object):
 83 |     def __init__(self,is_test=False):
 84 |         self.is_test = is_test
 85 | 
 86 |     def __call__(self, sample):
 87 |         image, depth = sample['image'], sample['depth']
 88 |         
 89 | 
 90 |         image = self.to_tensor(image)
 91 | 
 92 |         depth = depth.resize((320, 240))
 93 | 
 94 |         if self.is_test:
 95 |             depth = self.to_tensor(depth).float() / 1000
 96 |         else:            
 97 |             depth = self.to_tensor(depth).float() * 1000
 98 |         
 99 |         # put in expected range
100 |         depth = torch.clamp(depth, 10, 1000)
101 | 
102 |         return {'image': image, 'depth': depth}
103 | 
104 |     def to_tensor(self, pic):
105 |         pic = np.array(pic)
106 |         if not (_is_numpy_image(pic) or _is_pil_image(pic)):
107 |                 raise TypeError(  'pic should be PIL Image or ndarray. Got {}'.format(type(pic)))
108 |              
109 |         if isinstance(pic, np.ndarray):
110 |             if pic.ndim==2:
111 |                 pic=pic[..., np.newaxis]
112 |                 
113 |             img = torch.from_numpy(pic.transpose((2, 0, 1)))
114 | 
115 |             return img.float().div(255)


--------------------------------------------------------------------------------
/Example generated images/10_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/10_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/10_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/10_image.jpg


--------------------------------------------------------------------------------
/Example generated images/11_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/11_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/11_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/11_image.jpg


--------------------------------------------------------------------------------
/Example generated images/12_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/12_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/12_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/12_image.jpg


--------------------------------------------------------------------------------
/Example generated images/13_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/13_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/13_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/13_image.jpg


--------------------------------------------------------------------------------
/Example generated images/14_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/14_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/14_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/14_image.jpg


--------------------------------------------------------------------------------
/Example generated images/15_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/15_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/15_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/15_image.jpg


--------------------------------------------------------------------------------
/Example generated images/16_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/16_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/16_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/16_image.jpg


--------------------------------------------------------------------------------
/Example generated images/17_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/17_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/17_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/17_image.jpg


--------------------------------------------------------------------------------
/Example generated images/18_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/18_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/18_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/18_image.jpg


--------------------------------------------------------------------------------
/Example generated images/2_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/2_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/2_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/2_image.jpg


--------------------------------------------------------------------------------
/Example generated images/3_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/3_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/3_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/3_image.jpg


--------------------------------------------------------------------------------
/Example generated images/4_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/4_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/4_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/4_image.jpg


--------------------------------------------------------------------------------
/Example generated images/6_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/6_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/6_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/6_image.jpg


--------------------------------------------------------------------------------
/Example generated images/7_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/7_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/7_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/7_image.jpg


--------------------------------------------------------------------------------
/Example generated images/8_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/8_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/8_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/8_image.jpg


--------------------------------------------------------------------------------
/Example generated images/9_depth.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/9_depth.jpg


--------------------------------------------------------------------------------
/Example generated images/9_image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/Example generated images/9_image.jpg


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Alinstein Jose
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Mobile_model.py:
--------------------------------------------------------------------------------
 1 | import torch
 2 | import torch.nn as nn
 3 | import torch.nn.functional as F
 4 | 
 5 | class UpSample(nn.Sequential):
 6 |     def __init__(self, skip_input, output_features):
 7 |         super(UpSample, self).__init__()        
 8 |         self.convA = nn.Conv2d(skip_input, output_features, kernel_size=3, stride=1, padding=1)
 9 |         self.leakyreluA = nn.LeakyReLU(0.2)
10 |         self.convB = nn.Conv2d(output_features, output_features, kernel_size=3, stride=1, padding=1)
11 |         self.leakyreluB = nn.LeakyReLU(0.2)
12 | 
13 |     def forward(self, x, concat_with):
14 |         up_x = F.interpolate(x, size=[concat_with.size(2), concat_with.size(3)], mode='bilinear', align_corners=True)
15 |         return self.leakyreluB( self.convB( self.leakyreluA(self.convA( torch.cat([up_x, concat_with], dim=1) ) ) )  )
16 | 
17 | class Decoder(nn.Module):
18 |     def __init__(self, num_features=1280, decoder_width = .6):
19 |         super(Decoder, self).__init__()
20 |         features = int(num_features * decoder_width)
21 | 
22 |         self.conv2 = nn.Conv2d(num_features, features, kernel_size=1, stride=1, padding=1)
23 |         
24 |         self.up0 = UpSample(skip_input=features//1 + 320, output_features=features//2)
25 |         self.up1 = UpSample(skip_input=features//2 + 160, output_features=features//2)
26 |         self.up2 = UpSample(skip_input=features//2 + 64, output_features=features//4)
27 |         self.up3 = UpSample(skip_input=features//4 + 32, output_features=features//8)
28 |         self.up4 = UpSample(skip_input=features//8 +  24, output_features=features//8)
29 |         self.up5 = UpSample(skip_input=features//8 +  16, output_features=features//16)
30 | 
31 |         self.conv3 = nn.Conv2d(features//16, 1, kernel_size=3, stride=1, padding=1)
32 | 
33 |     def forward(self, features):
34 |         x_block0, x_block1, x_block2, x_block3, x_block4,x_block5,x_block6 = features[2], features[4], features[6], features[9], features[15],features[18],features[19]
35 |         x_d0 = self.conv2(x_block6)
36 |         x_d1 = self.up0(x_d0, x_block5)
37 |         x_d2 = self.up1(x_d1, x_block4)
38 |         x_d3 = self.up2(x_d2, x_block3)
39 |         x_d4 = self.up3(x_d3, x_block2)
40 |         x_d5 = self.up4(x_d4, x_block1)
41 |         x_d6 = self.up5(x_d5, x_block0)
42 |         return self.conv3(x_d6)
43 | 
44 | class Encoder(nn.Module):
45 |     def __init__(self):
46 |         super(Encoder, self).__init__()       
47 |         import torchvision.models as models
48 |         self.original_model = models.mobilenet_v2( pretrained=True )
49 | 
50 |     def forward(self, x):
51 |         features = [x]
52 |         for k, v in self.original_model.features._modules.items(): features.append( v(features[-1]) )
53 |         return features
54 | 
55 | class Model(nn.Module):
56 |     def __init__(self):
57 |         super(Model, self).__init__()
58 |         self.encoder = Encoder()
59 |         self.decoder = Decoder()
60 | 
61 |     def forward(self, x):
62 |         return self.decoder( self.encoder(x) )


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Monocular Depth Estimation with Transfer Learning pretrained MobileNetV2
 2 | 
 3 | 
 4 | This project implements a deep learning neural network model to generate the depth image of a given image.
 5 | Model is a U-net model with MobileNetV2 as the encoder, and model has utilized skip connection from encoder to decoder.
 6 | Model generates a depth image of resolution 480x640 for input image of same size.
 7 | 
 8 | ![Results](https://github.com/alinstein/Depth_estimation/blob/master/CombineGIF.gif)
 9 | 
10 | 
11 | This project was implemented taking reference from the following paper: 
12 | 
13 | [High Quality Monocular Depth Estimation via Transfer Learning (arXiv 2018)](https://arxiv.org/abs/1812.11941)
14 | **[Ibraheem Alhashim]** and **Peter Wonka**
15 | 
16 | ## Getting Started
17 | 
18 | ##### Model is trained using the IPYTHON file "train_mobilenetv2.ipynb".
19 | 
20 | * Download the dataset and give the location of dataset.
21 | * Change the following according to the needs: batch_size, epochs, lr (learning rate).
22 | Load the pretrained model if needed.
23 |  
24 | ##### IPYTHON file "test_img.ipynb" can be used to generate the depth image on pretrained model.
25 | 
26 | * Give the location for the dictionary of images to be converted and load the pretrained model
27 | 
28 | ##### IPYTHON file "test_video.ipynb" can be used to generate the depth video on pretrained model.
29 | 
30 | * Give the location for the dictionary of images to be converted and load the pretrained model.
31 | 
32 | #### Implementation of the Depth estimation using Densenet model is in the folder "Densenet_depth_model".
33 | 
34 | 
35 | ## Dataset 
36 | * [NYU Depth V2 (50K)](https://s3-eu-west-1.amazonaws.com/densedepth/nyu_data.zip) (4.1 GB): File is extraced while running the "train_mobilenetv2.ipynb".
37 | 
38 | ## Download the pretrained model 
39 | * [Mobilenet](https://drive.google.com/drive/folders/1rDvtiwUgYbhzk8ZPdQ176abv-u6SaZzI?usp=sharing) (55 MB). Pretrained model is trained on 2 NVIDIA GeForce GTX 1080 for 6 hours(6 epoches). 
40 | 
41 | ## Author
42 | 
43 | Written by Alinstein Jose, University of Victoria.
44 | 
45 | 


--------------------------------------------------------------------------------
/UtilityTest.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import glob
 3 | import time
 4 | from PIL import Image
 5 | import numpy as np
 6 | import PIL
 7 | import random
 8 | import torch
 9 | import matplotlib.pyplot as plt
10 | from torch.utils.data import Dataset, DataLoader
11 | from torchvision import transforms, utils
12 | 
13 | def _is_pil_image(img):
14 |     return isinstance(img, Image.Image)
15 | 
16 | def _is_numpy_image(img):
17 |     return isinstance(img, np.ndarray) and (img.ndim in {2, 3})
18 | 
19 | class DepthDataset(Dataset):
20 |     def __init__(self, root_dir, transform=None):
21 |         
22 |         self.root_dir = root_dir
23 |         self.transform = transform
24 | 
25 |     def __len__(self):
26 |         return len(os.listdir(self.root_dir))
27 | 
28 |     def __getitem__(self, idx):
29 |         
30 |         img_name = os.path.join(self.root_dir,os.listdir(self.root_dir)[idx])
31 |         image = (Image.open(img_name))
32 | 
33 |         sample1={'image': image}
34 | 
35 |         if self.transform:  sample1 = self.transform({'image': image})
36 |         return sample1
37 |     
38 |     
39 | 
40 | class ToTensor(object):
41 |     def __init__(self,is_test=False):
42 |         self.is_test = is_test
43 | 
44 |     def __call__(self, sample):
45 |         image= sample['image']
46 |         
47 |         image = image.resize((640, 480))
48 |         image = self.to_tensor(image)
49 | 
50 |         return {'image': image}
51 | 
52 |     def to_tensor(self, pic):
53 |         pic = np.array(pic)
54 |         if not (_is_numpy_image(pic) or _is_pil_image(pic)):
55 |                 raise TypeError(  'pic should be PIL Image or ndarray. Got {}'.format(type(pic)))
56 |                              
57 |         if isinstance(pic, np.ndarray):
58 |             if pic.ndim==2:
59 |                 pic=pic[..., np.newaxis]
60 |                 
61 |             img = torch.from_numpy(pic.transpose((2, 0, 1)))
62 | 
63 |             return img.float().div(255)


--------------------------------------------------------------------------------
/movie_depth.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/movie_depth.gif


--------------------------------------------------------------------------------
/movie_real.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alinstein/Depth_estimation/49f1d5e6f6f141c697efa3edc02264e2b5b4e1a4/movie_real.gif


--------------------------------------------------------------------------------
/test_video.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": null,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import cv2\n",
 10 |     "import os\n",
 11 |     "import glob\n",
 12 |     "import time\n",
 13 |     "from PIL import Image\n",
 14 |     "import numpy as np\n",
 15 |     "import PIL\n",
 16 |     "import imageio\n",
 17 |     "import random\n",
 18 |     "import torch\n",
 19 |     "import matplotlib.pyplot as plt\n",
 20 |     "from torch.utils.data import Dataset, DataLoader\n",
 21 |     "from torchvision import transforms, utils\n",
 22 |     "\n",
 23 |     "from UtilityTest import DepthDataset\n",
 24 |     "from UtilityTest import ToTensor"
 25 |    ]
 26 |   },
 27 |   {
 28 |    "cell_type": "code",
 29 |    "execution_count": null,
 30 |    "metadata": {},
 31 |    "outputs": [],
 32 |    "source": [
 33 |     "Location_video='/workspace/test_vid/VID_20200102_142929.mp4'"
 34 |    ]
 35 |   },
 36 |   {
 37 |    "cell_type": "code",
 38 |    "execution_count": null,
 39 |    "metadata": {},
 40 |    "outputs": [],
 41 |    "source": [
 42 |     "#Extract the video from zipfile\n",
 43 |     "from zipfile import ZipFile\n",
 44 |     "zf = ZipFile('/workspace/test_vid.zip', 'r')\n",
 45 |     "zf.extractall('/workspace/')\n",
 46 |     "zf.close()"
 47 |    ]
 48 |   },
 49 |   {
 50 |    "cell_type": "code",
 51 |    "execution_count": null,
 52 |    "metadata": {},
 53 |    "outputs": [],
 54 |    "source": [
 55 |     "#converting video into frames\n",
 56 |     "vidcap = cv2.VideoCapture(Location_video)\n",
 57 |     "success,image = vidcap.read()\n",
 58 |     "count = 0\n",
 59 |     "while success:\n",
 60 |     "  cv2.imwrite(\"/workspace/test_vid/Frames/frame%d.jpg\" % count, image)     # save frame as JPEG file      \n",
 61 |     "  success,image = vidcap.read()\n",
 62 |     "  print('Read a new frame: ', success)\n",
 63 |     "  count += 1"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": null,
 69 |    "metadata": {},
 70 |    "outputs": [],
 71 |    "source": [
 72 |     "#location of video frames\n",
 73 |     "loc_img='/workspace/test_vid/Frames/'\n",
 74 |     "\n",
 75 |     "#ploting few sample frames\n",
 76 |     "depth_dataset = DepthDataset(root_dir=loc_img)\n",
 77 |     "fig = plt.figure()\n",
 78 |     "len(depth_dataset)\n",
 79 |     "for i in range(len(depth_dataset)):\n",
 80 |     "    sample = depth_dataset[i]\n",
 81 |     "\n",
 82 |     "    print(i, sample['image'].size)\n",
 83 |     "\n",
 84 |     "\n",
 85 |     "    plt.imshow(sample['image'])\n",
 86 |     "    plt.figure()\n",
 87 |     "\n",
 88 |     "\n",
 89 |     "    if i == 2:\n",
 90 |     "        plt.show()\n",
 91 |     "        break"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "code",
 96 |    "execution_count": null,
 97 |    "metadata": {},
 98 |    "outputs": [],
 99 |    "source": [
100 |     "depth_dataset = DepthDataset(root_dir=loc_img,transform=transforms.Compose([ToTensor()]))\n",
101 |     "# depth_dataset\n",
102 |     "batch_size=1\n",
103 |     "train_loader=torch.utils.data.DataLoader(depth_dataset, batch_size)\n",
104 |     "# train_loader\n",
105 |     "dataiter = iter(train_loader)\n",
106 |     "images = dataiter.next()\n"
107 |    ]
108 |   },
109 |   {
110 |    "cell_type": "code",
111 |    "execution_count": null,
112 |    "metadata": {},
113 |    "outputs": [],
114 |    "source": [
115 |     "import torch\n",
116 |     "import torch.nn as nn\n",
117 |     "import torch.nn.utils as utils\n",
118 |     "import torchvision.utils as vutils    \n",
119 |     "import torchvision.models as models\n",
120 |     "from Mobile_model import Model\n",
121 |     "model = Model().cuda()\n",
122 |     "model = nn.DataParallel(model)\n",
123 |     "#loading the the trained model\n",
124 |     "model.load_state_dict(torch.load('/workspace/17.pth'))\n",
125 |     "model.eval()\n"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": null,
131 |    "metadata": {},
132 |    "outputs": [],
133 |    "source": [
134 |     "os.mkdir('/workspace/test_vid/depth_frames/')\n",
135 |     "\n",
136 |     "#generating the depth image of frames\n",
137 |     "\n",
138 |     "import matplotlib.cm as cm\n",
139 |     "for i,sample_batched1  in enumerate (train_loader):\n",
140 |     "    image1 = torch.autograd.Variable(sample_batched1['image'].cuda())\n",
141 |     "    \n",
142 |     "    outtt=model(image1 )\n",
143 |     "    x=outtt.detach().cpu().numpy()\n",
144 |     "    x.shape\n",
145 |     "    x=x.reshape(240,320)\n",
146 |     "    img=x\n",
147 |     "    scale_percent = 200 # percent of original size\n",
148 |     "    width = int(img.shape[1] * scale_percent / 100)\n",
149 |     "    height = int(img.shape[0] * scale_percent / 100)\n",
150 |     "    dim = (width, height)\n",
151 |     "    # resize image\n",
152 |     "    resized = cv2.resize(img, dim, interpolation = cv2.INTER_AREA)\n",
153 |     "    plt.imsave('/workspace/test_vid/depth_frames/geeks%d.jpg' %i, resized, cmap='inferno')\n"
154 |    ]
155 |   },
156 |   {
157 |    "cell_type": "code",
158 |    "execution_count": null,
159 |    "metadata": {},
160 |    "outputs": [],
161 |    "source": [
162 |     "from os.path import isfile, join\n",
163 |     " \n",
164 |     "def convert_frames_to_video(pathIn,pathOut,fps):\n",
165 |     "    frame_array = []\n",
166 |     "    files = [f for f in os.listdir(pathIn) if isfile(join(pathIn, f))]\n",
167 |     " \n",
168 |     "    #for sorting the file names properly\n",
169 |     "    files.sort(key = lambda x: int(x[5:-4]))\n",
170 |     " \n",
171 |     "    for i in range(len(files)):\n",
172 |     "        filename=pathIn + files[i]\n",
173 |     "        #reading each files\n",
174 |     "        img = cv2.imread(filename)\n",
175 |     "        height, width, layers = img.shape\n",
176 |     "        size = (width,height)\n",
177 |     "        print(filename)\n",
178 |     "        #inserting the frames into an image array\n",
179 |     "        frame_array.append(img)\n",
180 |     " \n",
181 |     "    out = cv2.VideoWriter(pathOut,cv2.VideoWriter_fourcc(*'MP4V'), fps, size)\n",
182 |     " \n",
183 |     "    for i in range(len(frame_array)):\n",
184 |     "        # writing to a image array\n",
185 |     "        out.write(frame_array[i])\n",
186 |     "    out.release()\n",
187 |     " "
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "code",
192 |    "execution_count": null,
193 |    "metadata": {},
194 |    "outputs": [],
195 |    "source": [
196 |     "    #convert frames to videos\n",
197 |     "    pathIn= '/workspace/test_vid/depth_frames/'\n",
198 |     "    pathOut = '/workspace/test_vid/video1.mp4'\n",
199 |     "    #enter the correct frame rates\n",
200 |     "    fps = 30.01\n",
201 |     "    convert_frames_to_video(pathIn, pathOut, fps)"
202 |    ]
203 |   },
204 |   {
205 |    "cell_type": "code",
206 |    "execution_count": null,
207 |    "metadata": {},
208 |    "outputs": [],
209 |    "source": [
210 |     "#converting the frames to gif\n",
211 |     "\n",
212 |     "filenames='/workspace/test_vid/depth_frames/'\n",
213 |     "files = [f for f in os.listdir(filenames) if isfile(join(filenames, f))]\n",
214 |     "\n",
215 |     "files.sort(key = lambda x: int(float(x[5:-4])))\n",
216 |     "files\n",
217 |     "images = []\n",
218 |     "for i,filename in enumerate(files):\n",
219 |     "    if i%10==0:\n",
220 |     "        images.append(imageio.imread(os.path.join('/workspace/test_vid/depth_frames/',filename)))\n",
221 |     "        print(filename)\n",
222 |     "imageio.mimsave('/workspace/test_vid/movie_depth.gif', images)"
223 |    ]
224 |   },
225 |   {
226 |    "cell_type": "code",
227 |    "execution_count": null,
228 |    "metadata": {},
229 |    "outputs": [],
230 |    "source": [
231 |     "from skimage import transform,io\n",
232 |     "filenames='/workspace/test_vid/Frames/'\n",
233 |     "files = [f for f in os.listdir(filenames) if isfile(join(filenames, f))]\n",
234 |     "\n",
235 |     "files.sort(key = lambda x: int(float(x[5:-4])))\n",
236 |     "files\n",
237 |     "images = []\n",
238 |     "for i,filename in enumerate(files):\n",
239 |     "    if i%10==0:\n",
240 |     "       \n",
241 |     "\n",
242 |     "            # resize to 28x28\n",
243 |     "        grey=(imageio.imread(os.path.join('/workspace/test_vid/Frames/',filename)))\n",
244 |     "        image = transform.resize(grey, (480,640), mode='symmetric', preserve_range=True)\n",
245 |     "        images.append(image)\n",
246 |     "        print(filename)\n",
247 |     "imageio.mimsave('/workspace/test_vid/movie_real.gif', images)"
248 |    ]
249 |   }
250 |  ],
251 |  "metadata": {
252 |   "kernelspec": {
253 |    "display_name": "Python 3",
254 |    "language": "python",
255 |    "name": "python3"
256 |   },
257 |   "language_info": {
258 |    "codemirror_mode": {
259 |     "name": "ipython",
260 |     "version": 3
261 |    },
262 |    "file_extension": ".py",
263 |    "mimetype": "text/x-python",
264 |    "name": "python",
265 |    "nbconvert_exporter": "python",
266 |    "pygments_lexer": "ipython3",
267 |    "version": "3.6.9"
268 |   }
269 |  },
270 |  "nbformat": 4,
271 |  "nbformat_minor": 2
272 | }
273 | 


--------------------------------------------------------------------------------