基于OpenCV制作道路车辆计数应用程序
基于OpenCV制作道路车辆计数应用程序
发展前景
随着科学技术的进步和工业的发展，城市中交通量激增，原始的交通方式已不能满足要求；同时，由于工业发展为城市交通提供的各种交通工具越来越多，从而加速了城市交通事业的发展。
道路容量严重不足 汽车增长速度过快 公共交通日趋萎缩
交通设施条件不足 缺乏整体发展战略
交通计数应用程序是为了统计交通流量用的，对城市、或公路网络，道路的规划设计所必须的参数-交通量（当然包含比如日交通量、年交通量、日交通高峰流量等）
今天，我们将学习如何根据计算机视觉和没有复杂的深度学习算法来计算道路交通量。 下面，我们将使用Python和OpenCV，在背景减法算法的帮助下，使用非常简单的运动检测思想。
这是我们的计划：
理解用于前景检测的背景减法算法的主要思想。
OpenCV图像过滤器。
通过轮廓检测物体。
构建处理管道以进一步处理数据。
下面这个视频是从youtube上下载：https://youtu.be/wqctLW0Hb_0
背景减法算法
背景减法有许多不同的算法，但它们的主要思想非常简单。 我们假设您有一个房间的视频，并且在该视频的某些帧上没有人和宠物，所以基本上它是静态的，我们称之为background_layer。因此，要获取正在视频中移动的对象，我们只需要：
foreground_objects = current_frame - background_layer
但在某些情况下，我们无法获得静态帧，因为灯光可能会发生变化，或某些物体会被某人移动，或者总是存在运动等等。在这种情况下，我们会保存一定数量的帧并试图找出哪些像素大多数都是一样的，然后这个像素成为background_layer的一部分。区别在于我们如何获得此background_layer以及我们用于使选择更准确的其他过滤。
在本课中，我们将使用MOG算法进行背景减法，处理后，它看起来像这样：
左侧的原始帧，右侧的MOG（带阴影检测）减去前景。
正如您所看到的那样，前景蒙版上会出现一些噪音，我们会尝试使用一些标准的滤镜技术来消除这些噪音。
现在我们的代码看起来像这样：
def train_bg_subtractor(inst, cap, num=500):
'''
BG减法器需要处理一些帧来开始给出结果
'''
print('Training BG Subtractor...')
i = 0
while cap.isOpened():
ret, frame = cap.read()
inst.apply(frame, None, 0.001)
i += 1
if i >= num:
return cap
# 创造MOG BG减法器,缓存500帧和阴影剔除
bg_subtractor = cv2.createBackgroundSubtractorMOG2(history=500, detectShadows=True)
# 设置图像源
cap = cv2.VideoCapture('input.mp4')
# 跳过500帧训练bg减法器
train_bg_subtractor(bg_subtractor, cap, num=500)
帧——就是影像动画中最小单位的单幅影像画面，相当于电影胶片上的每一格镜头。 一帧就是一副静止的画面，连续的帧就形成动画，如电视图象等。 我们通常说帧数，简单地说，就是在1秒钟时间里传输的图片的帧数，也可以理解为图形处理器每秒钟能够刷新几次，通常用fps（Frames Per Second）表示。每一帧都是静止的图象，快速连续地显示帧便形成了运动的假象。高的帧率可以得到更流畅、更逼真的动画。每秒钟帧数 (fps) 愈多，所显示的动作就会愈流畅。
哪吒：按照24帧/秒的人眼帧数
过滤
对于我们的情况，我们将需要这个过滤器：
阈值，侵蚀，扩张，开运算，闭运算。
腐蚀
卷积核沿着图像滑动，如果与卷积核对应的原图像的所有像素值都是 1，那么中心元素就保持原来的像素值，否则就变为零。
erosion = cv2.erode(img,kernel,iterations = 1)
膨胀
与腐蚀相反，与卷积核对应的原图像的像素值中只要有一个是 1，中心元素的像素值就是 1。
dilation = cv2.dilate(img,kernel,iterations = 1)
开运算（去噪）
先腐蚀再膨胀就叫做开运算。就像我们上面介绍的那样，它被用来去除噪声。这里我们用到的函数是 cv2.morphologyEx()。
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
闭运算（填黑点）
先膨胀再腐蚀。它经常被用来填充前景物体中的小洞，或者前景物体上的小黑点。
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
所以现在我们将使用它们去除前景蒙版上的一些噪音。 首先，我们将使用闭运算去除区域中的间隙，然后打开以移除1-2 px点，然后再扩张后使目标对象更大。
def filter_mask(self, img, a=None):
# 这个过滤器是根据视觉测试手工挑选的
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2, 2))
# 填补任何小洞
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
# 去除噪音
opening = cv2.morphologyEx(closing, cv2.MORPH_OPEN, kernel)
# 膨胀以合并相邻的小块
dilation = cv2.dilate(opening, kernel, iterations=2)
return dilation
我们的前景看起来像这样：
通过轮廓检测物体
为此，我们将使用带有params的标准cv2.findContours方法：
函数 cv2.findContours() 有三个参数：
第一个是输入图像，第二个是轮廓检索模式，第三个是轮廓近似方法。
返回值有三个，第一个是图像（现在没了），第二个是轮廓，第三个是（轮廓的）层析结构。轮廓（第二个返回值）是一个 Python列表，其中存储这图像中的所有轮廓。每一个轮廓都是一个 Numpy 数组，包含对象边界点（x，y）的坐标。
cv2.CV_RETR_EXTERNAL - 仅获取外轮廓。
cv2.CV_CHAIN_APPROX_TC89_L1 - 使用Teh-Chin链式近似算法（更快）
# 得到边界框的中心
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 = []
# 发现外部轮廓
contours, hierarchy = cv2.findContours(
fg_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1) # 根据高度，宽度进行过滤
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 # 得到边界框的中心
centroid = get_centroid(x, y, w, h)
# 将轮廓加入数组中
matches.append(((x, y, w, h), centroid)) return matches
在出口处，我们按高度，宽度过滤然后添加质心。很简单，是吗？
Pipeline封装
你必须明白，在ML和CV中没有一个魔术算法可以处理所有事情，即使我们想象这样的算法存在，我们仍然不会使用它，因为它在规模上不会有效。
例如几年前，Netflix以300万美元的奖金为最佳电影推荐算法创造了竞争。其中一个团队创建了这样的问题，就是它无法大规模运作，因此对公司来说毫无用处。但是，Netflix仍为它们支付了100万美元:)
所以现在我们将构建简单的处理流程，它不仅仅是为了方便但规模相同的规模。
class PipelineRunner(object):
'''
非常简单的pipline。
只需按顺序运行处理程序，将上下文从一个传递到另一个。
您还可以为处理器设置日志级别。
'''
def __init__(self, pipeline=None, log_level=logging.DEBUG):
self.pipeline = pipeline or []
self.context = {}
self.log = logging.getLogger(self.__class__.__name__)
self.log.setLevel(log_level)
self.log_level = log_level
self.set_log_level()
def set_context(self, data):
self.context = data
def add(self, processor):
if not isinstance(processor, PipelineProcessor):
raise Exception(
'Processor should be an isinstance of PipelineProcessor.')
processor.log.setLevel(self.log_level)
self.pipeline.append(processor)
def remove(self, name):
for i, p in enumerate(self.pipeline):
if p.__class__.__name__ == name:
del self.pipeline[i]
return True
return False
def set_log_level(self):
for p in self.pipeline:
p.log.setLevel(self.log_level)
def run(self):
for p in self.pipeline:
self.context = p(self.context)
self.log.debug("Frame #%d processed.", self.context['frame_number'])
return self.context
class PipelineProcessor(object):
'''
处理器的基类。
'''
def __init__(self):
self.log = logging.getLogger(self.__class__.__name__)
作为输入构造函数将采取将按顺序运行的处理器列表。每个处理器都是这项工作的一部分。让我们创建轮廓检测处理器。
class ContourDetection(PipelineProcessor):
'''
检测移动物体。
这个处理器的目的是减去背景，获得移动物体
并使用cv2.findContours方法检测它们，然后过滤掉宽度和高度不符合的。
bg_subtractor - 背景减法器isinstance。
min_contour_width - 最小边界矩形宽度。
min_contour_height - 最小边界矩形高度。
save_image - 如果为True，则将检测到的对象掩码保存到文件中。
image_dir - 保存图像的位置（必须存在）。
'''
def __init__(self, bg_subtractor, min_contour_width=35, min_contour_height=35, save_image=False,
image_dir='images'):
super(ContourDetection, self).__init__()
self.bg_subtractor = bg_subtractor
self.min_contour_width = min_contour_width
self.min_contour_height = min_contour_height
self.save_image = save_image
self.image_dir = image_dir
def filter_mask(self, img, a=None):
# 这个过滤器是根据视觉测试手工挑选的
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2, 2))
# 闭运算，填补任何小洞
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
# 开运算，去除噪音
opening = cv2.morphologyEx(closing, cv2.MORPH_OPEN, kernel)
# 膨胀以合并相邻的小块
dilation = cv2.dilate(opening, kernel, iterations=2)
return dilation
def detect_vehicles(self, fg_mask, context):
matches = []
# 发现外部轮廓
contours, hierarchy = cv2.findContours(fg_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1)
for (i, contour) in enumerate(contours):
# 找到其中一条轮廓,进行高和宽的过滤
(x, y, w, h) = cv2.boundingRect(contour)
contour_valid = (w >= self.min_contour_width) and (
h >= self.min_contour_height)
if not contour_valid:
# 不满足过滤掉
continue
# 得到边界框的中心
centroid = utils.get_centroid(x, y, w, h)
# 将轮廓加入数组中
matches.append(((x, y, w, h), centroid))
return matches
def __call__(self, context):
frame = context['frame'].copy()
frame_number = context['frame_number']
fg_mask = self.bg_subtractor.apply(frame, None, 0.001)
# 只是阈值化
fg_mask[fg_mask < 240] = 0
fg_mask = self.filter_mask(fg_mask, frame_number)
if self.save_image:
#可选,保存过滤后的黑白图片
utils.save_frame(fg_mask, self.image_dir +
"/mask_%04d.png" % frame_number, flip=False)
#进行目标检测
context['objects'] = self.detect_vehicles(fg_mask, context)
context['fg_mask'] = fg_mask
return context
所以只需将bg减法，过滤和检测三个部分合并在一起。 现在让我们创建一个处理器，它将链接到不同帧上的检测对象，并创建路径，也将计算到达出口区域的车辆。
class VehicleCounter(PipelineProcessor):
'''
计算进入出口区域的车辆。
此类的目的是基于检测到的对象和本地缓存创建
对象修补和计数在退出区域中定义的退出区域中输入的对象。
exit_masks - 退出监测后的点集合列表。
path_size - 路径中的最大点数。
max_dst - 两点之间的最大距离。
'''
def __init__(self, exit_masks=[], path_size=10, max_dst=30, x_weight=1.0, y_weight=1.0):
super(VehicleCounter, self).__init__()
self.exit_masks = exit_masks
self.vehicle_count = 0
self.path_size = path_size
self.pathes = []
self.max_dst = max_dst
self.x_weight = x_weight
self.y_weight = y_weight
def check_exit(self, point):
for exit_mask in self.exit_masks:
try:
if exit_mask[point[1]][point[0]] == 255:
return True
except:
return True
return False
def __call__(self, context):
objects = context['objects']
context['exit_masks'] = self.exit_masks
context['pathes'] = self.pathes
context['vehicle_count'] = self.vehicle_count
if not objects:
return context
points = np.array(objects)[:, 0:2]
points = points.tolist()
# 如果pathes为空，则添加新点
if not self.pathes:
for match in points:
self.pathes.append([match])
else:
# 根据最小距离链接新点与旧路径
# points
new_pathes = []
for path in self.pathes:
_min = 999999
_match = None
for p in points:
if len(path) == 1:
# distance from last point to current
d = utils.distance(p[0], path[-1][0])
else:
# 基于前2个点预测下一个点并计算
# 从预测的下一个点到当前的距离
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 _match and _min <= self.max_dst:
points.remove(_match)
path.append(_match)
new_pathes.append(path)
# 如果当前帧没有匹配，则不丢弃路径
if _match is None:
new_pathes.append(path)
self.pathes = new_pathes
# 添加新的pathes
if len(points):
for p in points:
# 不添加已经计算的点数
if self.check_exit(p[1]):
continue
self.pathes.append([p])
# 仅保存路径中的最后N个点
for i, _ in enumerate(self.pathes):
self.pathes[i] = self.pathes[i][self.path_size * -1:]
# 计算车辆和去除计数pathes：
new_pathes = []
for i, path in enumerate(self.pathes):
d = path[-2:]
if (
# 需要列表中的两点来计算
len(d) >= 2 and
# 上一个点不是在出口区
not self.check_exit(d[0][1]) and
# 当前点在出口区
self.check_exit(d[1][1]) and
# path len 大于 path_size
self.path_size <= len(path)
):
self.vehicle_count += 1
else:
# 禁止链接已经在退出区域中的路径
add = True
for p in 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
这个类有点复杂，所以让我们按部分来看看。
图像上的绿色面具是出口区域，是我们计算车辆的地方。例如，我们将仅计算长度超过3个点（以消除一些噪音）的路径和绿色区域中的第4个路径。 我们使用掩码导致它的许多操作比使用矢量算法更有效和简单。只需使用“二进制和”操作来检查该区域中的那个点，就是这样。这是我们如何设置它：
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]
现在让我们在路径中链接点
# 根据最小距离链接新点与旧路径
# points
new_pathes = []
for path in self.pathes:
_min = 999999
_match = None
for p in points:
if len(path) == 1:
# distance from last point to current
d = utils.distance(p[0], path[-1][0])
else:
# 基于前2个点预测下一个点并计算
# 从预测的下一个点到当前的距离
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 _match and _min <= self.max_dst:
points.remove(_match)
path.append(_match)
new_pathes.append(path)
# 如果当前帧没有匹配，则不丢弃路径
if _match is None:
new_pathes.append(path)
self.pathes = new_pathes
# 添加新的pathes
if len(points):
for p in points:
# 不添加已经计算的点数
if self.check_exit(p[1]):
continue
self.pathes.append([p])
# 仅保存路径中的最后N个点
for i, _ in enumerate(self.pathes):
self.pathes[i] = self.pathes[i][self.path_size * -1:]
在第一帧。我们只是将所有点添加为新路径。
接下来如果len（path）== 1，对于缓存中的每个路径，我们试图从新检测到的对象中找到点（质心），这些对象将具有到路径的最后一个点的最小欧几里德距离。
如果len（路径）> 1，那么路径中的最后两个点我们预测同一条线上的新点，并找到它与当前点之间的最小距离。
最小距离的点添加到当前路径的末尾并从列表中删除。
如果在此之后留下一些点，我们将它们添加为新路径。
而且我们也限制了路径中的点数。
# 计算车辆和去除计数pathes：
new_pathes = []
for i, path in enumerate(self.pathes):
d = path[-2:]
if (
# 需要列表中的两点来计算
len(d) >= 2 and
# 上一个点不是在出口区
not self.check_exit(d[0][1]) and
# 当前点在出口区
self.check_exit(d[1][1]) and
# path len 大于 path_size
self.path_size <= len(path)
):
self.vehicle_count += 1
else:
# 禁止链接已经在退出区域中的路径
add = True
for p in 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)
现在我们将尝试计算进入出口区域的车辆。要做到这一点，我们只需要在路径中取最后两个点，然后检查出口区域中的最后一个点，而不是先前的点，并检查len（路径）是否应大于限制。
之后的部分是防止将新点反向链接到出口区域中的点。
最后两个处理器是CSV编写器，用于创建报告CSV文件，以及用于调试和漂亮图片的可视化。
class Visualizer(PipelineProcessor):
def __init__(self, save_image=True, image_dir='images'):
super(Visualizer, self).__init__()
self.save_image = save_image
self.image_dir = image_dir
def check_exit(self, point, exit_masks=[]):
for exit_mask in exit_masks:
if exit_mask[point[1]][point[0]] == 255:
return True
return False
# 绘制路径
def draw_pathes(self, img, pathes):
if not img.any():
return
for i, path in enumerate(pathes):
path = np.array(path)[:, 1].tolist()
for point in path:
# 画出圆点和蓝色线条实现车尾尾随效果
cv2.circle(img, point, 2, CAR_COLOURS[0], -1)
cv2.polylines(img, [np.int32(path)], False, CAR_COLOURS[0], 1)
return img
# 绘制包裹车的盒子
def draw_boxes(self, img, pathes, exit_masks=[]):
for (i, match) in enumerate(pathes):
contour, centroid = match[-1][:2]
if self.check_exit(centroid, exit_masks):
continue
x, y, w, h = contour
# 根据车的宽高，绘制出车的矩形大小
cv2.rectangle(img, (x, y), (x + w - 1, y + h - 1),
BOUNDING_BOX_COLOUR, 1)
cv2.circle(img, centroid, 2, CENTROID_COLOUR, -1)
return img
def draw_ui(self, img, vehicle_count, exit_masks=[]):
# 这只是为图像添加不透明度的绿色遮罩
for exit_mask in exit_masks:
_img = np.zeros(img.shape, img.dtype)
_img[:, :] = EXIT_COLOR
mask = cv2.bitwise_and(_img, _img, mask=exit_mask)
cv2.addWeighted(mask, 1, img, 1, 0, img)
# 在图片上面绘制计数结果
cv2.rectangle(img, (0, 0), (img.shape[1], 50), (0, 0, 0), cv2.FILLED)
cv2.putText(img, ("Vehicles passed: {total} ".format(total=Zvehicle_count)), (30, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 1)
return img
def __call__(self, context):
frame = context['frame'].copy()
frame_number = context['frame_number']
pathes = context['pathes']
exit_masks = context['exit_masks']
vehicle_count = context['vehicle_count']
frame = self.draw_ui(frame, vehicle_count, exit_masks)
frame = self.draw_pathes(frame, pathes)
frame = self.draw_boxes(frame, pathes, exit_masks)
utils.save_frame(frame, self.image_dir +
"/processed_%04d.png" % frame_number)
return context
CSV编写器正在按时间保存数据，因为我们需要它来进行进一步的分析。所以我使用这个公式为unixtimestamp添加额外的帧时序：
time =（（self.start_time + int（frame_number / self.fps））* 100+ int（100.0 / self.fps）*（frame_number％self.fps））
所以在开始时间= 1 000 000 000和fps = 10的情况下，我将得到像这样的结果 1 = 1 000 000 000 010 帧1 = 1 000 000 000 020 ...
然后，在获得完整的csv报告后，您可以根据需要聚合此数据。
检测过程生成视频
ffmpeg常用命令总结：https://blog.csdn.net/langzijing/article/details/85256846
下载网站：https://ffmpeg.zeranoe.com/builds/
执行命令：ffmpeg -start_number 0 -framerate 15 -i ./out/processed_%04d.png -s:v 1280:720 -c:v libx264 -profile:v high -crf 20 -pix_fmt yuv420p ./out.mp4
结论
所以你看，它并不像很多人想的那么难。
但是，如果您运行该脚本，您将看到此解决方案不理想，并且前景对象存在重叠问题，也没有按照类型对车辆分类（您肯定需要真正的分析）。但是，凭借良好的相机位置（在道路上方），它提供了非常好的准确性。这告诉我们，即使是以正确方式使用的小而简单的算法也能提供良好的结果。
那么我们可以做些什么来解决当前的问题呢？
一种方法是尝试添加一些额外的过滤，试图分离对象以便更好地检测。另一个是使用更复杂的算法，如深度卷积网络。
附加：
yolo 算法
论文标题: 《You Only Look Once: Unified, Real-Time Object Detection》 论文地址：https://arxiv.org/pdf/1506.02640.pdf
v1是yolo系列的开山之作，以简洁的网络结构，简单的复现过程而受到人们的追捧。 yolo_v1奠定了yolo系列算法“分而治之”的基调，在yolo_v1上，输入图片被划分为7X7的网格，如下图所示:
如上图所示，输入图片被划分为7x7个单元格，每个单元格独立作检测。 在这里很容易被误导：每个网格单元的视野有限而且很可能只有局部特征，这样就很难理解yolo为何能检测比grid_cell大很多的物体。其实，yolo的做法并不是把每个单独的网格作为输入feed到模型，在inference的过程中，网格只是物体中心点位置的划分之用，并不是对图片进行切片，不会让网格脱离整体的关系。
可以通过yolo_v1的structure来进一步理解，相比一些复杂的网络结构而言，yolo_v1的网络结构显得亲民得多。基本思想是这样：预测框的位置、大小和物体分类都通过CNN暴力predict出来。
具体训练过程：https://blog.csdn.net/guleileo/article/details/80581858
总结： v1对于整个yolo系列的价值，即v2/v3还保留的特性，可以总结为3点：
使用了leaky ReLU，相比普通ReLU，leaky并不会让负数直接为0
分而治之，用网格来划分图片区域，每块区域独立检测目标；
端到端训练。损失函数的反向传播可以贯穿整个网络，这也是one-stage检测算法的优势。
YOLO局限性：
由于YOLO具有极强的空间限制，它限制了模型在邻近物体上的预测，如果两个物体出现在同一个cell中，模型只能预测一个物体，所以在小物体检测上会出问题。另外模型对训练数据中不包含的物体或具有异常长宽比的物体扩展不是太好。loss函数对大小bbox采取相同的error也是个问题。
西电的一个真实项目：https://www.jianshu.com/p/f9348a21051c
效果：
基于OpenCV制作道路车辆计数应用程序的更多相关文章
- 基于opencv的gpu与cpu对比程序，代码来自opencv的文档中
原文链接: http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/gpu/gpu-basics-similarity/gpu-basi ...
- C++从零实现简单深度神经网络（基于OpenCV）
代码地址如下:http://www.demodashi.com/demo/11138.html 一.准备工作 需要准备什么环境 需要安装有Visual Studio并且配置了OpenCV.能够使用Op ...
- 用Visual C＃开发基于OpenCV的Windows应用程序
http://blog.163.com/wangxh_jy/blog/static/28233883201001581640283/ 关于详细的配置及程序运行截图,请下载:http://downloa ...
- 基于OpenCv的人脸检测、识别系统学习制作笔记之一
基于OpenCv从视频文件到摄像头的人脸检测 在OpenCv中读取视频文件和读取摄像头的的视频流然后在放在一个窗口中显示结果其实是类似的一个实现过程. 先创建一个指向CvCapture结构的指针 Cv ...
- 【MFC】基于OpenCV的魔镜
最近半个月事情太多了,参加了泰迪杯数据挖掘,参加学院的科技节,科技节里面总共我参加了数学建模.PS.软件设计制作.电子设计大赛这4个.还有期中考.英语论文作业.今天终于忙的差不多,有时间来总结一下前段 ...
- 图像矫正-基于opencv实现
一.引言 上篇文章中四种方法对图像进行倾角矫正都非常有效.Hough变换和Radon相似,其抗干扰能力比较强,但是运算量大,程序执行慢,其改进方法为:我们可以不对整幅图像进行操作,可以在图像中选取一块 ...
- 语义分割：基于openCV和深度学习（一）
语义分割:基于openCV和深度学习(一) Semantic segmentation with OpenCV and deep learning 介绍如何使用OpenCV.深度学习和ENet架构执行 ...
- [转载]卡尔曼滤波器及其基于opencv的实现
卡尔曼滤波器及其基于opencv的实现 源地址:http://hi.baidu.com/superkiki1989/item/029f65013a128cd91ff0461b 这个是维基百科中的链接, ...
- 基于Opencv和Mfc的图像处理增强库GOCVHelper(索引)
GOCVHelper(GreenOpen Computer Version Helper )是我在这几年编写图像处理程序的过程中积累下来的函数库.主要是对Opencv的适当扩展和在实现Mfc程序时候的 ...
随机推荐
- CLR 调试概述
利用公共语言运行时 (CLR) 调试 API,工具供应商可以编写调试器来调试运行于 CLR 环境中的应用程序. 要调试的代码可为 CLR 支持的任何代码种类.CLR 调试 API 主要是使用非托管代码 ...
- 关于System.MissingMethodException异常
什么是MissingMethodException 试图动态访问不存在的方法时引发的异常. 继承 Object Exception SystemException MemberAccessExcept ...
- 不用VS调试.Net
将来,任何开发人员都将需要调试应用程序,并且将无法访问Visual Studio,在某些情况下甚至无法访问源代码.例如,在生产web或应用服务器上调试问题时,我真的不想安装Visual Studio并 ...
- BZOJ 1477: 青蛙的约会
二次联通门 : BZOJ 1477: 青蛙的约会 /* BZOJ 1477: 青蛙的约会 扩展欧几里得 列出方程, 判断一下 */ #include <iostream> #include ...
- C Primer Plus AND 菜鸟教程
C语言概述 首先,windows 环境下安装 GCC编译环境 下载 MinGW 下载地址:http://sourceforge.net/projects/mingw/files/ 根据系统环境下载对应 ...
- vue-cli3整体迁移至服务端渲染nuxtjs
vue项目与nuxt.js实在有着太多的不同,例如项目结构变化很大,router.js没了,vuex store写法有变化,router钩子没了等等.老项目毕竟也有一些体量,这么折腾我可接受不了,不过 ...
- DDL 语言
数据库模式定义语言并非程序设计语言,DDL数据库模式定义语言是SQL语言(结构化查询语言)的组成部分. SQL语言包括四种主要程序设计语言类别的语句:数据定义语言(DDL),数据操作语言(DML),数 ...
- Android中创建自定义控件
1.创建一个TitleLayout继承LinearLayout: //创建自定义控件 public class TitleLayout extends LinearLayout { private f ...
- EasyEarth三维可视化解决方案——智慧园区
智慧园区 智慧园区围绕“园区行为数据化”和“园区数据可视化”的核心理念,依托EasyEarth三维可视化基础地理信息云平台,综合运用云计算.物联网.自动化控制.现代通讯.图像识别.软硬件集成等技术,借 ...
- C语言函数内局部变量释放的坑
首先把代码贴上来: #include <stdio.h> #include<windows.h> int f(int **iptr){ ; *iptr = &a; ; ...