├── .bluemix
├── Dockerfile
├── deploy.json
├── icon.svg
├── pipeline.yml
├── toolchain.svg
└── toolchain.yml
├── .gitignore
├── .travis.yml
├── Dockerfile
├── README.md
├── app.js
├── bin
└── www
├── detected_images
└── output.jpg
├── error.html
├── kubernetes
├── kube-config.yml
├── local-volumes.yaml
└── postgres.yaml
├── package-lock.json
├── package.json
├── public
└── stylesheets
│ └── style.css
├── routes
├── index.js
└── users.js
├── sample_videos
└── vid10.mp4
├── scripts
├── bx_auth.sh
├── cv_object_detection.py
├── deploy.sh
├── install.sh
├── object_detection.cpp
├── quickstart.sh
└── resources.sh
└── views
├── error.jade
├── error.pug
├── index.html
├── index.jade
├── index.pug
├── layout.jade
└── layout.pug
/.bluemix/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM kkbankol/opencv_yolo
2 | ADD . /opt/cameras_app
3 | ADD bin/example_dnn_object_detection /nodejsAction/cv/example_dnn_object_detection
4 | RUN cd /opt/cameras_app && rm -rf node_modules && npm install
5 | RUN cp /nodejsAction/cv/object_detection_classes_yolov3.txt /tmp/object_detection_classes_yolov3.txt
6 | CMD cd /opt/cameras_app && npm start
7 |
--------------------------------------------------------------------------------
/.bluemix/deploy.json:
--------------------------------------------------------------------------------
1 | {
2 | "$schema": "http://json-schema.org/draft-04/schema#",
3 | "title": "Sample Deploy Stage",
4 | "description": "sample toolchain",
5 | "longDescription": "The Delivery Pipeline automates continuous deployment.",
6 | "type": "object",
7 | "properties": {
8 | "prod-region": {
9 | "description": "The bluemix region",
10 | "type": "string"
11 | },
12 | "prod-organization": {
13 | "description": "The bluemix org",
14 | "type": "string"
15 | },
16 | "prod-space": {
17 | "description": "The bluemix space",
18 | "type": "string"
19 | },
20 | "prod-app-name": {
21 | "description": "The name of your Drupal app",
22 | "type": "string"
23 | },
24 | "bluemix-user": {
25 | "description": "Your Bluemix user ID",
26 | "type": "string"
27 | },
28 | "bluemix-password": {
29 | "description": "Your Bluemix Password",
30 | "type": "string"
31 | },
32 | "bluemix-api-key": {
33 | "description": "Required for **Federated ID** since Federated ID can't login with Bluemix user and password via Bluemix CLI. You can obtain your API_KEY via https://console.ng.bluemix.net/iam/#/apikeys by clicking **Create API key** (Each API key only can be viewed once).",
34 | "type": "string"
35 | },
36 | "bluemix-cluster-account": {
37 | "description": "The GUID of the Bluemix account where you created the cluster. Retrieve it with [bx iam accounts].",
38 | "type": "string"
39 | },
40 | "bluemix-cluster-name": {
41 | "description": "Your cluster name. Retrieve it with [bx cs clusters].",
42 | "type": "string"
43 | }
44 | },
45 | "required": ["prod-region", "prod-organization", "prod-space", "bluemix-cluster-name"],
46 | "anyOf": [
47 | {
48 | "required": ["bluemix-user", "bluemix-password", "bluemix-cluster-account"]
49 | },
50 | {
51 | "required": ["bluemix-api-key"]
52 | }
53 | ],
54 | "form": [
55 | {
56 | "type": "validator",
57 | "url": "/devops/setup/bm-helper/helper.html"
58 | },
59 | {
60 | "type": "text",
61 | "readonly": false,
62 | "title": "Bluemix User ID",
63 | "key": "bluemix-user"
64 | },{
65 | "type": "password",
66 | "readonly": false,
67 | "title": "Bluemix Password",
68 | "key": "bluemix-password"
69 | },{
70 | "type": "password",
71 | "readonly": false,
72 | "title": "Bluemix API Key (Optional)",
73 | "key": "bluemix-api-key"
74 | },{
75 | "type": "password",
76 | "readonly": false,
77 | "title": "Bluemix Cluster Account ID",
78 | "key": "bluemix-cluster-account"
79 | },{
80 | "type": "text",
81 | "readonly": false,
82 | "title": "Bluemix Cluster Name",
83 | "key": "bluemix-cluster-name"
84 | },
85 | {
86 | "type": "table",
87 | "columnCount": 4,
88 | "widths": ["15%", "28%", "28%", "28%"],
89 | "items": [
90 | {
91 | "type": "label",
92 | "title": ""
93 | },
94 | {
95 | "type": "label",
96 | "title": "Region"
97 | },
98 | {
99 | "type": "label",
100 | "title": "Organization"
101 | },
102 | {
103 | "type": "label",
104 | "title": "Space"
105 | },
106 | {
107 | "type": "label",
108 | "title": "Production stage"
109 | },
110 | {
111 | "type": "select",
112 | "key": "prod-region"
113 | },
114 | {
115 | "type": "select",
116 | "key": "prod-organization"
117 | },
118 | {
119 | "type": "select",
120 | "key": "prod-space",
121 | "readonly": false
122 | }
123 | ]
124 | }
125 | ]
126 | }
127 |
--------------------------------------------------------------------------------
/.bluemix/icon.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
36 |
--------------------------------------------------------------------------------
/.bluemix/pipeline.yml:
--------------------------------------------------------------------------------
1 | ---
2 | stages:
3 | - name: Build
4 | inputs:
5 | - type: git
6 | branch: master
7 | # service: ${SAMPLE_REPO}
8 | triggers:
9 | - type: commit
10 | jobs:
11 | - name: Build
12 | type: builder
13 | artifact_dir: ''
14 | build_type: shell
15 | script: |-
16 | #!/bin/bash
17 | bash -n *.sh
18 | - name: Deploy
19 | inputs:
20 | - type: job
21 | stage: Build
22 | job: Build
23 | dir_name: null
24 | triggers:
25 | - type: stage
26 | properties:
27 | - name: BLUEMIX_USER
28 | type: text
29 | value: ${BLUEMIX_USER}
30 | - name: BLUEMIX_PASSWORD
31 | type: secure
32 | value: ${BLUEMIX_PASSWORD}
33 | - name: BLUEMIX_ACCOUNT
34 | type: secure
35 | value: ${BLUEMIX_ACCOUNT}
36 | - name: CLUSTER_NAME
37 | type: text
38 | value: ${CLUSTER_NAME}
39 | - name: API_KEY
40 | type: secure
41 | value: ${API_KEY}
42 | jobs:
43 | - name: Deploy
44 | type: deployer
45 | target:
46 | region_id: ${PROD_REGION_ID}
47 | api_key: ${API_KEY}
48 | kubernetes_cluster: ${CLUSTER_NAME}
49 | application: Pipeline
50 | script: |
51 | #!/bin/bash
52 | ./scripts/deploy.sh
53 | # hooks:
54 | # - enabled: true
55 | # label: null
56 | # ssl_enabled: false
57 | # url: https://devops-api-integration.stage1.ng.bluemix.net/v1/messaging/webhook/publish
58 |
--------------------------------------------------------------------------------
/.bluemix/toolchain.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/.bluemix/toolchain.yml:
--------------------------------------------------------------------------------
1 | # ---
2 | # name: "Deploy YOLO / Opencv object detection in Bluemix"
3 | # description: "Toolchain to deploy Opencv on Kubernetes in Bluemix"
4 | # version: 0.1
5 | # image: data:image/svg+xml;base64,$file(toolchain.svg,base64)
6 | # icon: data:image/svg+xml;base64,$file(icon.svg,base64)
7 | # required:
8 | # - deploy
9 | # - sample-repo
10 | #
11 | # # Github repos
12 | # sample-repo:
13 | # service_id: githubpublic
14 | # parameters:
15 | # repo_name: dnn-object-detection
16 | # repo_url: https://github.com/kkbankol-ibm/dnn-object-detection
17 | # type: clone
18 | # has_issues: false
19 | #
20 | # # Pipelines
21 | # sample-build:
22 | # service_id: pipeline
23 | # parameters:
24 | # name: "{{name}}"
25 | # ui-pipeline: true
26 | # configuration:
27 | # content: $file(pipeline.yml)
28 | # env:
29 | # SAMPLE_REPO: "sample-repo"
30 | # CF_APP_NAME: "{{deploy.parameters.prod-app-name}}"
31 | # PROD_SPACE_NAME: "{{deploy.parameters.prod-space}}"
32 | # PROD_ORG_NAME: "{{deploy.parameters.prod-organization}}"
33 | # PROD_REGION_ID: "{{deploy.parameters.prod-region}}"
34 | # BLUEMIX_USER: "{{deploy.parameters.bluemix-user}}"
35 | # BLUEMIX_PASSWORD: "{{deploy.parameters.bluemix-password}}"
36 | # API_KEY: "{{deploy.parameters.bluemix-api-key}}"
37 | # BLUEMIX_ACCOUNT: "{{deploy.parameters.bluemix-cluster-account}}"
38 | # CLUSTER_NAME: "{{deploy.parameters.bluemix-cluster-name}}"
39 | # execute: true
40 | # services: ["sample-repo"]
41 | # hidden: [form, description]
42 | #
43 | # # Deployment
44 | # deploy:
45 | # schema:
46 | # $ref: deploy.json
47 | # service-category: pipeline
48 | # parameters:
49 | # prod-app-name: "{{sample-repo.parameters.repo_name}}"
50 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .env
2 | uploads
3 | node_modules/
4 | motion_images
5 |
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | ---
2 | language: python
3 | python: 2.7
4 | cache: pip
5 | sudo: required
6 |
7 | env:
8 | - TEST_RUN="./tests/test-minikube.sh"
9 | - TEST_RUN="./tests/test-kubernetes.sh"
10 |
11 | before_install:
12 | - sudo apt-get install shellcheck
13 | - pip install -U -r test-requirements.txt
14 |
15 | install:
16 | - "./scripts/install.sh"
17 | - "./scripts/bx_auth.sh"
18 |
19 | before_script:
20 | - "./tests/test-shellcheck.sh"
21 | - "./tests/test-yamllint.sh"
22 |
23 | script: "$TEST_RUN"
24 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM kkbankol/opencv_yolo_pod
2 | RUN rm -rf /opt/cameras_app/*
3 | COPY . /opt/cameras_app/
4 | #git clone
5 | COPY bin/example_dnn_object_detection /nodejsAction/cv/example_dnn_object_detection
6 | RUN cd /opt/cameras_app && rm -rf node_modules && npm install
7 | RUN cp /nodejsAction/cv/object_detection_classes_yolov3.txt /tmp/object_detection_classes_yolov3.txt
8 | RUN bash -c 'curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash'
9 | # RUN cat /root/.bash_profile
10 | COPY .bash_profile_nvm /root/.bash_profile
11 | COPY .bashrc /root/.bashrc
12 |
13 | #RUN echo '# Place next three lines in ~/.bash_profile \
14 | #export NVM_DIR="$HOME/.nvm" \
15 | #[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm \
16 | #[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"' >> /root/.bash_profile
17 | RUN bash -c "source /root/.bash_profile && \
18 | nvm install v8.9.0 && \
19 | nvm use 8.9.0 && \
20 | nvm alias default 8.9.0"
21 | RUN bash -c "source /root/.bash_profile && cd /opt/cameras_app && rm -rf node_modules && nvm use 8.9.0 && npm install"
22 | CMD bash -c "source /root/.bash_profile && nvm use 8.9.0 && npm start --prefix /opt/cameras_app"
23 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | # Analyze real time CCTV images with Convolutional Neural Networks
6 | In this Code Pattern, we will deploy an application that will leverage neural networking models to analyze RTSP (Real Time Streaming Protocol) video streams using with OpenCV / Darknet.
7 |
8 | There are many surveillance cameras that have been installed, but cannot be closely monitored throughout the day. Since events are more likely to occur while the operator is not watching, many significant events go undetected, even when they are recorded. Users can't be expected to trace through hours of video footage, especially if they're not sure what they're looking for.
9 |
10 | This project aims to alleviate this problem by using deep learning algorithms to detect movement, and identify objects in a video feed. These algorithms can be applied to both live streams and previously recorded video. After each video frame has been analyzed, the labeled screenshot and corresponding metadata are also uploaded to a Cloudant database. This allows for an operator to invoke complex queries and run analytics against the collected data. A few example queries might be
11 | - Select all screenshots in which a person was detected at camera 3 during the previous Monday
12 | - Get total count of cars detected last Saturday
13 |
14 | When the reader has completed this Code Pattern, they will understand how to:
15 | * Connect to a RTSP video stream via Python + Opencv
16 | * Use Opencv and Numpy to process video frames and determine when significant motion has occured
17 | * Identify objects in a photograph or video using a pre-built Deep Learning model
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 | ## Flow
27 | 1. Connect a motion detection script to a RTSP stream or video file
28 | 2. If motion is detected, capture screenshot and forward to Node.js server hosted locally or in IBM Cloud container service
29 | 3. Analyze screenshot using Darknet / YOLO object detection algorithm
30 | 4. Upload labeled screenshot and associated metadata (time, camera channel) to Cloudant database
31 |
32 |
33 |
34 |
36 |
37 | [](https://bluemix.net/deploy?repository=https://github.com/kkbankol-ibm/dnn-object-detection.git&branch=master)
38 |
39 | ## Install Prerequisites:
40 | ### IBM Cloud CLI (Hosted)
41 | To interact with the hosted offerings, the IBM Cloud CLI will need to be installed beforehand. The latest CLI releases can be found at the link [here](https://console.bluemix.net/docs/cli/reference/bluemix_cli/download_cli.html#download_install). An install script is maintained at the mentioned link, which can be executed with one of the following commands
42 |
43 | ```
44 | # Mac OSX
45 | curl -fsSL https://clis.ng.bluemix.net/install/osx | sh
46 |
47 | # Linux
48 | curl -fsSL https://clis.ng.bluemix.net/install/linux | sh
49 |
50 | # Powershell
51 | iex(New-Object Net.WebClient).DownloadString('https://clis.ng.bluemix.net/install/powershell')
52 | ```
53 | After installation is complete, confirm the CLI is working by printing the version like so
54 | ```
55 | bx -v
56 | ```
57 |
58 | ### Kubernetes CLI (Hosted)
59 |
60 | *Linux*
61 | ```
62 | sudo apt-get update && sudo apt-get install -y apt-transport-https
63 | curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
64 | echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
65 | sudo apt-get update
66 | sudo apt-get install -y kubectl
67 | ```
68 |
69 | *MacOS*
70 | ```
71 | brew install kubernetes-cli
72 | ```
73 |
74 | ### Node.js + NPM (Local)
75 | If expecting to run this application locally, please continue by installing [Node.js](https://nodejs.org/en/) runtime and NPM. We'd suggest using [nvm](https://github.com/creationix/nvm) to easily switch between node versions, which can be done with the following commands
76 | ```
77 | curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash
78 | # Place next three lines in ~/.bash_profile
79 | export NVM_DIR="$HOME/.nvm"
80 | [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
81 | [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion" # This loads nvm bash_completion
82 | nvm install v8.9.0
83 | nvm use 8.9.0
84 | ```
85 |
86 |
88 |
89 | # Steps
90 | Use the ``Deploy to IBM Cloud`` instructions **OR** create the services and run locally.
91 |
92 |
93 |
94 | ## Included components
95 | * [Cloudant DB](https://console.bluemix.net/catalog/services/blockchain)
96 | * [Kubernetes](https://console.bluemix.net/containers-kubernetes/catalog/cluster)
97 |
98 |
99 | ## Featured technologies
100 |
101 | * [NPM](https://www.npmjs.com/)
102 | * [Node.js](https://nodejs.org/en/)
103 | * [Darknet / YOLO](https://pjreddie.com/darknet/yolo/)
104 | * [OpenCV](https://github.com/opencv/opencv)
105 |
106 |
107 | To begin setting up this project, the Node.js backend will need to be deployed first. After setting up the node.js server, continue by [setting up the Raspberry Pi / Linux client](#set-up-the-raspberry-pi-client).
108 |
109 | ## Deploy backend server to IBM Cloud
110 |
111 |
112 |
113 |
114 |
115 |
116 |
118 |
119 |
120 | 1. Use the IBM Cloud dashboard to create the following services (The free or "lite" version will suffice for both services)
121 | * [Cloudant-db](https://console.bluemix.net/catalog/services/cloudant)
122 | * [Kubernetes](https://console.bluemix.net/containers-kubernetes/catalog/cluster)
123 |
124 | 2. Install the IBM Cloud CLI on your development system using the following [instructions](https://console.bluemix.net/docs/containers/cs_cli_install.html)
125 |
126 | 3. Export the `KUBECONFIG` path. This should be presented just after creating the container cluster
127 | ```
128 | export KUBECONFIG=/Users/$USER/.bluemix/plugins/container-service/clusters/mycluster/kube-config-hou02-mycluster.yml
129 | ```
130 |
131 | 4. Store Cloudant Credentials
132 | > Store the **CLOUDANT_USERNAME**, **CLOUDANT_PASSWORD**, and **CLOUDANT_DB** into a `.env` file
133 | ```
134 | CLOUDANT_USERNAME="username"
135 | CLOUDANT_PASSWORD="password"
136 | CLOUDANT_DB="imagedb"
137 | ```
138 |
139 | Run the following kubectl command. This will generate a "secret", allowing for the Cloudant credentials to be accessible as a environment
140 | ```
141 | source .env
142 | kubectl create secret generic cloudant-auth --from-literal=CLOUDANT_USERNAME=${CLOUDANT_USERNAME} --from-literal=CLOUDANT_PASSWORD=${CLOUDANT_PASSWORD} --from-literal=CLOUDANT_DB=${CLOUDANT_DB}
143 | ```
144 |
145 |
146 |
147 |
148 | 5. Deploy the kubernetes application with the following command
149 | ```
150 | kubectl apply -f kubernetes/kube-config.yml
151 | ```
152 |
153 |
154 | To access the pod filesystem and confirm the credentials have been imported correctly, run the following commands (Optional)
155 | ```
156 | kubectl get pods
157 | kubectl exec -it dnn-pod bash
158 | # print environment vars in pod/container, filter by cloudant
159 | env | grep -i cloudant
160 | ```
161 |
162 | After confirming the Cloudant credentials are accessible as environment variables, tail the app logs with the following (Optional)
163 | ```
164 | kubectl logs -f dnn-pod
165 | ```
166 |
167 | 6. Find the public ip address of the Kubernetes cluster
168 | ```
169 | # Get id of cluster
170 | ibmcloud ks clusters
171 |
172 | # Print workers associated with cluster, take note of public ip. Default name is "mycluster"
173 | ibmcloud ks workers
174 | ```
175 |
176 | 7. Confirm that the Node.js backend is up and running
177 | ```
178 | curl :30000/status
179 | ```
180 |
181 | ## Deploy backend server locally
182 |
183 | If Docker is installed on your system, running the following command will start the backend service locally instead
184 | ```
185 | docker run -d -p 30000:30000 -e CLOUDANT_USERNAME=${CLOUDANT_USERNAME} -e CLOUDANT_PASSWORD=${CLOUDANT_PASSWORD} -e CLOUDANT_DB=${CLOUDANT_DB} --name opencv_yolo kkbankol/opencv_yolo_pod
186 | ```
187 |
188 | If Docker is not installed, continue with the following steps
189 | 1. [Clone the repo](#1-clone-the-repo)
190 | 2. [Create Watson services with IBM Cloud]()
191 | 3. [Configure credentials]()
192 | 4. [Install backend dependencies](#4-run-the-application)
193 | 5. [Start the backend node.js server](#4-run-the-application)
194 |
195 | ### 1. Clone the repo
196 |
197 | Clone the `dnn-object-detection` project locally. In a terminal, run:
198 |
199 | ```
200 | $ git clone https://github.com/IBM/dnn-object-detection
201 | ```
202 |
203 | ### 2. Create Watson services in IBM Cloud dashboard
204 |
205 | Create the following services:
206 |
207 | * [**Cloudant DB**](https://console.bluemix.net/catalog/services/cloudant)
208 | * [**Kubernetes**](https://console.bluemix.net/containers-kubernetes/catalog/cluster) (Hosted)
209 |
210 | ### 3. Configure credentials
211 | The credentials for IBM Cloud services (Cloudant DB), can be found in the ``Services`` menu in IBM Cloud by selecting the ``Service Credentials`` option for each service.
212 | > Store the **CLOUDANT_USERNAME**, **CLOUDANT_PASSWORD**, and **CLOUDANT_DB** into the `.env` file
213 | ```
214 | CLOUDANT_USERNAME="username"
215 | CLOUDANT_PASSWORD="password"
216 | CLOUDANT_DB="imagedb"
217 | ```
218 |
219 | ### 4. Install backend dependencies
220 | ```
221 | npm install
222 | ```
223 |
224 | ### 5. Start the backend Node.js server
225 | 1. Install [Node.js](https://nodejs.org/en/) runtime or NPM.
226 | 1. Start the app by running `npm install`, followed by `npm start`.
227 | > Note: server host can be changed as required in server.js and `PORT` can be set in `.env`.
228 |
229 |
230 | ```
231 | Kalonjis-MacBook-Pro:dnn-object-detection kkbankol@us.ibm.com$ npm start
232 |
233 | > cameras-app@0.0.0 start /Users/kkbankol@us.ibm.com/projects/smart-city-cameras/dnn-object-detection
234 | > node ./bin/www
235 | ```
236 |
237 | ## Set up the Raspberry Pi Client
238 | Now that we have a backend process up and running, we'll set up a device on the same local network as the CCTV cameras. The reasoning for this is that continuously pulling multiple video streams would be too demanding on the network bandwidth, and there would likely be latency issues. So as an alternative, we'll set up a Raspberry Pi on the same network as the CCTV system, and connect the two devices over the LAN instead. Any alternative Linux system should work.
239 |
240 | We'll start by installing a few dependencies for our "motion detection" script. Skip the packages that are already installed on your system
241 | ```
242 | # Linux
243 | sudo apt-get update
244 | sudo apt-get install python -y
245 | sudo apt-get install ffmpeg -y
246 |
247 | # Mac OS
248 | brew install ffmpeg
249 | brew install python
250 |
251 | pip install numpy cv2 requests
252 | ```
253 |
254 | Next, we can actually begin processing video that has either been pre-recorded or being live streamed. The script expects two arguments. The first argument is the video source (file or RTSP stream). The second argument is the ip address where images/metadata can be sent, this ip will either be 127.0.0.1 (if running node backend locally), or the public ip of the Kubernetes cluster.
255 | ```
256 | # process pre-recorded video
257 | python scripts/cv_object_detection.py sample_videos/vid10.mp4
258 |
259 | # process live stream video
260 | python cv_object_detection.py rtsp://@192.168.1.2:8080/out.h264
261 | ```
262 |
263 | Once this script begins, it'll iterate through each frame from the video source. As these iterations continue, the Opencv libary is used to calculate a "running average". Each frame gets compared to the running average, and if a significant difference is observed, the frame is then saved as an image and forwarded to the nodejs backend.
264 |
265 | As images are uploaded to the Node backend, they are then processed by the YOLO object detection algorithm, and labeled
266 |
267 |
268 |
269 |
270 | The labeled photo, identified classes, and metadata are then uploaded to Cloudant. Each Cloudant document is arranged like so
271 |
23 |
24 | 
268 | 
273 |