To set up a parking lot camera for our project, Here we have used a downloaded video and converted it into an image. This setup allows us to simulate a real parking lot scenario for analysis. This approach enables us to experiment and develop our parking lot monitoring system without needing access to a real parking lot.

This article’s main goal is to walk you through one of the simplest methods for creating a smart parking system with just a webcam and a few lines of Python code.

Sample Video: Link

Parking Video

The Selector Image to choose the location

We must construct the selector first. First, we import the necessary modules. Following that, we can set to work generating the image from which the parking spaces will be chosen. To do that, we can save the initial frame that the webcam captures, and utilize the image to choose the locations. The following code works like this:

1. Opens the video stream in a variable; and determines if the stream was opened successfully.
2. Writes the first frame into frame.jpg.
3. The stream is released and all windows are closed.
4. The new saved picture is read in another variable.

import cv2, csv, time

video = cv2.VideoCapture('Location to Video') 
source, image = video.read()

# Save the image fot ROI Selection
cv2.imwrite("frame.jpg", image)
video.release()
cv2.destroyAllWindows()

Having saved the first frame in the image variable, we can now utilize the selectROIs function to identify our parking spaces. Regions of interest, or ROIs, are parts of the image to which various functions and filters will be applied in order to obtain the desired results.

Using the selectROIs function once more, this will yield a list (type: numpy.ndarray) with the numbers we require to put together photos using their borders as our ROIs.

import cv2, csv, time

video = cv2.VideoCapture('Data/lot.mp4') 
source, image = video.read()
cv2.imwrite("frame.jpg", image)
video.release()
cv2.destroyAllWindows()
image = cv2.imread("frame.jpg")

# Need to resixe the image
height, width, layers = image.shape
image = cv2.resize(image, (int(width * 0.35), int(height * 0.35))) 
 
r = cv2.selectROI('Selector', image, showCrosshair=False, fromCenter=False)
rlist = list(r)

with open('Data/rois1.csv', 'a', newline='') as outf:
    csvw = csv.writer(outf)
    csvw.writerow(rlist)

We’ll save our list in the “r” variable. The following are the arguments passed to the cv2.selectROIs function:

1. We will be able to select the ROIs using a window called “Selector.”
2. The variable img holds the image that we wish to choose.
3. showCrosshair = Flase eliminates the selection’s inner center lines. Since there is no effect on the outcome, this can be set to True.
4. fromCenter = False is a crucial setting since it would have made correct selection much more difficult if it had been set to True.

It’s time to enter all of the parking spaces that have been chosen into a.csv file. Once we get the correct data, we may save it in the.csv file that we will use in the future.

Applying selector algorithm on all parking slots

The Detector to process the Image

After parking spaces have been chosen, it’s time to process the images. The method I used to tackle this was:

1. From the.csv file, obtain the coordinates.
2. Construct a new picture using it.
3. Use the Canny function that OpenCV offers.
4. Within the new image, count the white pixels.
5. Determine the range of pixels that would be occupied.
6. On the live feed, draw a rectangle in either red or green.

Step 1: We must define a function for each of these operations so that it may be used at each location. This is how the function looks like:

def drawRectangle(image, a, b, c, d, low_threshold, high_threshold, min_pix, max_pix):
    sub_image = image[b:b + d, a:a + c]
    edges = cv2.Canny(sub_image, low_threshold, high_threshold)
    pix = cv2.countNonZero(edges)
    if pix in range(min_pix, max_pix):
        cv2.rectangle(image, (a, b), (a + c, b + d), (0, 255, 0), 3)
        Spots.location += 1
    else:
        cv2.rectangle(image, (a, b), (a + c, b + d), (0, 0, 255), 3)

Now that we have the function, all we need to do is apply it to each set of coordinates in the.csv file.

First of all, we have several parameters that would be useful if we could change them in real time while the script is running, preferably via a GUI. To accomplish this, we need to construct a few track bars. Fortunately, OpenCV allows us to do so without requiring additional libraries.

Step 2: First, we need a callback function that does nothing but serves as a parameter when producing track bars with OpenCV. Actually, the callback parameter has a specific purpose, but we do not use it here.

def callback(foo):
    pass

Step 3: Now we need to make the track bars. To accomplish this, we will use the cv2.namedWindow and cv2.createTrackbar functions.

cv2.namedWindow('parameters')
cv2.createTrackbar('Threshold1', 'parameters', 186, 700, callback)
cv2.createTrackbar('Threshold2', 'parameters', 122, 700, callback)
cv2.createTrackbar('Min pixels', 'parameters', 100, 1500, callback)
cv2.createTrackbar('Max pixels', 'parameters', 534, 1500, callback)

Step 4: Now that we’ve constructed the GUI for operating the parameters, there’s just one thing remaining. This represents the number of available spots in the image. This is defined in the drawRectangle as spots.loc. This is a static variable that must be defined at the start of the program. This variable is static because we want the outcome of every drawRectangle function we call to be written to the same global variable rather than a different variable for each function. This ensures that the returned number of available spaces does not exceed the actual amount.

class Spots:
    location = 0

Step 5: Now that we’re almost there, all we need to do is extract the data from the.csv file, convert it all to integers, and run our created functions in an infinite loop.

while video.isOpened():
    Spots.location = 0
    source, image = video.read()
    
    if not source:
        break
        
    height, width, layers = image.shape
    image = cv2.resize(image, (int(width * 0.35), int(height * 0.35))) 

    min_pix = cv2.getTrackbarPos('Min pixels', 'parameters')
    max_pix = cv2.getTrackbarPos('Max pixels', 'parameters')
    low_threshold = cv2.getTrackbarPos('Threshold1', 'parameters')
    high_threshold = cv2.getTrackbarPos('Threshold2', 'parameters')

    for i in range(roi_data.shape[0]): 
        drawRectangle(image, roi_data.iloc[i, 0], roi_data.iloc[i, 1], roi_data.iloc[i, 2], roi_data.iloc[i, 3],
                      low_threshold, high_threshold, min_pix, max_pix) 

    font = cv2.FONT_HERSHEY_SIMPLEX
    cv2.putText(image, 'Available Spots: ' + str(Spots.location),
                (10, 30), font, 1, (0, 255, 0), 3)
    cv2.imshow('Frame', image)

    canny = cv2.Canny(image, low_threshold, high_threshold)
    cv2.imshow('Canny', canny)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

video.release()
cv2.destroyAllWindows()

Understanding the Loop in Our Script

1. First, we set the number of available places to 0 to avoid adding numbers for each frame.
2. Then we start two streams: the original image and the transformed image. This helps develop a better understanding of how this script functions and how the image is processed.
3. After that, we must obtain the values of the parameters set in the parameters GUI we generated for each iteration. This is accomplished using the cv2.getTrackbarPos function.
4. The most crucial portion now takes place: the drawRectangle function is applied to all of the coordinates collected by the Selector script.

What remains is to write the number of available spots on the resulting image, display the Canny function and result.

Output Video

Conclusion

Smart parking is a popular topic these days, and there are numerous implementations that can lead to a well-functioning system. I am aware that this is not ideal there are many alternatives that are more tuned and can operate in a variety of situations.