https://github.com/ajithvcoder/people_counter_app_udacity
contains helper files for people counter app udacity
https://github.com/ajithvcoder/people_counter_app_udacity
Last synced: 12 months ago
JSON representation
contains helper files for people counter app udacity
- Host: GitHub
- URL: https://github.com/ajithvcoder/people_counter_app_udacity
- Owner: ajithvcoder
- Created: 2020-06-30T19:38:56.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2020-07-28T08:15:30.000Z (over 5 years ago)
- Last Synced: 2025-01-12T19:30:43.459Z (about 1 year ago)
- Language: JavaScript
- Size: 63.3 MB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Please read Step 0 for setting up the project
# Deploy a People Counter App at the Edge
| Details | |
|-----------------------|---------------|
| Programming Language: | Python 3.5 or 3.6 |
## What it Does
The people counter application will demonstrate how to create a smart video IoT solution using Intel® hardware and software tools. The app will detect people in a designated area, providing the number of people in the frame, average duration of people in frame, and total count.
## How it Works
The counter will use the Inference Engine included in the Intel® Distribution of OpenVINO™ Toolkit. The model used should be able to identify people in a video frame. The app should count the number of people in the current frame, the duration that a person is in the frame (time elapsed between entering and exiting a frame) and the total count of people. It then sends the data to a local web server using the Paho MQTT Python package.
You will choose a model to use and convert it with the Model Optimizer.
## Requirements
### Hardware
* 6th to 10th generation Intel® Core™ processor with Iris® Pro graphics or Intel® HD Graphics.
* OR use of Intel® Neural Compute Stick 2 (NCS2)
* OR Udacity classroom workspace for the related course
### Software
* Intel® Distribution of OpenVINO™ toolkit 2019 R3 release
* Node v6.17.1
* Npm v3.10.10
* CMake
* MQTT Mosca server
## Setup
### Install Intel® Distribution of OpenVINO™ toolkit
Utilize the classroom workspace, or refer to the relevant instructions for your operating system for this step.
- [Linux/Ubuntu](./linux-setup.md)
- [Mac](./mac-setup.md)
- [Windows](./windows-setup.md)
### Install Nodejs and its dependencies
Utilize the classroom workspace, or refer to the relevant instructions for your operating system for this step.
- [Linux/Ubuntu](./linux-setup.md)
- [Mac](./mac-setup.md)
- [Windows](./windows-setup.md)
### Install npm
There are three components that need to be running in separate terminals for this application to work:
- MQTT Mosca server
- Node.js* Web server
- FFmpeg server
From the main directory:
* For MQTT/Mosca server:
```
cd webservice/server
npm install
```
* For Web server:
```
cd ../ui
npm install
```
**Note:** If any configuration errors occur in mosca server or Web server while using **npm install**, use the below commands:
```
sudo npm install npm -g
rm -rf node_modules
npm cache clean
npm config set registry "http://registry.npmjs.org"
npm install
```
## Model used :
ssd mobile net
## Running the application
From the main directory:
### Step 0 : setting up SSD mobile net model
if you are stuck some where u can mail me at inocajith21.5@gmail.com
Either you can do all the steps in step 0 or else you can clone this repo https://github.com/ajithvallabai/people_counter_app_udacity
and put the ssd_mo_model in main directory
From the main directory
Download pretrained mode
http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v2_coco_2018_03_29.tar.gz
Extract files
```
tar -xvf ssd_mobilenet_v2_coco_2018_03_29.tar.gz
```
inside ssd_movilenet directory run below command
```
python /opt/intel/openvino/deployment_tools/model_optimizer/mo_tf.py --input_model frozen_inference_graph.pb --tensorflow_object_detection_api_pipeline_config pipeline.config --tensorflow_use_custom_operations_config /opt/intel/openvino/deployment_tools/model_optimizer/extensions/front/tf/ssd_v2_support.json --reverse_input_channel
```
create a directory "ssd_mo_model"
```
mkdir ssd_mo_model
```
put xml,bin,mapping in side "ssd_mo_model"
### Step 1 - Start the Mosca server
```
cd webservice/server/node-server
node ./server.js
```
You should see the following message, if successful:
```
Mosca server started.
```
### Step 2 - Start the GUI
Open new terminal and run below commands.
```
cd webservice/ui
npm run dev
```
You should see the following message in the terminal.
```
webpack: Compiled successfully
```
### Step 3 - FFmpeg Server
Open new terminal and run the below commands.
```
sudo ffserver -f ./ffmpeg/server.conf
```
### Step 4 - Run the code
You must configure the environment to use the Intel® Distribution of OpenVINO™ toolkit one time per session by running the following command:
```
source /opt/intel/openvino/bin/setupvars.sh -pyver 3.5
```
Open a new terminal to run the code.
```
python main.py -i resources/Pedestrian_Detect_2_1_1.mp4 -m ssd_mo_model/frozen_inference_graph.xml -l /opt/intel/openvino/deployment_tools/inference_engine/lib/intel64/libcpu_extension_sse4.so -d CPU -pt 0.6 | ffmpeg -v warning -f rawvideo -pixel_format bgr24 -video_size 768x432 -framerate 24 -i - http://0.0.0.0:3004/fac.ffm
```
#### Setup the environment
You should also be able to run the application with Python 3.6, although newer versions of Python will not work with the app.
#### Running on the CPU
When running Intel® Distribution of OpenVINO™ toolkit Python applications on the CPU, the CPU extension library is required. This can be found at:
```
/opt/intel/openvino/deployment_tools/inference_engine/lib/intel64/
```
*Depending on whether you are using Linux or Mac, the filename will be either `libcpu_extension_sse4.so` or `libcpu_extension.dylib`, respectively.* (The Linux filename may be different if you are using a AVX architecture)
Though by default application runs on CPU, this can also be explicitly specified by ```-d CPU``` command-line argument:
```
python main.py -i resources/Pedestrian_Detect_2_1_1.mp4 -m your-model.xml -l /opt/intel/openvino/deployment_tools/inference_engine/lib/intel64/libcpu_extension_sse4.so -d CPU -pt 0.6 | ffmpeg -v warning -f rawvideo -pixel_format bgr24 -video_size 768x432 -framerate 24 -i - http://0.0.0.0:3004/fac.ffm
```
If you are in the classroom workspace, use the “Open App” button to view the output. If working locally, to see the output on a web based interface, open the link [http://0.0.0.0:3004](http://0.0.0.0:3004/) in a browser.
#### Running on the Intel® Neural Compute Stick
To run on the Intel® Neural Compute Stick, use the ```-d MYRIAD``` command-line argument:
```
python3.5 main.py -d MYRIAD -i resources/Pedestrian_Detect_2_1_1.mp4 -m your-model.xml -pt 0.6 | ffmpeg -v warning -f rawvideo -pixel_format bgr24 -video_size 768x432 -framerate 24 -i - http://0.0.0.0:3004/fac.ffm
```
To see the output on a web based interface, open the link [http://0.0.0.0:3004](http://0.0.0.0:3004/) in a browser.
**Note:** The Intel® Neural Compute Stick can only run FP16 models at this time. The model that is passed to the application, through the `-m ` command-line argument, must be of data type FP16.
#### Using a camera stream instead of a video file
To get the input video from the camera, use the `-i CAM` command-line argument. Specify the resolution of the camera using the `-video_size` command line argument.
For example:
```
python main.py -i CAM -m your-model.xml -l /opt/intel/openvino/deployment_tools/inference_engine/lib/intel64/libcpu_extension_sse4.so -d CPU -pt 0.6 | ffmpeg -v warning -f rawvideo -pixel_format bgr24 -video_size 768x432 -framerate 24 -i - http://0.0.0.0:3004/fac.ffm
```
To see the output on a web based interface, open the link [http://0.0.0.0:3004](http://0.0.0.0:3004/) in a browser.
**Note:**
User has to give `-video_size` command line argument according to the input as it is used to specify the resolution of the video or image file.
## A Note on Running Locally
The servers herein are configured to utilize the Udacity classroom workspace. As such,
to run on your local machine, you will need to change the below file:
```
webservice/ui/src/constants/constants.js
```
The `CAMERA_FEED_SERVER` and `MQTT_SERVER` both use the workspace configuration.
You can change each of these as follows:
```
CAMERA_FEED_SERVER: "http://localhost:3004"
...
MQTT_SERVER: "ws://localhost:3002"
```