基于计算机视觉和OpenCV：创建一个能够计算道路交通流量的应用

def filter_mask(img):

    kernel= cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2,2))

    # Fill any small holes
    closing= cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
    # Remove noise
    opening= cv2.morphologyEx(closing, cv2.MORPH_OPEN, kernel)

    # Dilate to merge adjacent blobs
    dilation= cv2.dilate(opening, kernel, iterations=2)

    # threshold
    th= dilation[dilation <240]= 0

    return th

cv2.CV_RETR_EXTERNAL — get only outer contours.
cv2.CV_CHAIN_APPROX_TC89_L1 - use Teh-Chin chain approximation algorithm (faster)
def
 
get_centroid(x, y, w, h):
    x1= int(w/ 2)
    y1= int(h/ 2)

    cx= x+ x1
    cy= y+ y1

    return (cx, cy)

def detect_vehicles(fg_mask, min_contour_width=35, min_contour_height=35):

    matches= []

    # finding external contours
    im, contours, hierarchy= cv2.findContours(
        fg_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1)

    # filtering by with, height
    for (i, contour)in enumerate(contours):
        (x, y, w, h)= cv2.boundingRect(contour)
        contour_valid= (w >= min_contour_width)and (
            h >= min_contour_height)

        if not contour_valid:
            continue

        # getting center of the bounding box
        centroid= get_centroid(x, y, w, h)

        matches.append(((x, y, w, h), centroid))

    return matches

EXIT_PTS= np.array([
    [[732,720], [732,590], [1280,500], [1280,720]],
    [[0,400], [645,400], [645,0], [0,0]]
])

base= np.zeros(SHAPE+ (3,), dtype='uint8')
exit_mask= cv2.fillPoly(base, EXIT_PTS, (255,255,255))[:, :,0]

new_pathes= []

for pathin self.pathes:
    _min= 999999
    _match= None
    for pin points:
        if len(path)== 1:
            # distance from last point to current
            d= utils.distance(p[0], path[-1][0])
        else:
            # based on 2 prev points predict next point and calculate
            # distance from predicted next point to current
            xn= 2 * path[-1][0][0]- path[-2][0][0]
            yn= 2 * path[-1][0][1]- path[-2][0][1]
            d= utils.distance(
                p[0], (xn, yn),
                x_weight=self.x_weight,
                y_weight=self.y_weight
            )

        if d < _min:
            _min= d
            _match= p

    if _matchand _min <= self.max_dst:
        points.remove(_match)
        path.append(_match)
        new_pathes.append(path)

    # do not drop path if current frame has no matches
    if _matchis None:
        new_pathes.append(path)

self.pathes= new_pathes

# add new pathes
if len(points):
    for pin points:
        # do not add points that already should be counted
        if self.check_exit(p[1]):
            continue
        self.pathes.append([p])

# save only last N points in path
for i, _in enumerate(self.pathes):
    self.pathes[i]= self.pathes[i][self.path_size* -1:]

# count vehicles and drop counted pathes:
 new_pathes= []
 for i, pathin enumerate(self.pathes):
     d= path[-2:]


    if (
         # need at list two points to count
         len(d) >= 2 and
         # prev point not in exit zone
         not self.check_exit(d[0][1])and
         # current point in exit zone
         self.check_exit(d[1][1])and
         # path len is bigger then min
         self.path_size <= len(path)
     ):
         self.vehicle_count+= 1
    else:
         # prevent linking with path that already in exit zone
         add= True
         for pin path:
             if self.check_exit(p[1]):
                add= False
                 break
        if add:
            new_pathes.append(path)


 self.pathes= new_pathes


 context['pathes']= self.pathes
 context['objects']= objects
 context['vehicle_count']= self.vehicle_count


 self.log.debug('#VEHICLES FOUND: %s' % self.vehicle_count)


 return context

time = ((self.start_time + int(frame_number / self.fps)) * 100 
        + int(100.0 / self.fps) * (frame_number % self.fps))