DEV Community: nima

YOLOV3 & Tensorflow object detection and report human movements in persian

nima — Sun, 11 Apr 2021 10:43:39 +0000

Yolov3 is an algorithm that uses deep convolutional neural networks to perform object detection. This repository implements Yolov3 using TensorFlow

you can access to this repository on Github:
https://github.com/nimadorostkar/human-detection

الگوریتم‌های مختلفی برای پیاده‌سازی سیستم تشخیص اشیا در نظر گرفته شدند، اما در نهایت، الگوریتم YOLO به عنوان الگوریتم اصلی بر پیاده‌سازی این سیستم در نظر گرفته شد. دلیل انتخاب الگوریتم YOLO، سرعت بالا و قدرت محاسباتی آن و همچنین، وجود منابع آموزشی زیاد برای راهنمایی کاربران هنگام پیاده‌سازی این الگوریتم است.

Getting started
Pip
pip install -r requirements.txt
Downloading official pretrained weights
از لینک های زیر dataset رو میتونید دانلود کنید
For Linux: Let’s download official yolov3 weights pretrained on COCO dataset.

yolov3

wget https://pjreddie.com/media/files/yolov3.weights -O weights/yolov3.weights

yolov3-tiny

wget https://pjreddie.com/media/files/yolov3-tiny.weights -O weights/yolov3-tiny.weights
For Windows: You can download the yolov3 weights by clicking here and yolov3-tiny here then save them to the weights folder.
Saving your yolov3 weights as a TensorFlow model.
Load the weights using load_weights.py script. This will convert the yolov3 weights into TensorFlow .ckpt model files!

yolov3

python load_weights.py

yolov3-tiny

python load_weights.py --weights ./weights/yolov3-tiny.weights --output ./weights/yolov3-tiny.tf --tiny
After executing one of the above lines, you should see .tf files in your weights folder.
Running just the TensorFlow model
The tensorflow model can also be run not using the APIs but through using detect.py script.
Don’t forget to set the IoU (Intersection over Union) and Confidence Thresholds within your yolov3-tf2/models.py file
Usage examples
Let’s run an example or two using sample images found within the data/images folder.

yolov3

python detect.py --images "data/images/dog.jpg, data/images/office.jpg"

yolov3-tiny

python detect.py --weights ./weights/yolov3-tiny.tf --tiny --images "data/images/dog.jpg"

webcam

python detect_video.py --video 0

video file

python detect_video.py --video data/video/paris.mp4 --weights ./weights/yolov3-tiny.tf --tiny

video file with output saved (can save webcam like this too)

python detect_video.py --video path_to_file.mp4 --output ./detections/output.avi
Then you can find the detections in the detections folder.

حتما اینو امتحان کنید
با دستور زیر به صورت real-time ویدیو از وبکم گرفته میشه و object های تصویر تحلیل میشه و اگه انسان شناسایی بشه به صورت صوتی اعلام میشه.
python detect_video.py --video 0
https://github.com/nimadorostkar/human-detection

Real Time Lane Detection — python opencv

nima — Sun, 11 Apr 2021 10:36:31 +0000

Overview
Lane detection is one of the most crucial technique of ADAS and has received significant attention recently. In this project, we achived lane detection with real time by numpy and multi-thread.

Dependencies:

Python
Numpy
Opencv

How to Run:

Run lane_detection.py. The default video is project_video, if you want to process the "fog_video.mp4", change video_index to 1 in line 9.

full source code:
import numpy as np
import cv2
import time
from threading import Thread
from queue import Queue

defualt video number, if you want to process the "fog_video.mp4", change video_index to 1

video_index = 0

the result of lane detection, we add the road to the main frame

road = np.zeros((720, 1280, 3))

A flag which means the process is started

started = 0

Pipeline combining color and gradient thresholding

def thresholding_pipeline(img, s_thresh=(90, 255), sxy_thresh=(20, 100)):
img = np.copy(img)
# 1: Convert to HSV color space and separate the V channel
hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS).astype(np.float)
h_channel = hls[:, :, 0]
l_channel = hls[:, :, 1]
s_channel = hls[:, :, 2]

2: Calculate x directional gradient

sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0)  # Take the derivative in x
# Absolute x derivative to accentuate lines away from horizontal
abs_sobelx = np.absolute(sobelx)
scaled_sobelx = np.uint8(255 * abs_sobelx / np.max(abs_sobelx))
sxbinary = np.zeros_like(scaled_sobelx)
sxbinary[(scaled_sobelx >= sxy_thresh[0]) &
         (scaled_sobelx <= sxy_thresh[1])] = 1
grad_thresh = sxbinary

3: Color Threshold of s channel

s_binary = np.zeros_like(s_channel)
s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1

4: Combine the two binary thresholds

combined_binary = np.zeros_like(grad_thresh)
combined_binary[(s_binary == 1) | (grad_thresh == 1)] = 1

return combined_binary

Apply perspective transformation to bird's eye view

def perspective_transform(img, src_mask, dst_mask):
img_size = (img.shape[1], img.shape[0])
src = np.float32(src_mask)
dst = np.float32(dst_mask)
M = cv2.getPerspectiveTransform(src, dst)
warped_img = cv2.warpPerspective(img, M, img_size, flags=cv2.INTER_LINEAR)
return warped_img

Implement Sliding Windows and Fit a Polynomial

def sliding_windows(binary_warped, nwindows=9):
histogram = np.sum(
binary_warped[int(binary_warped.shape[0]/2):, :], axis=0)

Find the peak of the left and right halves of the histogram

# These will be the starting point for the left and right lines
midpoint = np.int(histogram.shape[0]/2)
leftx_base = np.argmax(histogram[:midpoint])
rightx_base = np.argmax(histogram[midpoint:]) + midpoint

Set height of windows

window_height = np.int(binary_warped.shape[0]/nwindows)
# Identify the x and y positions of all nonzero pixels in the image
nonzero = binary_warped.nonzero()
nonzeroy = np.array(nonzero[0])
nonzerox = np.array(nonzero[1])
# Current positions to be updated for each window
leftx_current = leftx_base
rightx_current = rightx_base
# Set the width of the windows +/- margin
margin = 100
# Set minimum number of pixels found to recenter window
minpix = 50
# Create empty lists to receive left and right lane pixel indices
left_lane_inds = []
right_lane_inds = []

Step through the windows one by one

for window in range(nwindows):
    # Identify window boundaries in x and y (and right and left)
    win_y_low = binary_warped.shape[0] - (window+1)*window_height
    win_y_high = binary_warped.shape[0] - window*window_height
    win_xleft_low = leftx_current - margin
    win_xleft_high = leftx_current + margin
    win_xright_low = rightx_current - margin
    win_xright_high = rightx_current + margin
    # Identify the nonzero pixels in x and y within the window
    good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (
        nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0]
    good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (
        nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0]
    # Append these indices to the lists
    left_lane_inds.append(good_left_inds)
    right_lane_inds.append(good_right_inds)
    # If you found > minpix pixels, recenter next window on their mean position
    if len(good_left_inds) > minpix:
        leftx_current = np.int(np.mean(nonzerox[good_left_inds]))
    if len(good_right_inds) > minpix:
        rightx_current = np.int(np.mean(nonzerox[good_right_inds]))

Concatenate the arrays of indices

left_lane_inds = np.concatenate(left_lane_inds)
right_lane_inds = np.concatenate(right_lane_inds)

Extract left and right line pixel positions

leftx = nonzerox[left_lane_inds]
lefty = nonzeroy[left_lane_inds]
rightx = nonzerox[right_lane_inds]
righty = nonzeroy[right_lane_inds]

Fit a second order polynomial to each

left_fit = np.polyfit(lefty, leftx, 2)
right_fit = np.polyfit(righty, rightx, 2)

return left_fit, right_fit, lefty, leftx, righty, rightx

Warp lane line projection back to original image

def project_lanelines(binary_warped, orig_img, left_fit, right_fit, dst_mask, src_mask):
global road
global started
ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0])
left_fitx = left_fit[0]ploty2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty*2 + right_fit[1]*ploty + right_fit[2]

Create an image to draw the lines on

warp_zero = np.zeros_like(binary_warped).astype(np.uint8)
color_warp = np.dstack((warp_zero, warp_zero, warp_zero))

Recast the x and y points into usable format for cv2.fillPoly()

pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])
pts_right = np.array(
    [np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])
