def cv_to_array(image_cv):
return np.asarray(cv.GetMat(image_cv), dtype=np.float32).ravel()
def main():
orig = cv.LoadImageM("sample/lena.bmp")
np_mat = np.asarray(cv.GetMat(orig))
np_mat = np.rot90(np_mat).copy()
modif = cv.fromarray(np_mat)
cv.SaveImage("sample/lena_90.png", modif)
def map(self, event_filename, video_data):
"""
Args:
event_filename: Tuple of (event, filename)
video_data: Binary video data
Yields:
A tuple in the form of ((event, filename), features) where features is a dict
frame_features: List of frame features
file_size: Size in bytes
where each frame feature is a dictionary of
frame_time: Time in seconds
frame_num: Frame number
prev_frame_num: Previous frame number (useful if there is a frame skip)
keyframe: Boolean True/False
surf: List of surf points (see impoint)
face_widths:
face_heights:
predictions: Dictionary of predictions
"""
sys.stderr.write('In Raw:%s\n' % str(event_filename))
print(event_filename)
ext = '.' + event_filename[1].rsplit('.')[1]
with tempfile.NamedTemporaryFile(suffix=ext) as fp:
with self.timer('Writing video data'):
fp.write(video_data)
fp.flush()
kf = keyframe.DecisionTree(min_interval=0)
kf.load()
prev_frame = None
prev_frame_num = 0
all_out = []
sz = len(video_data)
self.timer.start('KF')
try:
for (frame_num, frame_time, frame), iskeyframe in kf(
viderator.frame_iter(fp.name, frozen=True)):
hadoopy.counter('RawFeatures', 'NumFrames')
self.timer.stop('KF')
print(frame_time)
if frame_num > self._max_frames:
break
if frame_num % 100 == 0:
with self.timer('Computing face features'):
faces = _detect_faces(
imfeat.convert_image(frame,
[('opencv', 'gray', 8)]),
self.cascade)
else:
faces = {}
out = {
'frame_time': frame_time,
'frame_num': frame_num,
'prev_frame_num': prev_frame_num,
'keyframe': iskeyframe,
'surf': kf.prev_vec['surf']
}
if faces: # If any faces
face_heights = np.array([x[0][3] for x in faces
]) / float(frame.height)
face_widths = np.array([x[0][2] for x in faces
]) / float(frame.width)
out['face_widths'] = face_widths
out['face_heights'] = face_heights
# Output the cur and previous frames if this is a keyframe
if iskeyframe and np.random.random(
) < self._frame_output_prob:
out['prev_frame'] = cv_to_jpg(prev_frame)
out['frame'] = cv_to_jpg(frame)
# Compute scene features
with self.timer('Computing scene classifier features'):
frame_res = cv.fromarray(
cv2.resize(
np.asarray(cv.GetMat(frame)),
(self._image_width, self._image_height)))
feature = self._feat(frame_res)
out['predictions'] = dict(
(classifier_name, classifier.predict(feature)) for
classifier_name, classifier in self._classifiers)
# Output JPEG with match lines from the SURF feature
if np.random.random(
) < self._match_line_prob and prev_frame:
out['surf_image'] = cv_to_jpg(
plot_matches(prev_frame,
kf.surf_debug['matches'],
kf.surf_debug['points0'],
kf.surf_debug['points1'],
max_feat_width=kf.max_feat_width))
# Output data buffer
all_out.append(out)
if len(all_out) >= self._block_size:
with self.timer('Yield'):
yield event_filename, {
'frame_features': all_out,
'file_size': sz
}
all_out = []
prev_frame = frame
prev_frame_num = frame_num
self.timer.start('KF')
except viderator.FPSParseException: # NOTE(brandyn): This will disregard videos with this error
hadoopy.counter('SkippedVideos', 'FPSParseException')
return
if all_out:
with self.timer('Yield'):
yield event_filename, {
'frame_features': all_out,
'file_size': sz
}
#!/usr/bin/python
import cv
grayImg = cv.LoadImage("../1.png", cv.CV_LOAD_IMAGE_GRAYSCALE)
mat = cv.GetMat(grayImg)
#cv.SaveImage("test.png", mat)
for i in range(mat.cols):
for j in range(mat.rows):
if mat[j, i] >= 180:
mat[j, i] = 255
else:
mat[j, i] = 0
cv.SaveImage("test.png", mat)
class ugv_image_blue:
def __init__(self):
self.image_pub = rospy.Publisher("/image",Image)
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("/p3dx/front_camera/image_raw",Image,self.callback)
def callback(self,data):
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError, e:
print e
(rows,cols,channels) = cv_image.shape
if cols > 60 and rows > 60 :
cv2.circle(cv_image, (50,50), 10, 255)
### Start of Image Processing ######
hsv = cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV)
lower_blue = np.array([110,50,50])
upper_blue = np.array([130,255,255])
mask = cv2.inRange(hsv, lower_blue, upper_blue)
mat=cv.GetMat(cv.fromarray(mask))
moments=cv.Moments(mat)
if((moments.m01>(-10000000000000)) and (moments.m01<10000000000000) and (moments.m00>(-1000000000000)) and (moments.m00<10000000000000) and (moments.m10>(-1000000000000)) and (moments.m10<10000000000000)):
global detected
mean = mask.mean()
if(mean > 0.5):
detected = 1
if(mean < 0.5 and detected == 1):
detected = 0
yc= moments.m01/moments.m00
xc=moments.m10/moments.m00
width, height = cv.GetSize(mat)
global max_right_blue_x
global max_left_blue_x
global max_right_blue_y
global max_left_blue_y
contours, hierarchy = cv2.findContours(mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
cnt = contours[0]
#print contours
leftmost = tuple(cnt[cnt[:,:,0].argmin()][0])
rightmost = tuple(cnt[cnt[:,:,0].argmax()][0])
max_left_blue_x = leftmost[0]
max_left_blue_y = leftmost[1]
max_right_blue_x = rightmost[0]
max_right_blue_y = rightmost[1]
global nxc_blue
global nyc_blue
nxc_blue=xc-640
nyc_blue=yc-360
new_max_left_blue_x = max_left_blue_x -640
new_max_left_blue_y = max_left_blue_y - 360
new_max_right_blue_x = max_right_blue_x - 640
new_max_right_blue_y = max_right_blue_y - 360
focal=1097.51
q= nxc_blue/focal
q1 = new_max_left_blue_x / focal
q2 = new_max_right_blue_x / focal
global bearing_blue
global bearing_left_edge
global bearing_right_edge
bearing_right_edge = math.atan(q2)*((180.0)/(3.14159))
bearing_left_edge = math.atan(q1)*((180.0)/(3.14159))
bearing_blue=math.atan(q)*((180.0)/(3.14159))
cv2.circle(cv_image,(int(xc),int(yc)),10,(0,0,255),-1)
def _create_grayscale_mat(bgr_bytes, width, height, channel):
image = cv.CreateImageHeader((width, height), cv.IPL_DEPTH_8U, 1)
cv.SetData(image, bgr_bytes[channel::3], width)
return cv.GetMat(image)
def track(self):
# in case something else is still open
cv.DestroyAllWindows()
tracker = Speed()
imgArr = []
capture = cv.CaptureFromCAM(self.camera_index)
if not capture:
QMessageBox.information(self, "Camera Error", "Camera not found")
return
cv.NamedWindow("Video", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("Video", 320, 0)
cv.NamedWindow("Tracking", cv.CV_WINDOW_AUTOSIZE)
cv.MoveWindow("Tracking", 800, 82)
moments = 0
cv.CreateTrackbar("Start at color", "Video", self.low_color, 179, self.update_low_color)
cv.CreateTrackbar("End at color", "Video", self.high_color, 179, self.update_high_color)
start_time = 0
camera_on = True
tracking = False
needs_saving = False
background = 0
while camera_on:
if (not self.busy_updating):
frame = cv.QueryFrame(capture)
if not frame:
break
#convert color to hue space for easier tracking
imgHSV = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.CvtColor(frame, imgHSV, cv.CV_BGR2HSV)
imgThresh = cv.CreateImage(cv.GetSize(frame), 8, 1)
# implement interactive thresholding
cv.InRangeS(imgHSV, cv.Scalar(self.low_color, self.MED_SV, self.MED_SV), cv.Scalar(self.high_color, self.MAX_SV, self.MAX_SV), imgThresh)
# find image momentsm, compute object position
# by dividing by area
moments = cv.Moments(cv.GetMat(imgThresh))
x_mov = cv.GetSpatialMoment(moments, 1, 0)
y_mov = cv.GetSpatialMoment(moments, 0, 1)
area = cv.GetCentralMoment(moments, 0, 0)
# size is 480 360 for webcam
# 324, 243 for massive-imaged external camera
small_thresh = cv.CreateImage((self.fit_camera_width, self.fit_camera_height), 8, 1)
cv.Resize(imgThresh, small_thresh)
small_frame = cv.CreateImage((self.fit_camera_width, self.fit_camera_height), 8, 3)
cv.Resize(frame, small_frame)
cv.ShowImage("Tracking", small_thresh)
cv.ShowImage("Video", small_frame)
k = cv.WaitKey(1)
# press q or escape to quit camera view
if k == 27 or k == 113:
camera_on = False
tracking = False
cv.DestroyAllWindows()
break;
# click "Record!" or press "g" to start tracking speed/recording
elif k == 103 or self.start_record:
needs_saving = True
start_time = time.clock()
tracking = True
# store background in memory and proceed to recording
background = cv.CloneImage(frame)
tracker.start_time = start_time
self.start_record = False
imgArr.append(background)
# click "Stop recording" or press "d" to stop tracking speed/recording
# save everything in the proper format and close recording windows
elif k == 100 or self.end_record:
if needs_saving:
tracking = False
tracker.stop_time = time.clock()
curr_dir = os.listdir(".")
# create the output folder if it doesn't already exist
if self.output_folder not in curr_dir:
path_var = "./" + str(self.output_folder)
os.mkdir(path_var)
# default saving directory is output_folder/Trial_<start time of trial>
new_vid_folder = "./" + str(self.output_folder) + "/Trial_" + str(start_time)
os.mkdir(new_vid_folder)
tracker.out_folder = new_vid_folder
# save the first frame of the film as the background image
background_name = str(tracker.out_folder) + "/background.png"
cv.SaveImage(background_name, background)
index = 0
for img in imgArr:
output_name = str(tracker.out_folder) + "/frame_" + str(index) + ".png"
cv.SaveImage(output_name, img)
index += 1
# compute velocity and acceleration values
tracker.update()
# save the tracking done so far (by pickling)
# can later be exported as a text file
tracker_file = str(tracker.out_folder) + "/Data"
f = open(tracker_file, 'w')
pickle.dump(tracker, f)
f.close()
cv.DestroyAllWindows()
break
else:
cv.DestroyAllWindows()
break
if tracking:
# store object position
if area > 0:
posX = float(x_mov)/float(area)
posY = float(y_mov)/float(area)
curr_time = time.clock()
tracker.add_pos(posX, posY, curr_time - start_time)
start_time = curr_time
imgArr.append(cv.CloneImage(frame))
def getBottomQuarter(img):
sub = cv.GetSubRect(img,
(0, img.height * 3 / 4, img.width, img.height / 4))
return cv.GetMat(sub)
def getPortion(img, portion_num):
sub = cv.GetSubRect(img, (0, img.height * portion_num / num_portions,
img.width, img.height / num_portions))
return cv.GetMat(sub)
def _create_grayscale_image(img_bytes, img_width, img_height, channel):
image = _create_image_header(img_width, img_height, 1)
cv.SetData(image, img_bytes[channel::3], img_width)
return cv.GetMat(image)
def run(self):
while True:
img = cv.QueryFrame(self.capture)
img_undist = cv.CreateImage(cv.GetSize(img), 8, 3)
self.filter.undistort(img, img_undist)
img = img_undist
# Convert the BGR image to HSV space for easier color thresholding
img_hsv = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, img_hsv, cv.CV_BGR2HSV)
# Smooth the image with a Gaussian Kernel
cv.Smooth(img_hsv, img_hsv, cv.CV_BLUR, 3)
# Threshold the HSV image to find yellow objects
img_th = cv.CreateImage(cv.GetSize(img_hsv), 8, 1)
cv.InRangeS(img_hsv, (20, 100, 100), (30, 255, 255), img_th)
# Connected Component Analysis
roi = self.detector.detect(cv.GetMat(img_th))
if len(roi) == 0:
continue
# Only consider the biggest blob
i = max(roi, key=lambda x: roi.get(x).count)
blob = roi[i]
# Filter out blobs that are smaller
if blob.count > 50:
# Draw bounding box and center of object
center_x = int(blob.x1 + (blob.x2 - blob.x1) / 2.0)
center_y = int(blob.y1 + (blob.y2 - blob.y1) / 2.0)
cv.Rectangle(img, (blob.x1, blob.y1), (blob.x2, blob.y2),
cv.RGB(255, 0, 0), 2)
cv.Circle(img, (center_x, center_y), 2, cv.RGB(255, 0, 0), -1)
# Draw cross
cv.Line(img, (int(img.width / 2), 0),
(int(img.width / 2), img.height), cv.RGB(0, 0, 0))
cv.Line(img, (0, int(img.height / 2)),
(img.width, int(img.height / 2)), cv.RGB(0, 0, 0))
# Apply Kalman filter
xhat = self.filter.predictUpdate(self.curr_pitch,
self.curr_yaw, center_x,
center_y)
print math.degrees(xhat[0])
fpix = -1 * self.filter.state2pixel(self.curr_pitch,
self.curr_yaw)
print fpix
cv.Circle(img, (int(fpix[0]), int(fpix[1])), 2,
cv.RGB(0, 255, 0), -1)
#self._MoveCameraHead(center_x, center_y, angle)
# Draw predicted object center
# Display the thresholded image
cv.ShowImage('Tracking', img_undist)
if cv.WaitKey(10) == 27:
break
self.serial.close()
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(file_list(a, ['jpg', 'pgm', 'png']))
else:
if a.find('*') != -1:
files.extend(glob.glob(a))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=opts.service,
elevation=True,
title='Map')
icon = slipmap.icon('redplane.png')
slipmap.add_object(
mp_slipmap.SlipIcon('plane', (0, 0),
icon,
layer=3,
rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
for flag in opts.flag:
a = flag.split(',')
lat = a[0]
lon = a[1]
icon = 'flag.png'
if len(a) > 2:
icon = a[2] + '.png'
icon = slipmap.icon(icon)
slipmap.add_object(
mp_slipmap.SlipIcon('icon - %s' % str(flag),
(float(lat), float(lon)),
icon,
layer=3,
rotation=0,
follow=False))
if opts.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(opts.mission)
plist = wp.polygon_list()
if len(plist) > 0:
for i in range(len(plist)):
slipmap.add_object(
mp_slipmap.SlipPolygon('Mission-%s-%u' % (opts.mission, i),
plist[i],
layer='Mission',
linewidth=2,
colour=(255, 255, 255)))
if opts.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.gammalog is not None:
gamma = parse_gamma_log(opts.gammalog)
else:
gamma = None
if opts.kmzlog:
kmzpos = mav_position.KmlPosition(opts.kmzlog)
else:
kmzpos = None
if opts.triggerlog:
triggerpos = mav_position.TriggerPosition(opts.triggerlog)
else:
triggerpos = None
# create a simple lens model using the focal length
C_params = cam_params.CameraParams(lens=opts.lens,
sensorwidth=opts.sensorwidth)
if opts.camera_params:
C_params.load(opts.camera_params)
camera_settings = MPSettings([
MPSetting('roll_stabilised', bool, opts.roll_stabilised,
'Roll Stabilised'),
MPSetting('altitude',
int,
opts.altitude,
'Altitude',
range=(0, 10000),
increment=1),
MPSetting(
'minalt', int, 30, 'MinAltitude', range=(0, 10000), increment=1),
MPSetting('mpp100',
float,
0.0977,
'MPPat100m',
range=(0, 10000),
increment=0.001),
MPSetting('rotate180', bool, opts.rotate_180, 'rotate180'),
MPSetting('filter_type',
str,
'simple',
'Filter Type',
choice=['simple', 'compactness']),
MPSetting('quality',
int,
75,
'Compression Quality',
range=(1, 100),
increment=1),
MPSetting('thumbsize',
int,
opts.thumbsize,
'Thumbnail Size',
range=(10, 200),
increment=1),
MPSetting('minscore',
int,
opts.minscore,
'Min Score',
range=(0, 1000),
increment=1,
tab='Scoring'),
MPSetting('brightness',
float,
1.0,
'Display Brightness',
range=(0.1, 10),
increment=0.1,
digits=2,
tab='Display')
],
title='Camera Settings')
image_settings = MPSettings([
MPSetting('MinRegionArea',
float,
0.3,
range=(0, 100),
increment=0.05,
digits=2,
tab='Image Processing'),
MPSetting('MaxRegionArea',
float,
4.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('MinRegionSize',
float,
0.1,
range=(0, 100),
increment=0.05,
digits=2),
MPSetting('MaxRegionSize',
float,
3.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('MaxRarityPct',
float,
0.02,
range=(0, 100),
increment=0.01,
digits=2),
MPSetting('RegionMergeSize',
float,
1.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('BlueEmphasis', bool, opts.blue_emphasis),
MPSetting('SaveIntermediate', bool, opts.debug)
],
title='Image Settings')
mosaic = cuav_mosaic.Mosaic(slipmap,
C=C_params,
camera_settings=camera_settings,
image_settings=image_settings,
start_menu=True,
classify=opts.categories,
thumb_size=opts.mosaic_thumbsize)
joelog = cuav_joe.JoeLog(None)
if opts.view:
viewer = mp_image.MPImage(title='Image', can_zoom=True, can_drag=True)
for f in files:
if not mosaic.started():
print("Waiting for startup")
while not mosaic.started():
mosaic.check_events()
time.sleep(0.01)
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
if gamma is not None:
frame_time = parse_gamma_time(f, gamma)
else:
frame_time = cuav_util.parse_frame_time(f)
frame_time += opts.time_offset
if camera_settings.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += opts.time_offset
# update the plane icon on the map
if pos is not None:
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
if camera_settings.altitude > 0:
pos.altitude = camera_settings.altitude
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f, rotate180=camera_settings.rotate180)
if im_orig is None:
continue
(w, h) = cuav_util.image_shape(im_orig)
if not opts.camera_params:
C_params.set_resolution(w, h)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
t0 = time.time()
img_scan = im_full
scan_parms = {}
for name in image_settings.list():
scan_parms[name] = image_settings.get(name)
scan_parms['SaveIntermediate'] = float(scan_parms['SaveIntermediate'])
scan_parms['BlueEmphasis'] = float(scan_parms['BlueEmphasis'])
if pos is not None:
(sw, sh) = cuav_util.image_shape(img_scan)
altitude = pos.altitude
if altitude < camera_settings.minalt:
altitude = camera_settings.minalt
scan_parms[
'MetersPerPixel'] = camera_settings.mpp100 * altitude / 100.0
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions,
cuav_util.image_shape(img_scan),
cuav_util.image_shape(im_full))
count += 1
t1 = time.time()
frame_time = pos.time
regions = cuav_region.filter_regions(
im_full,
regions,
frame_time=frame_time,
min_score=camera_settings.minscore,
filter_type=camera_settings.filter_type)
scan_count += 1
if pos and len(regions) > 0:
altitude = camera_settings.altitude
if altitude <= 0:
altitude = None
joelog.add_regions(frame_time,
regions,
pos,
f,
width=w,
height=h,
altitude=altitude)
mosaic.add_image(pos.time, f, pos)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(
cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.view:
img_view = img_scan
(wview, hview) = cuav_util.image_shape(img_view)
mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(mat, (255, 0, 0))
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
viewer.set_title('Image: ' + os.path.basename(f))
total_time += (t1 - t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' %
(os.path.basename(f), count / total_time, region_count,
scan_count, num_files))
def main():
os.chdir(sys.argv[1])
#print "DELETE ALL FILES FIRST!"
#tree = et.parse("project.xml")
#movie = tree.getroot()
#start_frame = int( movie.attrib["start_frame"] )
#end_frame = int( movie.attrib["end_frame"] )
f_shots = open("shots.txt")
shots = [
(int(start), int(end))
for start, end in [line.split("\t")[0:2] for line in f_shots if line]
]
f_shots.close()
f_chapters = open("chapters.txt")
chapters = [int(line) for line in f_chapters if line]
f_chapters.close()
'''# fix first and add last frame
chapters[0] = start_frame
chapters.append(end_frame)'''
os.chdir("shot_colors")
try:
os.mkdir(OUTPUT_DIR_NAME)
except:
pass
filenames = glob.glob("shot_colors_*.png")
last_shot_nr = 0
ch = 1
for i, shot in enumerate(shots):
start_frame, end_frame = shot
if ch == len(chapters): # will this ever happen, freder?
print "den rest noch"
#print " ".join(filenames[last_shot_nr:])
os.system("convert %s -append chapters\\chapter_%02d.png" %
(" ".join(filenames[last_shot_nr:]), ch))
break
elif end_frame >= chapters[ch]:
#if end_frame >= chapters[ch]:
print ch, ":", last_shot_nr, "->", i - 1
print " ".join(filenames[last_shot_nr:i])
os.system("convert %s -append chapters\\chapter_%02d.png" %
(" ".join(filenames[last_shot_nr:i]), ch))
last_shot_nr = i
ch += 1
os.chdir(OUTPUT_DIR_NAME)
for file_nr, file in enumerate(os.listdir(os.getcwd())):
if os.path.isdir(file):
continue
img_orig = cv.LoadImageM(file)
w, h = img_orig.cols, img_orig.rows
img_hls = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(img_orig, img_hls, cv.CV_BGR2HLS)
output_img = cv.CreateImage((PIXELS_PER_COLOR * NUM_CLUSTERS, h),
cv.IPL_DEPTH_8U, 3)
# convert to numpy array
a = numpy.asarray(cv.GetMat(img_hls))
a = a.reshape(a.shape[0] * a.shape[1],
a.shape[2]) # make it 1-dimensional
# set initial centroids
init_cluster = []
step = w / NUM_CLUSTERS
#for x, y in [(0*step, h*0.1), (1*step, h*0.3), (2*step, h*0.5), (3*step, h*0.7), (4*step, h*0.9)]:
for x, y in [(0 * step, h * 0.1), (1 * step, h * 0.1),
(2 * step, h * 0.3), (3 * step, h * 0.3),
(4 * step, h * 0.5), (5 * step, h * 0.5),
(6 * step, h * 0.7), (7 * step, h * 0.7),
(8 * step, h * 0.9), (9 * step, h * 0.9)]:
x = int(x)
y = int(y)
init_cluster.append(a[y * w + x])
centroids, labels = scipy.cluster.vq.kmeans2(a,
numpy.array(init_cluster))
vecs, dist = scipy.cluster.vq.vq(a, centroids) # assign codes
counts, bins = scipy.histogram(vecs,
len(centroids)) # count occurrences
centroid_count = []
for i, count in enumerate(counts):
if count > 0:
centroid_count.append((centroids[i].tolist(), count))
centroid_count.sort(hls_sort2)
px_count = w * h
x = 0
for item in centroid_count:
count = item[1] * (PIXELS_PER_COLOR * NUM_CLUSTERS)
count = int(math.ceil(count / float(px_count)))
centroid = item[0]
for l in range(count):
if x + l >= PIXELS_PER_COLOR * NUM_CLUSTERS:
break
for y in range(h):
cv.Set2D(output_img, y, x + l,
(centroid[0], centroid[1], centroid[2]))
x += count
output_img_rgb = cv.CreateImage(cv.GetSize(output_img),
cv.IPL_DEPTH_8U, 3)
cv.CvtColor(output_img, output_img_rgb, cv.CV_HLS2BGR)
cv.SaveImage(file, output_img_rgb)
# save to text-file
if file_nr == 0:
f_out = open("..\\..\\chapter_colors.txt", "w")
f_out.write("") # reset
f_out.close()
f_out = open("..\\..\\chapter_colors.txt", "a")
row = cv.GetRow(output_img_rgb, 0)
WIDTH = row.cols
#print WIDTH
data_items = []
counter = 0
last_px = cv.Get1D(row, 0)
for i in range(WIDTH):
px = cv.Get1D(row, i)
if px == last_px:
counter += 1
if i == WIDTH - 1:
#f_out.write("%d, %d, %d, %d _ " % (int(last_px[2]), int(last_px[1]), int(last_px[0]), counter))
data_items.append(
"%d, %d, %d, %d" % (int(last_px[2]), int(
last_px[1]), int(last_px[0]), counter))
continue
else:
#f_out.write("%d, %d, %d, %d _ " % (int(last_px[2]), int(last_px[1]), int(last_px[0]), counter))
data_items.append("%d, %d, %d, %d" % (int(
last_px[2]), int(last_px[1]), int(last_px[0]), counter))
counter = 1
last_px = px
print NUM_CLUSTERS - len(data_items), "colors missing"
for j in range(NUM_CLUSTERS -
len(data_items)): # sometimes there are fewer colors
data_items.append("0, 0, 0, 0")
f_out.write(" _ ".join(data_items))
f_out.write("\n")
f_out.close()
os.system("convert chapter_*.png -append _CHAPTERS.png")
return
cv.NamedWindow("img", cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow("gray", cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow("bin_img", cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow("cnt", cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow("countours", cv.CV_WINDOW_AUTOSIZE)
cv.CvtColor(img, gray, cv.CV_RGB2GRAY)
cv.InRangeS(gray, cv.Scalar(1), cv.Scalar(250), bin_img)
cv.Canny(bin_img, cnt, 10, 100, 3)
storage = cv.CreateMemStorage(0)
contours = cv.FindContours(bin_img, storage, cv.CV_RETR_TREE,
cv.CV_CHAIN_APPROX_SIMPLE, (0, 0))
while contours != None:
cv.DrawContours(dst, contours, cv.CV_RGB(250, 0, 0), cv.CV_RGB(0, 0, 250),
2, 1, 8)
contours = contours.h_next()
mat = cv.GetMat(dst, 0)
cv.Save('matrix.xml', mat)
cv.ShowImage("img", img)
cv.ShowImage("gray", gray)
cv.ShowImage("bin_img", bin_img)
cv.ShowImage("cnt", cnt)
cv.ShowImage("contours", dst)
cv.WaitKey(0)
def cvimg2numpy(cvimg): return numpy.asarray(cv.GetMat(cvimg))
def getCenterHorizontal5(img):
sub = cv.GetSubRect(img, (2 * img.width / 5, 0, img.width / 5, img.height))
return cv.GetMat(sub)
def main():
os.chdir(sys.argv[1])
output_dir = os.path.join(OUTPUT_DIR_NAME, OUTPUT_DIR_NAME)
try:
os.mkdir(output_dir)
except:
pass
os.chdir(OUTPUT_DIR_NAME)
for file in os.listdir(os.getcwd()):
if os.path.isdir(file):
continue
print(file)
if file == ".DS_Store":
print("Stupid .DS_Store files from Finder. Ignore these.")
else:
img_orig = cv.LoadImageM(file)
w, h = img_orig.cols, img_orig.rows
img_hls = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(img_orig, img_hls, cv.CV_BGR2HLS)
output_img = cv.CreateImage((PIXELS_PER_COLOR * NUM_CLUSTERS, h),
cv.IPL_DEPTH_8U, 3)
# convert to numpy array
a = numpy.asarray(cv.GetMat(img_hls))
a = a.reshape(a.shape[0] * a.shape[1],
a.shape[2]) # make it 1-dimensional
# set initial centroids
init_cluster = []
step = w / NUM_CLUSTERS
for x, y in [(0 * step, h * 0.1), (1 * step, h * 0.3),
(2 * step, h * 0.5), (3 * step, h * 0.7),
(4 * step, h * 0.9)]:
x = int(x)
y = int(y)
init_cluster.append(a[y * w + x])
centroids, labels = scipy.cluster.vq.kmeans2(
a, numpy.array(init_cluster))
vecs, dist = scipy.cluster.vq.vq(a, centroids) # assign codes
counts, bins = scipy.histogram(vecs,
len(centroids)) # count occurrences
centroid_count = []
for i, count in enumerate(counts):
if count > 0:
centroid_count.append((centroids[i].tolist(), count))
#centroids = centroids.tolist()
#centroids.sort(hls_sort)
centroid_count.sort(hls_sort2)
px_count = w * h
x = 0
for item in centroid_count:
count = item[1] * (PIXELS_PER_COLOR * NUM_CLUSTERS)
count = int(math.ceil(count / float(px_count)))
centroid = item[0]
for l in range(count):
if x + l >= PIXELS_PER_COLOR * NUM_CLUSTERS:
break
for y in range(h):
cv.Set2D(output_img, y, x + l,
(centroid[0], centroid[1], centroid[2]))
x += count
#for centroid_nr, centroid in enumerate(centroids):
# for j in range(PIXELS_PER_COLOR):
# x = centroid_nr*PIXELS_PER_COLOR + j
# for y in range(h):
# cv.Set2D(output_img, y, x, (centroid[0], centroid[1], centroid[2]))
output_img_rgb = cv.CreateImage(cv.GetSize(output_img),
cv.IPL_DEPTH_8U, 3)
cv.CvtColor(output_img, output_img_rgb, cv.CV_HLS2BGR)
cv.SaveImage(os.path.join(OUTPUT_DIR_NAME, file), output_img_rgb)
print("appending...")
os.chdir(OUTPUT_DIR_NAME)
os.system("convert shot_colors_*.png -append result.png")
#raw_input("- done -")
return
def extractVertical(img, vstart, vend):
sub = cv.GetSubRect(img, (0, vstart, img.width, vend + 1))
return cv.GetMat(sub)
def track(bgr_image, threshold=100):
'''Accepts BGR image and optional object threshold between 0 and 255 (default = 100).
Returns: (x,y) coordinates of centroid if found
(-1,-1) if no centroid was found
None if user hit ESC
'''
# Extract bytes, width, and height
bgr_bytes = bgr_image.tostring()
width = bgr_image.width
height = bgr_image.height
# Create separate red, green, and blue image matrices from bytes
r_image = _create_grayscale_mat(bgr_bytes, width, height, 2)
b_image = _create_grayscale_mat(bgr_bytes, width, height, 0)
g_image = _create_grayscale_mat(bgr_bytes, width, height, 1)
# Remove 1/3 of red and blue components from green
threes_image = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 1)
cv.Set(threes_image, 3)
# Remove 1/3 of green and red components from blue
#_div_and_sub(b_image, r_image, threes_image)
#_div_and_sub(b_image, g_image, threes_image)
# Remove 1/3 of green and blue components from red
#_div_and_sub(r_image, g_image, threes_image)
#_div_and_sub(r_image, b_image, threes_image)
#Remove 1/3 of red and blue components from green
_div_and_sub(g_image, r_image, threes_image)
_div_and_sub(g_image, b_image, threes_image)
#Threshold and erode green image
cv.Threshold(g_image, g_image, threshold, 255, cv.CV_THRESH_BINARY)
cv.Erode(g_image, g_image)
# Threshold and erode red image
#cv.Threshold(r_image, r_image, threshold, 255, cv.CV_THRESH_BINARY)
#cv.Erode(r_image, r_image)
# Threshold and erode blue image
#cv.Threshold(b_image, b_image, threshold, 255, cv.CV_THRESH_BINARY)
#cv.Erode(b_image, b_image)
# Find centroid of eroded image
moments = cv.Moments(cv.GetMat(g_image), 1) # binary flag
#moments = cv.Moments(cv.GetMat(r_image), 1) # binary flag
#moments = cv.Moments(cv.GetMat(b_image), 1) # binary flag
centroid_x = _centroid(moments, 1, 0)
centroid_y = _centroid(moments, 0, 1)
# Assume no centroid
ctr = (-1, -1)
# Use centroid if it exists
if centroid_x != None and centroid_y != None:
ctr = (centroid_x, centroid_y)
# Put black circle in at centroid in image
cv.Circle(bgr_image, ctr, 4, (0, 0, 0))
# Display full-color image
cv.NamedWindow(WINDOW_NAME)
cv.ShowImage(WINDOW_NAME, bgr_image)
# Force image display, setting centroid to None on ESC key input
if cv.WaitKey(5) == 27:
ctr = None
# Return coordinates of centroid
return ctr
def extractHorizontal(img, hstart, hend):
sub = cv.GetSubRect(img, (hstart, 0, hend, img.height))
return cv.GetMat(sub)
def Image_callback(self, image):
try:
self.matImage = np.uint8(
cv.GetMat(self.cvbridge.imgmsg_to_cv(image, "passthrough")))
except CvBridgeError, e:
rospy.logwarn('Exception converting ROS image to opencv: %s' % e)
def Image_callback(self, image):
if self.bInitialized:
self.stampImage = image.header.stamp
try:
imgInput = np.uint8(cv.GetMat(self.cvbridge.imgmsg_to_cv(image, 'passthrough')))
except CvBridgeError, e:
rospy.logwarn('Exception CvBridgeError in image callback: %s' % e)
if (not self.bInitialized_images):
self.InitializeImages(imgInput.shape)
if self.bInitialized_images:
xText = 25
yText = 25
dyText = 20
self.imgProcessed = copy.copy(imgInput)
self.imgDisplay = cv2.cvtColor(imgInput, cv.CV_GRAY2RGB)
display_text = 'checker_size=%0.3f' % self.checker_size
cv2.putText(self.imgDisplay, display_text,
(xText,yText), cv.CV_FONT_HERSHEY_TRIPLEX, 0.5, self.colorFont)
yText += dyText
display_text = 'originArena = [%0.0f, %0.0f]' % (self.ptOriginArena.point.x, self.ptOriginArena.point.y)
cv2.putText(self.imgDisplay, display_text, (xText,yText), cv.CV_FONT_HERSHEY_TRIPLEX, 0.5, self.colorFont)
yText += dyText
# Update image mask
cv2.circle(self.imgMask,
(int(self.ptOriginArena.point.x), int(self.ptOriginArena.point.y)),
int(self.radiusMask), self.colorMax, cv.CV_FILLED)
self.imgProcessed = cv2.bitwise_and(self.imgProcessed, self.imgMask)
self.FindExtrinsics()
# Draw the arena origin.
cv2.circle(self.imgDisplay,
(int(self.ptOriginArena.point.x),int(self.ptOriginArena.point.y)),
3, cv.CV_RGB(0,self.colorMax,0), cv.CV_FILLED)
# Draw the mask circle
cv2.circle(self.imgDisplay,
(int(self.ptOriginArena.point.x),int(self.ptOriginArena.point.y)),
int(self.radiusMask), cv.CV_RGB(0,self.colorMax,0))
display_text = 'radiusMask = ' + str(int(self.radiusMask))
cv2.putText(self.imgDisplay, display_text, (xText,yText), cv.CV_FONT_HERSHEY_TRIPLEX, 0.5, self.colorFont)
yText += dyText
display_text = 'rvec cur=[%+3.3f, %+3.3f, %+3.3f] avg=[%3.3f, %3.3f, %3.3f]' % ((self.rvec2[0]+np.pi)%(2*np.pi)-np.pi,
(self.rvec2[1]+np.pi)%(2*np.pi)-np.pi,
(self.rvec2[2]+np.pi)%(2*np.pi)-np.pi,
(self.rvec2_avg[0]+np.pi)%(2*np.pi)-np.pi,
(self.rvec2_avg[1]+np.pi)%(2*np.pi)-np.pi,
(self.rvec2_avg[2]+np.pi)%(2*np.pi)-np.pi)
cv2.putText(self.imgDisplay, display_text,
(xText,yText), cv.CV_FONT_HERSHEY_TRIPLEX, 0.5, self.colorFont)
yText += dyText
display_text = 'tvec cur=[%+3.3f, %+3.3f, %+3.3f] avg=[%3.3f, %3.3f, %3.3f]' % (self.tvec2[0], self.tvec2[1], self.tvec2[2],
self.tvec2_avg[0], self.tvec2_avg[1], self.tvec2_avg[2])
cv2.putText(self.imgDisplay, display_text,
(xText,yText), cv.CV_FONT_HERSHEY_TRIPLEX, 0.5, self.colorFont)
yText += dyText
display_text = 'pixels_per_mm=%3.3f' % (self.K_rect[0,0]/self.tvec2_avg[2])
cv2.putText(self.imgDisplay, display_text,
(xText,yText), cv.CV_FONT_HERSHEY_TRIPLEX, 0.5, self.colorFont)
yText += dyText
cv2.imshow('Camera Arena Calibration', self.imgDisplay)
cv2.waitKey(3)
def find_centroid(self, binary):
mat = cv.GetMat(binary)
moments = cv.Moments(mat)
return (int(moments.m10 / moments.m00), int(moments.m01 / moments.m00))
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(glob.glob(os.path.join(a, '*.pgm')))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
joes = []
if opts.mavlog:
mpos = mav_position.MavInterpolator(gps_lag=opts.gps_lag)
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.boundary:
boundary = cuav_util.polygon_load(opts.boundary)
else:
boundary = None
if opts.mosaic:
slipmap = mp_slipmap.MPSlipMap(service='GoogleSat',
elevation=True,
title='Map')
icon = slipmap.icon('planetracker.png')
slipmap.add_object(
mp_slipmap.SlipIcon('plane', (0, 0),
icon,
layer=3,
rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
C_params = cam_params.CameraParams(lens=opts.lens)
path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..',
'..', 'cuav', 'data', 'chameleon1_arecont0.json')
C_params.load(path)
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params)
if boundary is not None:
mosaic.set_boundary(boundary)
if opts.joe:
joes = cuav_util.polygon_load(opts.joe)
if boundary:
for i in range(len(joes)):
joe = joes[i]
if cuav_util.polygon_outside(joe, boundary):
print("Error: joe outside boundary", joe)
return
icon = slipmap.icon('flag.png')
slipmap.add_object(
mp_slipmap.SlipIcon('joe%u' % i, (joe[0], joe[1]),
icon,
layer=4))
joelog = cuav_joe.JoeLog('joe.log')
if opts.view:
viewer = mp_image.MPImage(title='Image')
frame_time = 0
scan_parms = {
'MinRegionArea': opts.min_region_area,
'MaxRegionArea': opts.max_region_area,
'MinRegionSize': opts.min_region_size,
'MaxRegionSize': opts.max_region_size,
'MaxRarityPct': opts.max_rarity_pct,
'RegionMergeSize': opts.region_merge,
'SaveIntermediate': float(opts.debug),
'MetersPerPixel': opts.meters_per_pixel
}
if opts.filter_type == 'compactness':
calculate_compactness = True
print("Using compactness filter")
else:
calculate_compactness = False
for f in files:
if mpos:
frame_time = cuav_util.parse_frame_time(f)
try:
if opts.roll_stabilised:
roll = 0
else:
roll = None
pos = mpos.position(frame_time, opts.max_deltat, roll=roll)
slipmap.set_position('plane', (pos.lat, pos.lon),
rotation=pos.yaw)
except mav_position.MavInterpolatorException as e:
print e
pos = None
else:
pos = None
# check for any events from the map
if opts.mosaic:
slipmap.check_events()
mosaic.check_events()
if f.endswith('.pgm'):
pgm = cuav_util.PGM(f)
im = pgm.array
if pgm.eightbit:
im_8bit = im
else:
im_8bit = numpy.zeros((960, 1280, 1), dtype='uint8')
if opts.gamma != 0:
scanner.gamma_correct(im, im_8bit, opts.gamma)
else:
scanner.reduce_depth(im, im_8bit)
im_full = numpy.zeros((960, 1280, 3), dtype='uint8')
scanner.debayer(im_8bit, im_full)
im_640 = numpy.zeros((480, 640, 3), dtype='uint8')
scanner.downsample(im_full, im_640)
else:
im_orig = cv.LoadImage(f)
(w, h) = cuav_util.image_shape(im_orig)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
if opts.fullres:
img_scan = im_full
else:
img_scan = im_640
t0 = time.time()
for i in range(opts.repeat):
regions = scanner.scan(img_scan, scan_parms)
regions = cuav_region.RegionsConvert(
regions, cuav_util.image_shape(img_scan),
cuav_util.image_shape(im_full), calculate_compactness)
count += 1
t1 = time.time()
if opts.filter:
regions = cuav_region.filter_regions(im_full,
regions,
frame_time=frame_time,
min_score=opts.minscore,
filter_type=opts.filter_type)
scan_count += 1
# optionally link all the images with joe into a separate directory
# for faster re-running of the test with just joe images
if pos and opts.linkjoe and len(regions) > 0:
cuav_util.mkdir_p(opts.linkjoe)
if not cuav_util.polygon_outside((pos.lat, pos.lon), boundary):
joepath = os.path.join(opts.linkjoe, os.path.basename(f))
if os.path.exists(joepath):
os.unlink(joepath)
os.symlink(f, joepath)
if pos and len(regions) > 0:
joelog.add_regions(frame_time,
regions,
pos,
f,
width=1280,
height=960,
altitude=opts.altitude)
if boundary:
regions = cuav_region.filter_boundary(regions, boundary, pos)
region_count += len(regions)
if opts.mosaic and len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(
cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.compress:
jpeg = scanner.jpeg_compress(im_full, opts.quality)
jpeg_filename = f[:-4] + '.jpg'
if os.path.exists(jpeg_filename):
print('jpeg %s already exists' % jpeg_filename)
continue
chameleon.save_file(jpeg_filename, jpeg)
if opts.view:
if opts.fullres:
img_view = im_full
else:
img_view = img_scan
mat = cv.fromarray(img_view)
for r in regions:
(x1, y1, x2, y2) = r.tuple()
(w, h) = cuav_util.image_shape(img_view)
x1 = x1 * w // 1280
x2 = x2 * w // 1280
y1 = y1 * h // 960
y2 = y2 * h // 960
cv.Rectangle(mat, (max(x1 - 2, 0), max(y1 - 2, 0)),
(x2 + 2, y2 + 2), (255, 0, 0), 2)
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
total_time += (t1 - t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' %
(f, count / total_time, region_count, scan_count, num_files))
def atualiza_brilhocontraste(self):
if self.contraste > 0:
delta = 127. * self.contraste / 100
a = 255. / (255. - delta * 2)
b = a * (self.brilho - delta)
else:
delta = -128. * self.contraste / 100
a = (256. - delta * 2) / 255.
b = a * self.brilho + delta
cv.ConvertScale(self.imagem_fonte, self.imagem_destino, a, b)
cv.ShowImage("Foto Tons Cinza", self.imagem_destino)
self.calcularHistograma()
cv.ShowImage("Histograma", self.imagemHistograma)
cv.EqualizeHist(self.imagem_destino, self.imagem_destino)
cv.ShowImage("Foto Equalizada", self.imagem_destino)
self.calcularHistograma()
cv.ShowImage("Histograma Equalizado", self.imagemHistograma)
if __name__ == "__main__":
imagem = cv.LoadImageM('foto.jpg')
cv.NamedWindow("Foto Original", 0)
cv.ShowImage("Foto Original", imagem)
imagem_cinza = cv.GetMat(cv.LoadImage('foto.jpg', 0))
histograma = Histograma(imagem_cinza)
cv.WaitKey(0)
def _hist(self, i):
(hist, bin_edges) = np.histogram(np.asarray(cv.GetMat(i)), bins=50)
rd.set("histogram", json.dumps(hist.tolist()))
def main():
project_root_dir = sys.argv[1]
os.chdir(project_root_dir)
os.chdir(os.path.join(OUTPUT_DIR_NAME, OUTPUT_DIR_NAME))
output_img = cv.CreateImage((WIDTH, WIDTH), cv.IPL_DEPTH_8U, 3)
print(os.system("identify -format \"%k\" result.png"))
print("reducing colors to 10")
os.system("convert result.png +dither -colors 10 result_quant.png")
img_orig = cv.LoadImageM("result_quant.png")
output_img = cv.CreateImage((WIDTH, WIDTH), cv.IPL_DEPTH_8U, 3)
img_hls = cv.CreateImage(cv.GetSize(img_orig), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(img_orig, img_hls, cv.CV_BGR2HLS)
pixels = numpy.asarray(cv.GetMat(img_hls))
d = {}
print("counting...")
for line in pixels:
for px in line:
if tuple(px) in d:
d[tuple(px)] += 1
else:
d[tuple(px)] = 1
colors = d.keys()
#print "%d pixels, %d colors" % (img_orig.width*img_orig.height, len(colors))
print("sorting...")
#colors.sort(hls_sort)
colors = sort_by_distance(colors)
px_count = img_orig.width * img_orig.height
x_pos = 0
print("building image...")
for color in colors:
l = d[color] / float(px_count)
l = int(math.ceil(l * WIDTH))
for x in range(l):
if x_pos + x >= WIDTH:
break
for y in range(WIDTH):
cv.Set2D(output_img, y, x_pos + x,
(int(color[0]), int(color[1]), int(color[2])))
x_pos += l
print("saving...")
output_img_rgb = cv.CreateImage(cv.GetSize(output_img), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(output_img, output_img_rgb, cv.CV_HLS2BGR)
cv.SaveImage("_RESULT.png", output_img_rgb)
f = open(os.path.join("..", "..", "colors.txt"), "w")
row = cv.GetRow(output_img_rgb, 0)
counter = 0
last_px = cv.Get1D(row, 0)
for i in range(WIDTH):
px = cv.Get1D(row, i)
if px == last_px:
counter += 1
if i == WIDTH - 1:
f.write("%d, %d, %d, %d\n" % (int(last_px[2]), int(
last_px[1]), int(last_px[0]), counter))
continue
else:
f.write(
"%d, %d, %d, %d\n" %
(int(last_px[2]), int(last_px[1]), int(last_px[0]), counter))
counter = 1
last_px = px
f.close()
return
def run(self):
# Initialize
#log_file_name = "tracker_output.log"
#log_file = file( log_file_name, 'a' )
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
# Capture the first frame from webcam for image properties
display_image = cv.QueryFrame(self.capture)
# Greyscale image, thresholded to create the motion mask:
grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
# The RunningAvg() function requires a 32-bit or 64-bit image...
running_average_image = cv.CreateImage(cv.GetSize(frame),
cv.IPL_DEPTH_32F, 3)
# ...but the AbsDiff() function requires matching image depths:
running_average_in_display_color_depth = cv.CloneImage(display_image)
# RAM used by FindContours():
mem_storage = cv.CreateMemStorage(0)
# The difference between the running average and the current frame:
difference = cv.CloneImage(display_image)
target_count = 1
last_target_count = 1
last_target_change_t = 0.0
k_or_guess = 1
codebook = []
frame_count = 0
last_frame_entity_list = []
t0 = time.time()
# For toggling display:
image_list = ["camera", "difference", "threshold", "display", "faces"]
image_index = 0 # Index into image_list
# Prep for text drawing:
text_font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, .5, .5, 0.0, 1,
cv.CV_AA)
text_coord = (5, 15)
text_color = cv.CV_RGB(255, 255, 255)
###############################
### Face detection stuff
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_default.xml' )
haar_cascade = cv.Load('haarcascades/haarcascade_frontalface_alt.xml')
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt2.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_mcs_mouth.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_eye.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt_tree.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_upperbody.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_profileface.xml' )
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 3
while True:
# Capture frame from webcam
camera_image = cv.QueryFrame(self.capture)
frame_count += 1
frame_t0 = time.time()
# Create an image with interactive feedback:
display_image = cv.CloneImage(camera_image)
# Create a working "color image" to modify / blur
color_image = cv.CloneImage(display_image)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 19, 0)
# Use the Running Average as the static background
# a = 0.020 leaves artifacts lingering way too long.
# a = 0.320 works well at 320x240, 15fps. (1/a is roughly num frames.)
cv.RunningAvg(color_image, running_average_image, 0.320, None)
# Convert the scale of the moving average.
cv.ConvertScale(running_average_image,
running_average_in_display_color_depth, 1.0, 0.0)
# Subtract the current frame from the moving average.
cv.AbsDiff(color_image, running_average_in_display_color_depth,
difference)
# Convert the image to greyscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
# Threshold the image to a black and white motion mask:
cv.Threshold(grey_image, grey_image, 2, 255, cv.CV_THRESH_BINARY)
# Smooth and threshold again to eliminate "sparkles"
cv.Smooth(grey_image, grey_image, cv.CV_GAUSSIAN, 19, 0)
cv.Threshold(grey_image, grey_image, 240, 255, cv.CV_THRESH_BINARY)
grey_image_as_array = numpy.asarray(cv.GetMat(grey_image))
non_black_coords_array = numpy.where(grey_image_as_array > 3)
# Convert from numpy.where()'s two separate lists to one list of (x, y) tuples:
non_black_coords_array = zip(non_black_coords_array[1],
non_black_coords_array[0])
points = [
] # Was using this to hold either pixel coords or polygon coords.
bounding_box_list = []
# Now calculate movements using the white pixels as "motion" data
contour = cv.FindContours(grey_image, mem_storage,
cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
while contour:
bounding_rect = cv.BoundingRect(list(contour))
point1 = (bounding_rect[0], bounding_rect[1])
point2 = (bounding_rect[0] + bounding_rect[2],
bounding_rect[1] + bounding_rect[3])
bounding_box_list.append((point1, point2))
polygon_points = cv.ApproxPoly(list(contour), mem_storage,
cv.CV_POLY_APPROX_DP)
# To track polygon points only (instead of every pixel):
#points += list(polygon_points)
# Draw the contours:
###cv.DrawContours(color_image, contour, cv.CV_RGB(255,0,0), cv.CV_RGB(0,255,0), levels, 3, 0, (0,0) )
cv.FillPoly(grey_image, [
list(polygon_points),
], cv.CV_RGB(255, 255, 255), 0, 0)
cv.PolyLine(display_image, [
polygon_points,
], 0, cv.CV_RGB(255, 255, 255), 1, 0, 0)
#cv.Rectangle( display_image, point1, point2, cv.CV_RGB(120,120,120), 1)
contour = contour.h_next()
# Find the average size of the bbox (targets), then
# remove any tiny bboxes (which are prolly just noise).
# "Tiny" is defined as any box with 1/10th the area of the average box.
# This reduces false positives on tiny "sparkles" noise.
box_areas = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
box_areas.append(box_width * box_height)
#cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(255,0,0), 1)
average_box_area = 0.0
if len(box_areas):
average_box_area = float(sum(box_areas)) / len(box_areas)
trimmed_box_list = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
# Only keep the box if it's not a tiny noise box:
if (box_width * box_height) > average_box_area * 0.1:
trimmed_box_list.append(box)
# Draw the trimmed box list:
#for box in trimmed_box_list:
# cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(0,255,0), 2 )
bounding_box_list = merge_collided_bboxes(trimmed_box_list)
# Draw the merged box list:
for box in bounding_box_list:
cv.Rectangle(display_image, box[0], box[1],
cv.CV_RGB(0, 255, 0), 1)
# Here are our estimate points to track, based on merged & trimmed boxes:
estimated_target_count = len(bounding_box_list)
# Don't allow target "jumps" from few to many or many to few.
# Only change the number of targets up to one target per n seconds.
# This fixes the "exploding number of targets" when something stops moving
# and the motion erodes to disparate little puddles all over the place.
if frame_t0 - last_target_change_t < .350: # 1 change per 0.35 secs
estimated_target_count = last_target_count
else:
if last_target_count - estimated_target_count > 1:
estimated_target_count = last_target_count - 1
if estimated_target_count - last_target_count > 1:
estimated_target_count = last_target_count + 1
last_target_change_t = frame_t0
# Clip to the user-supplied maximum:
estimated_target_count = min(estimated_target_count, max_targets)
# The estimated_target_count at this point is the maximum number of targets
# we want to look for. If kmeans decides that one of our candidate
# bboxes is not actually a target, we remove it from the target list below.
# Using the numpy values directly (treating all pixels as points):
points = non_black_coords_array
center_points = []
if len(points):
# If we have all the "target_count" targets from last frame,
# use the previously known targets (for greater accuracy).
k_or_guess = max(estimated_target_count,
1) # Need at least one target to look for.
if len(codebook) == estimated_target_count:
k_or_guess = codebook
#points = vq.whiten(array( points )) # Don't do this! Ruins everything.
codebook, distortion = vq.kmeans(array(points), k_or_guess)
# Convert to tuples (and draw it to screen)
for center_point in codebook:
center_point = (int(center_point[0]), int(center_point[1]))
center_points.append(center_point)
#cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 0, 0), 2)
#cv.Circle(display_image, center_point, 5, cv.CV_RGB(255, 0, 0), 3)
# Now we have targets that are NOT computed from bboxes -- just
# movement weights (according to kmeans). If any two targets are
# within the same "bbox count", average them into a single target.
#
# (Any kmeans targets not within a bbox are also kept.)
trimmed_center_points = []
removed_center_points = []
for box in bounding_box_list:
# Find the centers within this box:
center_points_in_box = []
for center_point in center_points:
if center_point[0] < box[right][0] and center_point[0] > box[left][0] and \
center_point[1] < box[bottom][1] and center_point[1] > box[top][1] :
# This point is within the box.
center_points_in_box.append(center_point)
# Now see if there are more than one. If so, merge them.
if len(center_points_in_box) > 1:
# Merge them:
x_list = y_list = []
for point in center_points_in_box:
x_list.append(point[0])
y_list.append(point[1])
average_x = int(float(sum(x_list)) / len(x_list))
average_y = int(float(sum(y_list)) / len(y_list))
trimmed_center_points.append((average_x, average_y))
# Record that they were removed:
removed_center_points += center_points_in_box
if len(center_points_in_box) == 1:
trimmed_center_points.append(
center_points_in_box[0]) # Just use it.
# If there are any center_points not within a bbox, just use them.
# (It's probably a cluster comprised of a bunch of small bboxes.)
for center_point in center_points:
if (not center_point in trimmed_center_points) and (
not center_point in removed_center_points):
trimmed_center_points.append(center_point)
# Draw what we found:
#for center_point in trimmed_center_points:
# center_point = ( int(center_point[0]), int(center_point[1]) )
# cv.Circle(display_image, center_point, 20, cv.CV_RGB(255, 255,255), 1)
# cv.Circle(display_image, center_point, 15, cv.CV_RGB(100, 255, 255), 1)
# cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 255, 255), 2)
# cv.Circle(display_image, center_point, 5, cv.CV_RGB(100, 255, 255), 3)
# Determine if there are any new (or lost) targets:
actual_target_count = len(trimmed_center_points)
last_target_count = actual_target_count
# Now build the list of physical entities (objects)
this_frame_entity_list = []
# An entity is list: [ name, color, last_time_seen, last_known_coords ]
for target in trimmed_center_points:
# Is this a target near a prior entity (same physical entity)?
entity_found = False
entity_distance_dict = {}
for entity in last_frame_entity_list:
entity_coords = entity[3]
delta_x = entity_coords[0] - target[0]
delta_y = entity_coords[1] - target[1]
distance = sqrt(pow(delta_x, 2) + pow(delta_y, 2))
entity_distance_dict[distance] = entity
# Did we find any non-claimed entities (nearest to furthest):
distance_list = entity_distance_dict.keys()
distance_list.sort()
for distance in distance_list:
# Yes; see if we can claim the nearest one:
nearest_possible_entity = entity_distance_dict[distance]
# Don't consider entities that are already claimed:
if nearest_possible_entity in this_frame_entity_list:
#print "Target %s: Skipping the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3], nearest_possible_entity[1] )
continue
#print "Target %s: USING the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3] , nearest_possible_entity[1])
# Found the nearest entity to claim:
entity_found = True
nearest_possible_entity[
2] = frame_t0 # Update last_time_seen
nearest_possible_entity[
3] = target # Update the new location
this_frame_entity_list.append(nearest_possible_entity)
#log_file.write( "%.3f MOVED %s %d %d\n" % ( frame_t0, nearest_possible_entity[0], nearest_possible_entity[3][0], nearest_possible_entity[3][1] ) )
break
if entity_found == False:
# It's a new entity.
color = (random.randint(0, 255), random.randint(0, 255),
random.randint(0, 255))
name = hashlib.md5(str(frame_t0) +
str(color)).hexdigest()[:6]
last_time_seen = frame_t0
new_entity = [name, color, last_time_seen, target]
this_frame_entity_list.append(new_entity)
#log_file.write( "%.3f FOUND %s %d %d\n" % ( frame_t0, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
# Now "delete" any not-found entities which have expired:
entity_ttl = 1.0 # 1 sec.
for entity in last_frame_entity_list:
last_time_seen = entity[2]
if frame_t0 - last_time_seen > entity_ttl:
# It's gone.
#log_file.write( "%.3f STOPD %s %d %d\n" % ( frame_t0, entity[0], entity[3][0], entity[3][1] ) )
pass
else:
# Save it for next time... not expired yet:
this_frame_entity_list.append(entity)
# For next frame:
last_frame_entity_list = this_frame_entity_list
# Draw the found entities to screen:
for entity in this_frame_entity_list:
center_point = entity[3]
c = entity[1] # RGB color tuple
cv.Circle(display_image, center_point, 20,
cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 15,
cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 10,
cv.CV_RGB(c[0], c[1], c[2]), 2)
cv.Circle(display_image, center_point, 5,
cv.CV_RGB(c[0], c[1], c[2]), 3)
#print "min_size is: " + str(min_size)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
# Toggle which image to show
if chr(c) == 'd':
image_index = (image_index + 1) % len(image_list)
image_name = image_list[image_index]
# Display frame to user
if image_name == "camera":
image = camera_image
cv.PutText(image, "Camera (Normal)", text_coord, text_font,
text_color)
elif image_name == "difference":
image = difference
cv.PutText(image, "Difference Image", text_coord, text_font,
text_color)
elif image_name == "display":
image = display_image
cv.PutText(image, "Targets (w/AABBs and contours)", text_coord,
text_font, text_color)
elif image_name == "threshold":
# Convert the image to color.
cv.CvtColor(grey_image, display_image, cv.CV_GRAY2RGB)
image = display_image # Re-use display image here
cv.PutText(image, "Motion Mask", text_coord, text_font,
text_color)
elif image_name == "faces":
# Do face detection
detect_faces(camera_image, haar_cascade, mem_storage)
image = camera_image # Re-use camera image here
cv.PutText(image, "Face Detection", text_coord, text_font,
text_color)
cv.ShowImage("Target", image)
if self.writer:
cv.WriteFrame(self.writer, image)
#log_file.flush()
# If only using a camera, then there is no time.sleep() needed,
# because the camera clips us to 15 fps. But if reading from a file,
# we need this to keep the time-based target clipping correct:
frame_t1 = time.time()
# If reading from a file, put in a forced delay:
if not self.writer:
delta_t = frame_t1 - frame_t0
if delta_t < (1.0 / 15.0): time.sleep((1.0 / 15.0) - delta_t)
t1 = time.time()
time_delta = t1 - t0
processed_fps = float(frame_count) / time_delta
print "Got %d frames. %.1f s. %f fps." % (frame_count, time_delta,
processed_fps)
class uav_image_green:
def __init__(self):
self.image_pub = rospy.Publisher("/image", Image)
cv2.namedWindow("Image window", 1)
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("/uav/downward_cam/camera/image",
Image, self.callback)
def callback(self, data):
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError, e:
print e
### Start of Image Processing ######
hsv = cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV)
lower_green = np.array([50, 50, 50])
upper_green = np.array([70, 255, 255])
mask = cv2.inRange(hsv, lower_green, upper_green)
mat = cv.GetMat(cv.fromarray(mask))
moments = cv.Moments(mat)
if ((moments.m01 >
(-10000000000000)) and (moments.m01 < 10000000000000)
and (moments.m00 >
(-1000000000000)) and (moments.m00 < 10000000000000)
and (moments.m10 >
(-1000000000000)) and (moments.m10 < 10000000000000)):
global yc_green
global xc_green
yc_green = moments.m01 / moments.m00
xc_green = moments.m10 / moments.m00
width, height = cv.GetSize(mat)
global max_right_green_x
global max_right_green_y
global max_left_green_x
global max_left_green_y
global bottom_green_y
global bottom_green_x
contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)
cnt = contours[0]
#print contours
leftmost = tuple(cnt[cnt[:, :, 0].argmin()][0])
rightmost = tuple(cnt[cnt[:, :, 0].argmax()][0])
bottommost = tuple(cnt[cnt[:, :, 1].argmax()][0])
max_left_green_x = leftmost[0]
max_left_green_y = leftmost[1]
max_right_green_x = rightmost[0]
max_right_green_y = rightmost[1]
bottom_green_x = bottommost[0]
bottom_green_y = bottommost[1]
# max_right_green_x = 0
# for a in range(int(round(xc_green)), width, 3):
# for b in range (0, height, 3):
# if(mat[b,a] == 0):
# continue
# elif(a > max_right_green_x):
# max_right_green_x = a
# max_right_green_y = b
# global max_left_green_x
# global max_left_green_y
# max_left_green_x = width
# for a2 in range(int(round(xc_green)), 0, -3):
# for b2 in range (0, height, 3):
# if(mat[b2,a2] == 0):
# continue
# elif(a2 < max_left_green_x):
# max_left_green_x = a2
# max_left_green_y = b2
global nxc_green
global nyc_green
nxc_green = xc_green - 320
nyc_green = yc_green - 240
focal = 1690.0 #1097.51
q = nxc_green / focal
global bearing
bearing = math.atan(q) * ((180.0) / (3.14159))
# cv2.circle(cv_image,(int(max_right_green_x),int(yc_green)),3,(0,0,255),-1)
# cv2.circle(cv_image,(int(max_left_green_y),int(yc_green)),3,(0,0,255),-1)
#cv2.imshow('Thresholded', mask)
### End of Image Processing ######
#cv2.imshow('UAV Image', cv_image)
cv2.waitKey(1)
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError, e:
print e
class Target:
def __init__(self):
self.capture = cv.CaptureFromCAM(0)
cv.NamedWindow(“Target”, 1)
cv.NamedWindow(“Threshold1”,1)
cv.NamedWindow(“Threshold2”,1)
cv.NamedWindow(“hsv”,1)
def run(self):
#initiate font
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 3, 8)
#instantiate images
hsv_img=cv.CreateImage(cv.GetSize(cv.QueryFrame(self.capture)),8,3)
threshold_img1 = cv.CreateImage(cv.GetSize(hsv_img),8,1)
threshold_img1a = cv.CreateImage(cv.GetSize(hsv_img),8,1)
threshold_img2 = cv.CreateImage(cv.GetSize(hsv_img),8,1)
i=0
writer=cv.CreateVideoWriter(“angle_tracking.avi”,cv.CV_FOURCC(‘M’,’J’,’P’,’G’),30,cv.GetSize(hsv_img),1)
while True:
#capture the image from the cam
img=cv.QueryFrame(self.capture)
#convert the image to HSV
cv.CvtColor(img,hsv_img,cv.CV_BGR2HSV)
#threshold the image to isolate two colors
cv.InRangeS(hsv_img,(165,145,100),(250,210,160),threshold_img1) #red
cv.InRangeS(hsv_img,(0,145,100),(10,210,160),threshold_img1a) #red again
cv.Add(threshold_img1,threshold_img1a,threshold_img1) #this is combining the two limits for red
cv.InRangeS(hsv_img,(105,180,40),(120,260,100),threshold_img2) #blue
#determine the moments of the two objects
threshold_img1=cv.GetMat(threshold_img1)
threshold_img2=cv.GetMat(threshold_img2)
moments1=cv.Moments(threshold_img1,0)
moments2=cv.Moments(threshold_img2,0)
area1=cv.GetCentralMoment(moments1,0,0)
area2=cv.GetCentralMoment(moments2,0,0)
#initialize x and y
x1,y1,x2,y2=(1,2,3,4)
coord_list=[x1,y1,x2,y2]
for x in coord_list:
x=0
#there can be noise in the video so ignore objects with small areas
if (area1 >200000):
#x and y coordinates of the center of the object is found by dividing the 1,0 and 0,1 moments by the area
x1=int(cv.GetSpatialMoment(moments1,1,0)/area1)
y1=int(cv.GetSpatialMoment(moments1,0,1)/area1)
#draw circle
cv.Circle(img,(x1,y1),2,(0,255,0),20)
#write x and y position
cv.PutText(img,str(x1)+”,”+str(y1),(x1,y1+20),font, 255) #Draw the text
if (area2 >100000):
#x and y coordinates of the center of the object is found by dividing the 1,0 and 0,1 moments by the area
x2=int(cv.GetSpatialMoment(moments2,1,0)/area2)
y2=int(cv.GetSpatialMoment(moments2,0,1)/area2)
#draw circle
cv.Circle(img,(x2,y2),2,(0,255,0),20)
cv.PutText(img,str(x2)+”,”+str(y2),(x2,y2+20),font, 255) #Draw the text
cv.Line(img,(x1,y1),(x2,y2),(0,255,0),4,cv.CV_AA)
#draw line and angle
cv.Line(img,(x1,y1),(cv.GetSize(img)[0],y1),(100,100,100,100),4,cv.CV_AA)
x1=float(x1)
y1=float(y1)
x2=float(x2)
y2=float(y2)
angle = int(math.atan((y1-y2)/(x2-x1))*180/math.pi)
cv.PutText(img,str(angle),(int(x1)+50,(int(y2)+int(y1))/2),font,255)
#cv.WriteFrame(writer,img)
#display frames to users
cv.ShowImage(“Target”,img)
cv.ShowImage(“Threshold1”,threshold_img1)
cv.ShowImage(“Threshold2”,threshold_img2)
cv.ShowImage(“hsv”,hsv_img)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
cv.DestroyAllWindows()
