-
Notifications
You must be signed in to change notification settings - Fork 70
/
selective_search.py
209 lines (148 loc) · 6.24 KB
/
selective_search.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
##########################################################################
# Example : detect live selective search bounding boxes from a video file
# specified on the command line (e.g. python FILE.py video_file) or from an
# attached web camera
# Author : Toby Breckon, toby.breckon@durham.ac.uk
# Copyright (c) 2021 Dept. Computer Science,
# Durham University, UK
# License : LGPL - http://www.gnu.org/licenses/lgpl.html
##########################################################################
import cv2
import argparse
import sys
import math
#####################################################################
# press all the go-faster buttons - i.e. speed-up using multithreads
cv2.setUseOptimized(True)
cv2.setNumThreads(4)
# if we have OpenCL H/W acceleration availale, use it - we'll need it
cv2.ocl.setUseOpenCL(True)
print(
"INFO: OpenCL - available: ",
cv2.ocl.haveOpenCL(),
" using: ",
cv2.ocl.useOpenCL())
##########################################################################
keep_processing = True
# parse command line arguments for camera ID or video file
parser = argparse.ArgumentParser(
description='Perform ' +
sys.argv[0] +
' example operation on incoming camera/video image')
parser.add_argument(
"-c",
"--camera_to_use",
type=int,
help="specify camera to use",
default=0)
parser.add_argument(
"-r",
"--rescale",
type=float,
help="rescale image by this factor",
default=1.0)
parser.add_argument(
"-fs",
"--fullscreen",
action='store_true',
help="run in full screen mode")
parser.add_argument(
'video_file',
metavar='video_file',
type=str,
nargs='?',
help='specify optional video file')
args = parser.parse_args()
##########################################################################
# define video capture object
try:
# to use a non-buffered camera stream (via a separate thread)
if not (args.video_file):
import camera_stream
cap = camera_stream.CameraVideoStream()
else:
cap = cv2.VideoCapture() # not needed for video files
except BaseException:
# if not then just use OpenCV default
print("INFO: camera_stream class not found - camera input may be buffered")
cap = cv2.VideoCapture()
# define display window name
window_name = "Selective Search - Bounding Boxes" # window name
# if command line arguments are provided try to read video_name
# otherwise default to capture from attached camera
if (((args.video_file) and (cap.open(str(args.video_file))))
or (cap.open(args.camera_to_use))):
# create window by name (as resizable)
cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
#####################################################################
# create Selective Search Segmentation Object using default parameters
ss = cv2.ximgproc.segmentation.createSelectiveSearchSegmentation()
while (keep_processing):
# start a timer (to see how long processing and display takes)
start_t = cv2.getTickCount()
# if camera /video file successfully open then read frame
if (cap.isOpened):
ret, frame = cap.read()
# when we reach the end of the video (file) exit cleanly
if (ret == 0):
keep_processing = False
continue
# rescale if specified
if (args.rescale != 1.0):
frame = cv2.resize(
frame, (0, 0), fx=args.rescale, fy=args.rescale)
# set input image on which we will run segmentation
ss.setBaseImage(frame)
# Switch to fast but low recall Selective Search method
ss.switchToSelectiveSearchFast()
# Switch to high recall but slow Selective Search method (slower)
# ss.switchToSelectiveSearchQuality()
# run selective search segmentation on input image
rects = ss.process()
print('Total Number of Region Proposals: {}'.format(len(rects)))
# number of region proposals to show
numShowRects = 100
# iterate over all the region proposals
for i, rect in enumerate(rects):
# draw rectangle for region proposal till numShowRects
if (i < numShowRects):
x, y, w, h = rect
cv2.rectangle(frame, (x, y), (x+w, y+h),
(0, 255, 0), 1, cv2.LINE_AA)
else:
break
# stop the timer and convert to ms. (to see how long processing and
# display takes)
stop_t = ((cv2.getTickCount() - start_t) /
cv2.getTickFrequency()) * 1000
label = ('Processing time: %.2f ms' % stop_t) + \
(' (Framerate: %.2f fps' % (1000 / stop_t)) + ')'
cv2.putText(frame, label, (0, 15),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255))
# display image
cv2.imshow(window_name, frame)
cv2.setWindowProperty(window_name, cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN & args.fullscreen)
# start the event loop - essential
# cv2.waitKey() is a keyboard binding function (argument is the time in
# milliseconds). It waits for specified milliseconds for any keyboard
# event. If you press any key in that time, the program continues.
# If 0 is passed, it waits indefinitely for a key stroke.
# (bitwise and with 0xFF to extract least significant byte of
# multi-byte response)
# wait 40ms or less depending on processing time taken (i.e. 1000ms /
# 25 fps = 40 ms)
key = cv2.waitKey(max(2, 40 - int(math.ceil(stop_t)))) & 0xFF
# It can also be set to detect specific key strokes by recording which
# key is pressed
# e.g. if user presses "x" then exit / press "f" for fullscreen
# display
if (key == ord('x')):
keep_processing = False
elif (key == ord('f')):
args.fullscreen = not (args.fullscreen)
# close all windows
cv2.destroyAllWindows()
else:
print("No video file specified or camera connected.")
##########################################################################