pts = np.hstack((pts_left, pts_right))

Draw the lane onto the warped blank image

cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))
# Warp the blank back to original image space using inverse perspective matrix (Minv)
warped_inv = perspective_transform(color_warp, dst_mask, src_mask)
road = warped_inv
started = 1

Main process functions

def main_pipeline(input):

step 1 select the ROI, and we need to distort the image for fog_video

if video_index == 0:
    image = input
    top_left = [540, 460]
    top_right = [754, 460]
    bottom_right = [1190, 670]
    bottom_left = [160, 670]
else:
    mtx = np.array([[1.15396467e+03, 0.00000000e+00, 6.69708251e+02], [0.00000000e+00, 1.14802823e+03, 3.85661017e+02],
                    [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
    dist = np.array([[-2.41026561e-01, -5.30262184e-02, -
                      1.15775369e-03, -1.27924043e-04, 2.66417032e-02]])
    image = cv2.undistort(input, mtx, dist, None, mtx)
    top_left = [240, 270]
    top_right = [385, 270]
    bottom_right = [685, 402]
    bottom_left = [0, 402]
src_mask = np.array([[(top_left[0], top_left[1]), (top_right[0], top_right[1]),
                      (bottom_right[0], bottom_right[1]), (bottom_left[0], bottom_left[1])]], np.int32)
dst_mask = np.array([[(bottom_left[0], 0), (bottom_right[0], 0),
                      (bottom_right[0], bottom_right[1]), (bottom_left[0], bottom_left[1])]], np.int32)

Step 2 Thresholding: color and gradient thresholds to generate a binary image

binary_image = thresholding_pipeline(image, s_thresh=(90, 255))

Step 3 Perspective transform on binary image:

binary_warped = perspective_transform(binary_image, src_mask, dst_mask)

Step 4 Fit Polynomial

left_fit, right_fit, lefty, leftx, righty, rightx = sliding_windows(
    binary_warped, nwindows=9)

Step 5 Project Lines

project_lanelines(binary_warped, image, left_fit,
                  right_fit, dst_mask, src_mask)

if name == 'main':
frames_counts = 1
if video_index == 0:
cap = cv2.VideoCapture('project_video.mp4')
else:
cap = cv2.VideoCapture('fog_video.mp4')
class MyThread(Thread):
def init(self, q):
Thread.init(self)
self.q = q
def run(self):
while(1):
if (not self.q.empty()):
image = self.q.get()
main_pipeline(image)
q = Queue()
q.queue.clear()
thd1 = MyThread(q)
thd1.setDaemon(True)
thd1.start()
while (True):
start = time.time()
ret, frame = cap.read()

Detect the lane every 5 frames

    if frames_counts % 5 == 0:
        q.put(frame)

Add the lane image on the original frame if started

    if started:
        frame = cv2.addWeighted(frame, 1, road, 0.5, 0)
    cv2.imshow("RealTime_lane_detection", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
    frames_counts += 1
    cv2.waitKey(12)
    finish = time.time()
    print('FPS:  ' + str(int(1/(finish-start))))

cap.release()
cv2.destroyAllWindows()

Github link:
https://github.com/nimadorostkar/realtime_lane_detection

Serial port communication in C

nima — Sun, 11 Apr 2021 10:32:48 +0000

github link for this project:
https://github.com/atrotech/comtest
How to build

git clone https://github.com/atrotech/comtest.git

cd comtest

gcc -o comtest comtest.c

Usage
./comtest -d /dev/ttyAMA3 -s 38400
Parameters

./comtest --help

comtest - interactive program of comm port
press [ESC] 3 times to quit
Usage: comtest [-d device] [-t tty] [-s speed] [-7] [-c] [-x] [-o] [-h]
-7 7 bit
-x hex mode
-o output to stdout too
-c stdout output use color
-h print this help
comtest.c :

include

static int SerialSpeed(const char *SpeedString)
{
int SpeedNumber = atoi(SpeedString);

define TestSpeed(Speed) if (SpeedNumber == Speed) return B##Speed

TestSpeed(1200);
TestSpeed(2400);
TestSpeed(4800);
TestSpeed(9600);
TestSpeed(19200);
TestSpeed(38400);
TestSpeed(57600);
TestSpeed(115200);
TestSpeed(230400);
return -1;

}
static inline void WaitFdWriteable(int Fd)
{
fd_set WriteSetFD;
FD_ZERO(&WriteSetFD);
FD_SET(Fd, &WriteSetFD);
if (select(Fd + 1, NULL, &WriteSetFD, NULL, NULL) < 0) {
printf("%s",strerror(errno));

}
int main(int argc, char **argv)
{
int CommFd, TtyFd;
struct termios TtyAttr;
struct termios BackupTtyAttr;
int DeviceSpeed = B38400;
int TtySpeed = B38400;
int ByteBits = CS8;
const char *DeviceName = "/dev/ttyAMA3";
const char *TtyName = "/dev/tty";
int OutputHex = 0;
int OutputToStdout = 0;
int UseColor = 0;

CommFd = open(DeviceName, O_RDWR, 0);

if (fcntl(CommFd, F_SETFL, O_NONBLOCK) < 0)
  printf("Unable set to NONBLOCK mode");

memset(&TtyAttr, 0, sizeof(struct termios));
TtyAttr.c_iflag = IGNPAR;
TtyAttr.c_cflag = DeviceSpeed | HUPCL | ByteBits | CREAD | CLOCAL;
TtyAttr.c_cc[VMIN] = 1;
if (tcsetattr(CommFd, TCSANOW, &TtyAttr) < 0)
printf("Unable to set comm port");
TtyFd = open(TtyName, O_RDWR | O_NDELAY, 0);
TtyAttr.c_cflag = TtySpeed | HUPCL | ByteBits | CREAD | CLOCAL;
if (tcgetattr(TtyFd, &BackupTtyAttr) < 0)
printf("Unable to get tty");
if (tcsetattr(TtyFd, TCSANOW, &TtyAttr) < 0)
printf("Unable to set tty");
for (;;) {
unsigned char Char = 0;
fd_set ReadSetFD;
void OutputStdChar(FILE *File) {
char Buffer[10];
int Len = sprintf(Buffer, OutputHex ? "%.2X " : "%c", Char);
fwrite(Buffer, 1, Len, File);
}
FD_ZERO(&ReadSetFD);
FD_SET(CommFd, &ReadSetFD);
FD_SET( TtyFd, &ReadSetFD);

define max(x,y) ( ((x) >= (y)) ? (x) : (y) )

if (select(max(CommFd, TtyFd) + 1, &ReadSetFD, NULL, NULL, NULL) < 0) {
printf("%s",strerror(errno));
}

undef max

if (FD_ISSET(CommFd, &ReadSetFD)) {
while (read(CommFd, &Char, 1) == 1) {
WaitFdWriteable(TtyFd);
if (write(TtyFd, &Char, 1) < 0) {
printf("%s",strerror(errno));
}
if (OutputToStdout) {
if (UseColor)
fwrite("\x1b[01;34m", 1, 8, stdout);
OutputStdChar(stdout);
if (UseColor)
fwrite("\x1b[00m", 1, 8, stdout);
fflush(stdout);
}
}
}
if (FD_ISSET(TtyFd, &ReadSetFD)) {
while (read(TtyFd, &Char, 1) == 1) {
static int EscKeyCount = 0;
WaitFdWriteable(CommFd);
if (write(CommFd, &Char, 1) < 0) {
printf("%s",strerror(errno));
}
if (OutputToStdout) {
if (UseColor)
fwrite("\x1b[01;31m", 1, 8, stderr);
OutputStdChar(stderr);
if (UseColor)
fwrite("\x1b[00m", 1, 8, stderr);
fflush(stderr);
}
if (Char == '\x1b') {
EscKeyCount ++;
if (EscKeyCount >= 3)
goto ExitLabel;
} else
EscKeyCount = 0;
}
}
}
ExitLabel:
if (tcsetattr(TtyFd, TCSANOW, &BackupTtyAttr) < 0)
printf("Unable to set tty");
return 0;
}
Makefile
CROSS=arm-linux-
all: armcomtest x86comtest
armcomtest: comtest.c
$(CROSS)gcc -Wall -O3 -o armcomtest comtest.c
x86comtest: comtest.c
gcc -o x86comtest comtest.c
clean:
@rm -vf armcomtest x86comtest *.o *~