def __init__(self, device_num = 0):
self.camera = vd.VidereCap(device_num)
#self.camera.process_frames()
self.camera.set_mode(vd.NONE)
vd.set_gain(self.camera.capture, 96)
vd.set_exposure(self.camera.capture, 255)
self.camera.process_frames()
self.low_exposure_left = cv.cvCreateImage(cv.cvGetSize(self.camera.left_debayered), 8, 3)
self.low_exposure_right = cv.cvCreateImage(cv.cvGetSize(self.camera.right_debayered), 8, 3)
def __init__(self, device_num=0):
self.camera = vd.VidereCap(device_num)
#self.camera.process_frames()
self.camera.set_mode(vd.NONE)
vd.set_gain(self.camera.capture, 96)
vd.set_exposure(self.camera.capture, 255)
self.camera.process_frames()
self.low_exposure_left = cv.cvCreateImage(
cv.cvGetSize(self.camera.left_debayered), 8, 3)
self.low_exposure_right = cv.cvCreateImage(
cv.cvGetSize(self.camera.right_debayered), 8, 3)
def detect(self, image):
# image size is needed by underlying opencv lib to allocate memory
image_size = opencv.cvGetSize(image)
# the algorithm works with grayscale images
grayscale = opencv.cvCreateImage(image_size, 8, 1)
opencv.cvCvtColor(image, grayscale, opencv.CV_BGR2GRAY)
# more underlying c lib memory allocation
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
# equalize histogram
opencv.cvEqualizeHist(grayscale, grayscale)
# detect faces using haar cascade, the used file is trained to
# detect frontal faces
cascade = opencv.cvLoadHaarClassifierCascade(
'haarcascade_frontalface_alt.xml', opencv.cvSize(1, 1))
faces = opencv.cvHaarDetectObjects(grayscale, cascade, storage, 1.2, 2,
opencv.CV_HAAR_DO_CANNY_PRUNING,
opencv.cvSize(100, 100))
# draw rectangles around faces
for face in faces:
opencv.cvRectangle(
image, opencv.cvPoint(int(face.x), int(face.y)),
opencv.cvPoint(int(face.x + face.width),
int(face.y + face.height)),
opencv.CV_RGB(127, 255, 0), 2)
# return faces casted to list here, otherwise some obscure bug
# in opencv will make it segfault if the casting happens later
return image, list(faces)
def findcontours(iplimage, threshold=100):
srcimage = opencv.cvCloneImage(iplimage)
# create the storage area and bw image
grayscale = opencv.cvCreateImage(opencv.cvGetSize(srcimage), 8, 1)
opencv.cvCvtColor(srcimage, grayscale, opencv.CV_BGR2GRAY)
#threshold
opencv.cvThreshold(grayscale, grayscale, threshold, 255, opencv.CV_THRESH_BINARY)
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
# find the contours
nb_contours, contours = opencv.cvFindContours (grayscale, storage)
# comment this out if you do not want approximation
contours = opencv.cvApproxPoly (contours, opencv.sizeof_CvContour, storage, opencv.CV_POLY_APPROX_DP, 3, 1)
# next line is for ctypes-opencv
#contours = opencv.cvApproxPoly (contours, opencv.sizeof(opencv.CvContour), storage, opencv.CV_POLY_APPROX_DP, 3, 1)
conts = []
for cont in contours.hrange():
points=[]
for pt in cont:
points.append((pt.x,pt.y))
conts.append(points)
opencv.cvReleaseMemStorage(storage)
opencv.cvReleaseImage(srcimage)
opencv.cvReleaseImage(grayscale)
return (nb_contours, conts)
def findcontours(iplimage, threshold=100):
srcimage = opencv.cvCloneImage(iplimage)
# create the storage area and bw image
grayscale = opencv.cvCreateImage(opencv.cvGetSize(srcimage), 8, 1)
opencv.cvCvtColor(srcimage, grayscale, opencv.CV_BGR2GRAY)
# threshold
opencv.cvThreshold(grayscale, grayscale, threshold, 255, opencv.CV_THRESH_BINARY)
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
# find the contours
nb_contours, contours = opencv.cvFindContours(grayscale, storage)
# comment this out if you do not want approximation
contours = opencv.cvApproxPoly(contours, opencv.sizeof_CvContour, storage, opencv.CV_POLY_APPROX_DP, 3, 1)
# next line is for ctypes-opencv
# contours = opencv.cvApproxPoly (contours, opencv.sizeof(opencv.CvContour), storage, opencv.CV_POLY_APPROX_DP, 3, 1)
conts = []
for cont in contours.hrange():
points = []
for pt in cont:
points.append((pt.x, pt.y))
conts.append(points)
opencv.cvReleaseMemStorage(storage)
opencv.cvReleaseImage(srcimage)
opencv.cvReleaseImage(grayscale)
return (nb_contours, conts)
def detect(self, image):
# image size is needed by underlying opencv lib to allocate memory
image_size = opencv.cvGetSize(image)
# the algorithm works with grayscale images
grayscale = opencv.cvCreateImage(image_size, 8, 1)
opencv.cvCvtColor(image, grayscale, opencv.CV_BGR2GRAY)
# more underlying c lib memory allocation
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
# equalize histogram
opencv.cvEqualizeHist(grayscale, grayscale)
# detect faces using haar cascade, the used file is trained to
# detect frontal faces
cascade = opencv.cvLoadHaarClassifierCascade(
'haarcascade_frontalface_alt.xml', opencv.cvSize(1, 1))
faces = opencv.cvHaarDetectObjects(
grayscale, cascade, storage, 1.2, 2,
opencv.CV_HAAR_DO_CANNY_PRUNING, opencv.cvSize(100, 100))
# draw rectangles around faces
for face in faces:
opencv.cvRectangle(
image, opencv.cvPoint(
int(face.x), int(face.y)),
opencv.cvPoint(int(face.x + face.width),
int(face.y + face.height)), opencv.CV_RGB(127, 255, 0), 2)
# return faces casted to list here, otherwise some obscure bug
# in opencv will make it segfault if the casting happens later
return image, list(faces)
def get_test_data():
cfg = configuration.configuration('../data/ROS_test_client/',
'dummyScanner')
pc = processor.processor(cfg)
pc.scan_dataset = scan_dataset()
pc.scan_dataset.image_artag_filename = ''
pc.scan_dataset.table_plane_translation = np.matrix([0, 0, 0]).T
#approximate height of hokuyo above the ground, assume it to be fixed for now.
pc.scan_dataset.ground_plane_translation = np.matrix([0, 0, 1.32]).T
pc.scan_dataset.ground_plane_rotation = ''
#pc.scan_dataset.is_test_set = True
pc.scan_dataset.is_labeled = True
pc.scan_dataset.id = 'ROStest'
pc.load_raw_data(pc.scan_dataset.id)
image_size = cv.cvGetSize(pc.img)
#don't do any mapping to not change the pts3d!
#create point cloud from raw range points
(pc.pts3d, pc.scan_indices,
pc.intensities) = pc.create_pointcloud(pc.laserscans, True, True)
#region of interest in image pixels
polygon = label_object()
polygon.set_label('surface')
width_min = image_size.width * 0.4
width_max = image_size.width * 0.95
height_min = image_size.height * 0.3
height_max = image_size.height * 0.95
polygon.add_point((width_min, height_min))
polygon.add_point((width_min, height_max))
polygon.add_point((width_max, height_max))
polygon.add_point((width_max, height_min))
return pc.pts3d, pc.intensities, None, pc.img, pc.image_angle, polygon
def get_test_data():
cfg = configuration.configuration("../data/ROS_test_client/", "dummyScanner")
pc = processor.processor(cfg)
pc.scan_dataset = scan_dataset()
pc.scan_dataset.image_artag_filename = ""
pc.scan_dataset.table_plane_translation = np.matrix([0, 0, 0]).T
# approximate height of hokuyo above the ground, assume it to be fixed for now.
pc.scan_dataset.ground_plane_translation = np.matrix([0, 0, 1.32]).T
pc.scan_dataset.ground_plane_rotation = ""
# pc.scan_dataset.is_test_set = True
pc.scan_dataset.is_labeled = True
pc.scan_dataset.id = "ROStest"
pc.load_raw_data(pc.scan_dataset.id)
image_size = cv.cvGetSize(pc.img)
# don't do any mapping to not change the pts3d!
# create point cloud from raw range points
(pc.pts3d, pc.scan_indices, pc.intensities) = pc.create_pointcloud(pc.laserscans, True, True)
# region of interest in image pixels
polygon = label_object()
polygon.set_label("surface")
width_min = image_size.width * 0.4
width_max = image_size.width * 0.95
height_min = image_size.height * 0.3
height_max = image_size.height * 0.95
polygon.add_point((width_min, height_min))
polygon.add_point((width_min, height_max))
polygon.add_point((width_max, height_max))
polygon.add_point((width_max, height_min))
return pc.pts3d, pc.intensities, None, pc.img, pc.image_angle, polygon
def detect(image):
# Find out how large the file is, as the underlying C-based code
# needs to allocate memory in the following steps
image_size = opencv.cvGetSize(image)
# create grayscale version - this is also the point where the allegation about
# facial recognition being racist might be most true. A caucasian face would have more
# definition on a webcam image than an African face when greyscaled.
# I would suggest that adding in a routine to overlay edge-detection enhancements may
# help, but you would also need to do this to the training images as well.
grayscale = opencv.cvCreateImage(image_size, 8, 1)
opencv.cvCvtColor(image, grayscale, opencv.CV_BGR2GRAY)
# create storage (It is C-based so you need to do this sort of thing)
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
# equalize histogram
opencv.cvEqualizeHist(grayscale, grayscale)
# detect objects - Haar cascade step
# In this case, the code uses a frontal_face cascade - trained to spot faces that look directly
# at the camera. In reality, I found that no bearded or hairy person must have been in the training
# set of images, as the detection routine turned out to be beardist as well as a little racist!
cascade = opencv.cvLoadHaarClassifierCascade('haarcascade_frontalface_alt.xml', opencv.cvSize(1,1))
faces = opencv.cvHaarDetectObjects(grayscale, cascade, storage, 1.2, 2, opencv.CV_HAAR_DO_CANNY_PRUNING, opencv.cvSize(50, 50))
if faces:
for face in faces:
# Hmm should I do a min-size check?
# Draw a Chartreuse rectangle around the face - Chartruese rocks
opencv.cvRectangle(image, opencv.cvPoint( int(face.x), int(face.y)),
opencv.cvPoint(int(face.x + face.width), int(face.y + face.height)),
opencv.CV_RGB(127, 255, 0), 2) # RGB #7FFF00 width=2
def __init__(self, frame):
self.blob_image = opencv.cvCloneImage(frame.iplimage)
self.blob_gray = opencv.cvCreateImage(opencv.cvGetSize(self.blob_image), 8, 1)
self.blob_mask = opencv.cvCreateImage(opencv.cvGetSize(self.blob_image), 8, 1)
opencv.cvSet(self.blob_mask, 1)
opencv.cvCvtColor(self.blob_image, self.blob_gray, opencv.CV_BGR2GRAY)
# opencv.cvEqualizeHist(self.blob_gray, self.blob_gray)
# opencv.cvThreshold(self.blob_gray, self.blob_gray, frame.thresh, 255, opencv.CV_THRESH_BINARY)
# opencv.cvThreshold(self.blob_gray, self.blob_gray, frame.thresh, 255, opencv.CV_THRESH_TOZERO)
opencv.cvThreshold(self.blob_gray, self.blob_gray, frame.bthresh, 255, frame.bthreshmode)
# opencv.cvAdaptiveThreshold(self.blob_gray, self.blob_gray, 255, opencv.CV_ADAPTIVE_THRESH_MEAN_C, opencv.CV_THRESH_BINARY_INV)
self._frame_blobs = CBlobResult(self.blob_gray, self.blob_mask, 100, True)
self._frame_blobs.filter_blobs(10, 10000)
self.count = self._frame_blobs.GetNumBlobs()
self.items = []
for i in range(self.count):
self.items.append(self._frame_blobs.GetBlob(i))
def __init__(self, frame):
self.blob_image = opencv.cvCloneImage(frame.iplimage)
self.blob_gray = opencv.cvCreateImage(opencv.cvGetSize(self.blob_image), 8, 1)
self.blob_mask = opencv.cvCreateImage(opencv.cvGetSize(self.blob_image), 8, 1)
opencv.cvSet(self.blob_mask, 1)
opencv.cvCvtColor(self.blob_image, self.blob_gray, opencv.CV_BGR2GRAY)
#opencv.cvEqualizeHist(self.blob_gray, self.blob_gray)
#opencv.cvThreshold(self.blob_gray, self.blob_gray, frame.thresh, 255, opencv.CV_THRESH_BINARY)
#opencv.cvThreshold(self.blob_gray, self.blob_gray, frame.thresh, 255, opencv.CV_THRESH_TOZERO)
opencv.cvThreshold(self.blob_gray, self.blob_gray, frame.bthresh, 255, frame.bthreshmode)
#opencv.cvAdaptiveThreshold(self.blob_gray, self.blob_gray, 255, opencv.CV_ADAPTIVE_THRESH_MEAN_C, opencv.CV_THRESH_BINARY_INV)
self._frame_blobs = CBlobResult(self.blob_gray, self.blob_mask, 100, True)
self._frame_blobs.filter_blobs(10, 10000)
self.count = self._frame_blobs.GetNumBlobs()
self.items = []
for i in range(self.count):
self.items.append(self._frame_blobs.GetBlob(i))
def main(argv):
# Frames per second
fps = 20
tux_pos = 5
tux_pos_min = 0.0
tux_pos_max = 9.0
try:
opts, args = getopt.getopt(argv, "fps", ["framerate=",])
except getopt.GetoptError:
sys.exit(2)
for opt, arg in opts:
if opt in ("-fps", "--framerate"):
fps = arg
camera = highgui.cvCreateCameraCapture(0)
while True:
highgui.cvNamedWindow('Camera', 1)
im = highgui.cvQueryFrame(camera)
if im is None:
break
# mirror
opencv.cv.cvFlip(im, None, 1)
# positions = face.detect(im, 'haarcascade_data/haarcascade_profileface.xml')
positions = face.detect(im, 'haarcascade_data/haarcascade_frontalface_alt2.xml')
# if not positions:
# positions = face.detect(im, 'haarcascade_data/haarcascade_frontalface_alt2.xml')
# display webcam image
highgui.cvShowImage('Camera', im)
# Division of the screen to count as "walking" motion to trigger tux
image_size = opencv.cvGetSize(im)
motion_block = image_size.width / 9
if positions:
mp = None
for position in positions:
if not mp or mp['width'] > position['width']:
mp = position
pos = (mp['x'] + (mp['width'] / 2)) / motion_block
print "tux pos: %f" % tux_pos
print "pos: %f" % pos
if pos != tux_pos:
if tux_pos > pos:
move_tux_right(tux_pos - pos)
elif tux_pos < pos:
move_tux_left(pos - tux_pos)
tux_pos = pos
if highgui.cvWaitKey(fps) >= 0:
highgui.cvDestroyWindow('Camera')
sys.exit(0)
def ipl2cairo(iplimage):
srcimage = opencv.cvCloneImage(iplimage)
width = srcimage.width
height = srcimage.height
image = opencv.cvCreateImage(opencv.cvGetSize(srcimage), 8, 4)
opencv.cvCvtColor(srcimage, image, opencv.CV_BGR2BGRA)
buffer = numpy.fromstring(image.imageData, dtype=numpy.uint32).astype(numpy.uint32)
buffer.shape = (image.width, image.height)
opencv.cvReleaseImage(srcimage)
opencv.cvReleaseImage(image)
return cairo.ImageSurface.create_for_data(buffer, cairo.FORMAT_RGB24, width, height, width * 4)
def ipl2cairo(iplimage):
srcimage = opencv.cvCloneImage(iplimage)
width = srcimage.width
height = srcimage.height
image = opencv.cvCreateImage(opencv.cvGetSize(srcimage),8, 4)
opencv.cvCvtColor(srcimage,image,opencv.CV_BGR2BGRA)
buffer = numpy.fromstring(image.imageData, dtype=numpy.uint32).astype(numpy.uint32)
buffer.shape = (image.width, image.height)
opencv.cvReleaseImage(srcimage)
opencv.cvReleaseImage(image)
return cairo.ImageSurface.create_for_data(buffer, cairo.FORMAT_RGB24, width, height, width*4)
def run():
filename = 'C:\\Documents and Settings\\rmccormack\\Desktop\\work_projects\\openCV\\test\\test1.jpg'
im = hg.cvLoadImage(filename)
if not im:
print "Error opening %s" % filename
sys.exit(-1)
im2 = opencv.cvCreateImage(opencv.cvGetSize(im), 8, 4)
opencv.cvCvtColor(im, im2, opencv.CV_BGR2BGRA)
buffer = numpy.fromstring(im2.imageData,
dtype=numpy.uint32).astype(numpy.float32)
buffer.shape = (im2.width, im2.height)
return buffer
def test_segmentation():
rospy.wait_for_service('segment_pointcloud')
try:
pts3d, intensities, labels, image, image_angle, polygon = get_test_data(
)
ROS_pointcloud = convert_pointcloud_to_ROS(pts3d, intensities, labels)
ROS_image = convert_cvimage_to_ROS(image)
imageSize = cv.cvGetSize(image)
ROS_polygon = convert_polygon_to_ROS(polygon)
segment_pointcloud = rospy.ServiceProxy('segment_pointcloud',
Segmentation)
request = SegmentationRequest()
request.imageWidth = 41
request.pointcloud = ROS_pointcloud
request.image = ROS_image
request.imageWidth = imageSize.width
request.imageHeight = imageSize.height
request.imageAngle = image_angle
request.regionOfInterest2D = ROS_polygon
request.laserHeightAboveGround = 1.32
request.numberOfPointsToClassify = 1000 #-1 == all
response = segment_pointcloud(request)
pts3d_bound, intensities, labels = convert_ROS_pointcloud_to_pointcloud(
response.pointcloud)
cfg = configuration.configuration('../data/ROS_test_client/',
'dummyScanner')
pc = processor.processor(cfg)
pc.scan_dataset = scan_dataset()
pc.scan_dataset.image_artag_filename = ''
pc.scan_dataset.table_plane_translation = np.matrix([0, 0, 0]).T
pc.scan_dataset.ground_plane_translation = np.matrix(
[0, 0, request.laserHeightAboveGround]).T
pc.scan_dataset.ground_plane_rotation = ''
pc.scan_dataset.is_labeled = True
pc.scan_dataset.id = 'ROStest'
pc.image_angle = ''
pc.pts3d_bound = pts3d_bound
pc.map_polys = labels
pc.scan_dataset.ground_plane_normal = np.matrix([0., 0., 1.]).T
from enthought.mayavi import mlab
pc.display_3d('labels')
mlab.show()
return response
except rospy.ServiceException, e:
print "Service call failed: %s" % e
def __init__(self, src="", time=None):
self.src = src
self.time = time
if self.time:
hg.cvSetCaptureProperty(self.src, hg.CV_CAP_PROP_POS_FRAMES, self.time)
self.iplimage = hg.cvQueryFrame(self.src)
self.width = self.iplimage.width
self.height = self.iplimage.height
self.image = opencv.cvCreateImage(opencv.cvGetSize(self.iplimage),8, 4)
opencv.cvCvtColor(self.iplimage,self.image,opencv.CV_BGR2BGRA)
self.buffer = numpy.fromstring(self.image.imageData, dtype=numpy.uint32).astype(numpy.uint32)
self.buffer.shape = (self.image.width, self.image.height)
self.time = hg.cvGetCaptureProperty(self.src, hg.CV_CAP_PROP_POS_MSEC)
def __init__(self, src="", time=None):
self.src = src
self.time = time
if self.time:
hg.cvSetCaptureProperty(self.src, hg.CV_CAP_PROP_POS_FRAMES, self.time)
self.iplimage = hg.cvQueryFrame(self.src)
self.width = self.iplimage.width
self.height = self.iplimage.height
self.image = opencv.cvCreateImage(opencv.cvGetSize(self.iplimage), 8, 4)
opencv.cvCvtColor(self.iplimage, self.image, opencv.CV_BGR2BGRA)
self.buffer = numpy.fromstring(self.image.imageData, dtype=numpy.uint32).astype(numpy.uint32)
self.buffer.shape = (self.image.width, self.image.height)
self.time = hg.cvGetCaptureProperty(self.src, hg.CV_CAP_PROP_POS_MSEC)
def test_segmentation():
rospy.wait_for_service("segment_pointcloud")
try:
pts3d, intensities, labels, image, image_angle, polygon = get_test_data()
ROS_pointcloud = convert_pointcloud_to_ROS(pts3d, intensities, labels)
ROS_image = convert_cvimage_to_ROS(image)
imageSize = cv.cvGetSize(image)
ROS_polygon = convert_polygon_to_ROS(polygon)
segment_pointcloud = rospy.ServiceProxy("segment_pointcloud", Segmentation)
request = SegmentationRequest()
request.imageWidth = 41
request.pointcloud = ROS_pointcloud
request.image = ROS_image
request.imageWidth = imageSize.width
request.imageHeight = imageSize.height
request.imageAngle = image_angle
request.regionOfInterest2D = ROS_polygon
request.laserHeightAboveGround = 1.32
request.numberOfPointsToClassify = 1000 # -1 == all
response = segment_pointcloud(request)
pts3d_bound, intensities, labels = convert_ROS_pointcloud_to_pointcloud(response.pointcloud)
cfg = configuration.configuration("../data/ROS_test_client/", "dummyScanner")
pc = processor.processor(cfg)
pc.scan_dataset = scan_dataset()
pc.scan_dataset.image_artag_filename = ""
pc.scan_dataset.table_plane_translation = np.matrix([0, 0, 0]).T
pc.scan_dataset.ground_plane_translation = np.matrix([0, 0, request.laserHeightAboveGround]).T
pc.scan_dataset.ground_plane_rotation = ""
pc.scan_dataset.is_labeled = True
pc.scan_dataset.id = "ROStest"
pc.image_angle = ""
pc.pts3d_bound = pts3d_bound
pc.map_polys = labels
pc.scan_dataset.ground_plane_normal = np.matrix([0.0, 0.0, 1.0]).T
from enthought.mayavi import mlab
pc.display_3d("labels")
mlab.show()
return response
except rospy.ServiceException, e:
print "Service call failed: %s" % e
def detectObject(self, classifier):
self.grayscale = opencv.cvCreateImage(opencv.cvGetSize(self.iplimage), 8, 1)
opencv.cvCvtColor(self.iplimage, self.grayscale, opencv.CV_BGR2GRAY)
self.storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(self.storage)
opencv.cvEqualizeHist(self.grayscale, self.grayscale)
try:
self.cascade = opencv.cvLoadHaarClassifierCascade(os.path.join(os.path.dirname(__file__), classifier+".xml"),opencv.cvSize(1, 1))
except:
raise AttributeError("could not load classifier file")
self.objects = opencv.cvHaarDetectObjects(self.grayscale, self.cascade, self.storage, 1.2, 2, opencv.CV_HAAR_DO_CANNY_PRUNING, opencv.cvSize(50, 50))
return self.objects
def detectObject(self, classifier):
self.grayscale = opencv.cvCreateImage(opencv.cvGetSize(self.iplimage), 8, 1)
opencv.cvCvtColor(self.iplimage, self.grayscale, opencv.CV_BGR2GRAY)
self.storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(self.storage)
opencv.cvEqualizeHist(self.grayscale, self.grayscale)
try:
self.cascade = opencv.cvLoadHaarClassifierCascade(os.path.join(os.path.dirname(__file__), classifier+".xml"),opencv.cvSize(1,1))
except:
raise AttributeError, "could not load classifier file"
self.objects = opencv.cvHaarDetectObjects(self.grayscale, self.cascade, self.storage, 1.2, 2, opencv.CV_HAAR_DO_CANNY_PRUNING, opencv.cvSize(50,50))
return self.objects
def detectHaar(iplimage, classifier):
srcimage = opencv.cvCloneImage(iplimage)
grayscale = opencv.cvCreateImage(opencv.cvGetSize(srcimage), 8, 1)
opencv.cvCvtColor(srcimage, grayscale, opencv.CV_BGR2GRAY)
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
opencv.cvEqualizeHist(grayscale, grayscale)
try:
cascade = opencv.cvLoadHaarClassifierCascade(os.path.join(os.path.dirname(__file__), classifier+".xml"),opencv.cvSize(1,1))
except:
raise AttributeError, "could not load classifier file"
objs = opencv.cvHaarDetectObjects(grayscale, cascade, storage, 1.2, 2, opencv.CV_HAAR_DO_CANNY_PRUNING, opencv.cvSize(50,50))
objects = []
for obj in objs:
objects.append(Haarobj(obj))
opencv.cvReleaseImage(srcimage)
opencv.cvReleaseImage(grayscale)
opencv.cvReleaseMemStorage(storage)
return objects
def detectHaar(iplimage, classifier):
srcimage = opencv.cvCloneImage(iplimage)
grayscale = opencv.cvCreateImage(opencv.cvGetSize(srcimage), 8, 1)
opencv.cvCvtColor(srcimage, grayscale, opencv.CV_BGR2GRAY)
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
opencv.cvEqualizeHist(grayscale, grayscale)
try:
cascade = opencv.cvLoadHaarClassifierCascade(os.path.join(os.path.dirname(__file__), classifier + ".xml"), opencv.cvSize(1, 1))
except:
raise AttributeError("could not load classifier file")
objs = opencv.cvHaarDetectObjects(grayscale, cascade, storage, 1.2, 2, opencv.CV_HAAR_DO_CANNY_PRUNING, opencv.cvSize(50, 50))
objects = []
for obj in objs:
objects.append(Haarobj(obj))
opencv.cvReleaseImage(srcimage)
opencv.cvReleaseImage(grayscale)
opencv.cvReleaseMemStorage(storage)
return objects
def detect(self, pil_image, cascade_name, recogn_w = 50, recogn_h = 50):
# Get cascade:
cascade = self.get_cascade(cascade_name)
image = opencv.PIL2Ipl(pil_image)
image_size = opencv.cvGetSize(image)
grayscale = image
if pil_image.mode == "RGB":
# create grayscale version
grayscale = opencv.cvCreateImage(image_size, 8, 1)
# Change to RGB2Gray - I dont think itll affect the conversion
opencv.cvCvtColor(image, grayscale, opencv.CV_BGR2GRAY)
# create storage
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
# equalize histogram
opencv.cvEqualizeHist(grayscale, grayscale)
# detect objects
return opencv.cvHaarDetectObjects(grayscale, cascade, storage, 1.2, 2, opencv.CV_HAAR_DO_CANNY_PRUNING, opencv.cvSize(recogn_w, recogn_h))
def detect(self, pil_image, cascade_name, recogn_w=50, recogn_h=50):
# Get cascade:
cascade = self.get_cascade(cascade_name)
image = opencv.PIL2Ipl(pil_image)
image_size = opencv.cvGetSize(image)
grayscale = image
if pil_image.mode == "RGB":
# create grayscale version
grayscale = opencv.cvCreateImage(image_size, 8, 1)
# Change to RGB2Gray - I dont think itll affect the conversion
opencv.cvCvtColor(image, grayscale, opencv.CV_BGR2GRAY)
# create storage
storage = opencv.cvCreateMemStorage(0)
opencv.cvClearMemStorage(storage)
# equalize histogram
opencv.cvEqualizeHist(grayscale, grayscale)
# detect objects
return opencv.cvHaarDetectObjects(grayscale, cascade, storage, 1.2, 2,
opencv.CV_HAAR_DO_CANNY_PRUNING,
opencv.cvSize(recogn_w, recogn_h))
import sys; sys.exit()
pc.img = cv.cvCloneImage(np.array(np_img) ) #only works in CV 2.0, but not cv 2.1
pc.laserscans = []
pc.scan_indices = np.array( range(N) )
pc.camPts = camPts
pc.camPts_bound = camPts[:,idx_list]
pc.pts3d_bound = pc.pts3d[:,idx_list]
pc.scan_indices_bound = np.array(range(N))[idx_list]
pc.intensities_bound = pc.intensities[idx_list]
pc.idx_list = idx_list
###pc.map = (pc.camPts_bound, pc.camPts, pc.idx_list, pc.pts3d_bound,pc.scan_indices_bound, pc.intensities_bound)
#create dummy surface polygon to define ROI
# [Below] These polygons will be used to generate a 'mask' cv image and used to
# limit the area of image where 3D projected points are considered.
image_size = cv.cvGetSize(pc.img)
w = image_size.width
h = image_size.height
crop_region = (0.3,0.3,0.3,0.3) # % to crop left, crop right, crop top, crop bot
surface_ROI, list_of_edges = define_ROI_polygons(w, h, crop_region)
pc.scan_dataset.polygons.append(surface_ROI)
for p in list_of_edges: pc.scan_dataset.polygons.append(p)
''' [Below] Does 'map_laser_into_cam2D' to get camPts, and bounds on all values
Optionally applies translate and rotate relative to a groundplane (if defined)
'''
if not cfg.device=='PR2':
pc.do_all_point_cloud()
else:
pc.do_all_point_cloud(map_already_exists=True)
def prepare(self, features_k_nearest_neighbors, nonzero_indices = None, all_save_load = False, regenerate_neightborhood_indices = False):
#print np.shape(self.processor.pts3d_bound), 'shape pts3d_bound'
imgTmp = cv.cvCloneImage(self.processor.img)
self.imNP = ut.cv2np(imgTmp,format='BGR')
###self.processor.map2d = np.asarray(self.processor.camPts_bound) #copied from laser to image mapping
if features_k_nearest_neighbors == None or features_k_nearest_neighbors == False: #use range
self.kdtree2d = kdtree.KDTree(self.processor.pts3d_bound.T)
#print len(nonzero_indices)
#print np.shape(np.asarray((self.processor.pts3d_bound.T)[nonzero_indices]))
if nonzero_indices != None:
print ut.getTime(), 'query ball tree for ', len(nonzero_indices), 'points'
kdtree_query = kdtree.KDTree((self.processor.pts3d_bound.T)[nonzero_indices])
else:
print ut.getTime(), 'query ball tree'
kdtree_query = kdtree.KDTree(self.processor.pts3d_bound.T)
filename = self.processor.config.path+'/data/'+self.processor.scan_dataset.id+'_sphere_neighborhood_indices_'+str(self.processor.feature_radius)+'.pkl'
if all_save_load == True and os.path.exists(filename) and regenerate_neightborhood_indices == False:
#if its already there, load it:
print ut.getTime(), 'loading',filename
self.kdtree_queried_indices = ut.load_pickle(filename)
else:
self.kdtree_queried_indices = kdtree_query.query_ball_tree(self.kdtree2d, self.processor.feature_radius, 2.0, 0.2) #approximate
print ut.getTime(), 'queried kdtree: ',len(self.kdtree_queried_indices),'points, radius:',self.processor.feature_radius
if all_save_load == True:
ut.save_pickle(self.kdtree_queried_indices, filename)
#make dict out of list for faster operations? (doesn't seem to change speed significantly):
#self.kdtree_queried_indices = dict(zip(xrange(len(self.kdtree_queried_indices)), self.kdtree_queried_indices))
else: #experiemental: use_20_nearest_neighbors == True
#TODO: exclude invalid values in get_featurevector (uncomment code there)
self.kdtree2d = kdtree.KDTree(self.processor.pts3d_bound.T)
self.kdtree_queried_indices = []
print ut.getTime(), 'kdtree single queries for kNN start, k=', features_k_nearest_neighbors
count = 0
for point in ((self.processor.pts3d_bound.T)[nonzero_indices]):
count = count + 1
result = self.kdtree2d.query(point, features_k_nearest_neighbors,0.2,2,self.processor.feature_radius)
#existing = result[0][0] != np.Inf
#print existing
#print result[1]
self.kdtree_queried_indices += [result[1]] #[existing]
if count % 4096 == 0:
print ut.getTime(),count
print ut.getTime(), 'kdtree singe queries end'
#convert to numpy array -> faster access
self.kdtree_queried_indices = np.asarray(self.kdtree_queried_indices)
#print self.kdtree_queried_indices
#takes long to compute:
#avg_len = 0
#minlen = 999999
#maxlen = 0
#for x in self.kdtree_queried_indices:
# avg_len += len(x)
# minlen = min(minlen, len(x))
# maxlen = max(maxlen, len(x))
#avg_len = avg_len / len(self.kdtree_queried_indices)
#print ut.getTime(), "range neighbors: avg_len", avg_len, 'minlen', minlen, 'maxlen', maxlen
#create HSV numpy images:
# compute the hsv version of the image
image_size = cv.cvGetSize(self.processor.img)
img_h = cv.cvCreateImage (image_size, 8, 1)
img_s = cv.cvCreateImage (image_size, 8, 1)
img_v = cv.cvCreateImage (image_size, 8, 1)
img_hsv = cv.cvCreateImage (image_size, 8, 3)
cv.cvCvtColor (self.processor.img, img_hsv, cv.CV_BGR2HSV)
cv.cvSplit (img_hsv, img_h, img_s, img_v, None)
self.imNP_h = ut.cv2np(img_h)
self.imNP_s = ut.cv2np(img_s)
self.imNP_v = ut.cv2np(img_v)
textures = texture_features.eigen_texture(self.processor.img)
self.imNP_tex1 = textures[:,:,0]
self.imNP_tex2 = textures[:,:,1]
self.debug_before_first_featurevector = True
self.generate_voi_histogram(self.processor.point_of_interest,self.processor.voi_width)
def undistort_img(self, image):
if self.temp is None:
self.temp = cv.cvCreateImage(cv.cvGetSize(image), 8, 3)
#cv.cvUndistort2(image, self.temp, self.intrinsic_mat_cv, self.lens_distortion_radial_cv)
cv.cvRemap(image, self.temp, self.mapx, self.mapy)
return self.temp
def prepare(self,
features_k_nearest_neighbors,
nonzero_indices=None,
all_save_load=False,
regenerate_neightborhood_indices=False):
#print np.shape(self.processor.pts3d_bound), 'shape pts3d_bound'
imgTmp = cv.cvCloneImage(self.processor.img)
self.imNP = ut.cv2np(imgTmp, format='BGR')
###self.processor.map2d = np.asarray(self.processor.camPts_bound) #copied from laser to image mapping
if features_k_nearest_neighbors == None or features_k_nearest_neighbors == False: #use range
self.kdtree2d = kdtree.KDTree(self.processor.pts3d_bound.T)
#print len(nonzero_indices)
#print np.shape(np.asarray((self.processor.pts3d_bound.T)[nonzero_indices]))
if nonzero_indices != None:
print ut.getTime(), 'query ball tree for ', len(
nonzero_indices), 'points'
kdtree_query = kdtree.KDTree(
(self.processor.pts3d_bound.T)[nonzero_indices])
else:
print ut.getTime(), 'query ball tree'
kdtree_query = kdtree.KDTree(self.processor.pts3d_bound.T)
filename = self.processor.config.path + '/data/' + self.processor.scan_dataset.id + '_sphere_neighborhood_indices_' + str(
self.processor.feature_radius) + '.pkl'
if all_save_load == True and os.path.exists(
filename) and regenerate_neightborhood_indices == False:
#if its already there, load it:
print ut.getTime(), 'loading', filename
self.kdtree_queried_indices = ut.load_pickle(filename)
else:
self.kdtree_queried_indices = kdtree_query.query_ball_tree(
self.kdtree2d, self.processor.feature_radius, 2.0,
0.2) #approximate
print ut.getTime(), 'queried kdtree: ', len(
self.kdtree_queried_indices
), 'points, radius:', self.processor.feature_radius
if all_save_load == True:
ut.save_pickle(self.kdtree_queried_indices, filename)
#make dict out of list for faster operations? (doesn't seem to change speed significantly):
#self.kdtree_queried_indices = dict(zip(xrange(len(self.kdtree_queried_indices)), self.kdtree_queried_indices))
else: #experiemental: use_20_nearest_neighbors == True
#TODO: exclude invalid values in get_featurevector (uncomment code there)
self.kdtree2d = kdtree.KDTree(self.processor.pts3d_bound.T)
self.kdtree_queried_indices = []
print ut.getTime(
), 'kdtree single queries for kNN start, k=', features_k_nearest_neighbors
count = 0
for point in ((self.processor.pts3d_bound.T)[nonzero_indices]):
count = count + 1
result = self.kdtree2d.query(point,
features_k_nearest_neighbors, 0.2,
2, self.processor.feature_radius)
#existing = result[0][0] != np.Inf
#print existing
#print result[1]
self.kdtree_queried_indices += [result[1]] #[existing]
if count % 4096 == 0:
print ut.getTime(), count
print ut.getTime(), 'kdtree singe queries end'
#convert to numpy array -> faster access
self.kdtree_queried_indices = np.asarray(
self.kdtree_queried_indices)
#print self.kdtree_queried_indices
#takes long to compute:
#avg_len = 0
#minlen = 999999
#maxlen = 0
#for x in self.kdtree_queried_indices:
# avg_len += len(x)
# minlen = min(minlen, len(x))
# maxlen = max(maxlen, len(x))
#avg_len = avg_len / len(self.kdtree_queried_indices)
#print ut.getTime(), "range neighbors: avg_len", avg_len, 'minlen', minlen, 'maxlen', maxlen
#create HSV numpy images:
# compute the hsv version of the image
image_size = cv.cvGetSize(self.processor.img)
img_h = cv.cvCreateImage(image_size, 8, 1)
img_s = cv.cvCreateImage(image_size, 8, 1)
img_v = cv.cvCreateImage(image_size, 8, 1)
img_hsv = cv.cvCreateImage(image_size, 8, 3)
cv.cvCvtColor(self.processor.img, img_hsv, cv.CV_BGR2HSV)
cv.cvSplit(img_hsv, img_h, img_s, img_v, None)
self.imNP_h = ut.cv2np(img_h)
self.imNP_s = ut.cv2np(img_s)
self.imNP_v = ut.cv2np(img_v)
textures = texture_features.eigen_texture(self.processor.img)
self.imNP_tex1 = textures[:, :, 0]
self.imNP_tex2 = textures[:, :, 1]
self.debug_before_first_featurevector = True
self.generate_voi_histogram(self.processor.point_of_interest,
self.processor.voi_width)
#return to drawing routines
ballax = ballax * FRICTION
ballay = ballay * FRICTION
odeBBall.setLinearVel((ballax, zvel, ballay))
if distance((ballx, bally), (holex, holey)) < 0.25 and abs(ballax)<5 and abs(ballay)<5:
resetGame()
switchMode(MODE_DETECT_OBSTACLES)
return
if abs(ballax)<0.01 and abs(ballay)<0.01:
switchMode(MODE_READY)
im = queryWebcam()
igray = opencv.cvCreateImage(opencv.cvGetSize(im), 8, 1)
iwhite = opencv.cvCreateImage(opencv.cvGetSize(im), 8, 1)
stor = opencv.cvCreateMemStorage(0)
lastframe = time.time()
font = pygame.font.Font(None, 20)
while 1:
for event in pygame.event.get():
if event.type == pygame.QUIT: exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if mode == MODE_DETECT_UNITSQUARE:
setIsoRect(event)
else:
exit()
if event.type == pygame.KEYDOWN: keyPress(event)
#screen.fill(black)
def undistort_img(self, image):
if self.temp is None:
self.temp = cv.cvCreateImage(cv.cvGetSize(image), 8, 3)
#cv.cvUndistort2(image, self.temp, self.intrinsic_mat_cv, self.lens_distortion_radial_cv)
cv.cvRemap(image, self.temp, self.mapx, self.mapy)
return self.temp
def size(self): return opencv.cvGetSize(self.image)
