def display_tracking(img_size, img1, img2, img_flow, homography):
for x in range(0, img_size[0], 100):
for y in range(0, img_size[1], 100):
cv.Circle(img1, (x, y), 3, (0, 255, 0, 0), -1, 8, 0)
point = cv.CreateMat(3, 1, cv.CV_64F)
point[0, 0] = x
point[1, 0] = y
point[2, 0] = 1
newpoint = cv.CreateMat(3, 1, cv.CV_64F)
cv.MatMul(homography, point, newpoint)
cv.Circle(img2, (int(newpoint[0, 0]), int(newpoint[1, 0])), 3,
(0, 255, 0, 0), -1, 8, 0)
cv.Line(img_flow, (x, y),
(int(newpoint[0, 0]), int(newpoint[1, 0])),
cv.CV_RGB(255, 0, 0), 2)
cv.Rectangle(img_flow, (0, 0), (150, 25), cv.CV_RGB(0, 0, 0), thickness=-1)
cv.PutText(
img_flow, "Good?: " + str(isHomographyGood(homography)), (0, 20),
cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.75, 0.75, thickness=2),
cv.CV_RGB(255, 255, 255))
cv.NamedWindow("Image1", 0)
cv.NamedWindow("Image2", 0)
cv.NamedWindow("Flow", 0)
cv.ResizeWindow("Image1", int(0.5 * img_size[0]), int(0.5 * img_size[1]))
cv.ResizeWindow("Image2", int(0.5 * img_size[0]), int(0.5 * img_size[1]))
cv.ResizeWindow("Flow", int(0.5 * img_size[0]), int(0.5 * img_size[1]))
cv.ShowImage("Image1", img1)
cv.ShowImage("Image2", img2)
cv.ShowImage("Flow", img_flow)
cv.WaitKey(0)
def process(self, gui):
"""Process file, find corners on chessboard and keep points
"""
gui.setMessage("Analyzing movie... get frame count")
#open capture file
capture = cv.CaptureFromFile(self.filename)
frame = cv.QueryFrame(capture)
#count... I know it sucks
numframes=1
while frame:
frame = cv.QueryFrame(capture)
numframes +=1
step = int(numframes/Calibration.NUMPOINT)
capture = cv.CaptureFromFile(self.filename)
frame = cv.QueryFrame(capture) #grab a frame to get some information
self.framesize = (frame.width, frame.height)
gray = cv.CreateImage((frame.width,frame.height), 8, 1)
points = []
nframe = 0
f=0
cv.NamedWindow("ChessBoard",cv.CV_WINDOW_NORMAL)
gui.setMessage("Analyzing movie... find chessCorner for %d frames" % Calibration.NUMPOINT)
while frame:
f+=1
#find corners
state,found = cv.FindChessboardCorners(frame, self.chessSize, flags=cv.CV_CALIB_CB_FILTER_QUADS)
if state==1:
#affine search
cv.CvtColor( frame, gray, cv.CV_BGR2GRAY )
found = cv.FindCornerSubPix(gray, found, (11,11), (-1,-1), (cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 30, 0.1))
#draw corners on image
cv.DrawChessboardCorners(frame, self.chessSize, found, state)
#compute points
for x,y in found:
points.append((x,y))
nframe+=1
cv.ResizeWindow("ChessBoard",640,480)
cv.ShowImage("ChessBoard",frame)
cv.WaitKey(4)
frame = cv.QueryFrame(capture) #grab a frame to get some information
#skip frames to get only NUMPOINT of point to calculate
while f%step != 0 and frame:
f+=1
frame = cv.QueryFrame(capture)
self.points = points
self.nframe = nframe
gui.setMessage("Analyze end, %d points found" % len(self.points))
def show_rotated():
g = main.grid.occ
#g = blockcraft.centered_rotated(main.R_correct, g)
g = blockcraft.translated_rotated(main.R_correct, g)
marginal = g.sum(1).astype('u1') * 255
cv.NamedWindow('scale_test', 0)
cv.ShowImage('scale_test', cv.fromarray(marginal))
cv.ResizeWindow('scale_test', 300, 300)
def __init__(self, node_name):
rospy.init_node(node_name)
rospy.on_shutdown(self.cleanup)
self.node_name = node_name
self.input_rgb_image = "input_rgb_image"
self.input_depth_image = "input_depth_image"
self.output_image = "output_image"
self.show_text = rospy.get_param("~show_text", True)
self.show_features = rospy.get_param("~show_features", True)
""" Initialize the Region of Interest and its publisher """
#self.ROI = RegionOfInterest()
#self.pubROI = rospy.Publisher("/roi", RegionOfInterest)
""" Do the same for the point cluster publisher """
#self.cluster3d = PointStamped()
#self.pub_cluster3d = rospy.Publisher("/target_point", PointStamped)
""" Initialize a number of global variables """
self.image = None
self.image_size = None
self.depth_image = None
self.grey = None
self.selected_point = None
self.selection = None
self.drag_start = None
self.keystroke = None
self.key_command = None
self.detect_box = None
self.track_box = None
self.display_box = None
self.keep_marker_history = False
self.night_mode = False
self.auto_face_tracking = True
self.cps = 0 # Cycles per second = number of processing loops per second.
self.cps_values = list()
self.cps_n_values = 20
self.flip_image = False
""" Create the display window """
self.cv_window_name = self.node_name
cv.NamedWindow(self.cv_window_name, cv.CV_NORMAL)
cv.ResizeWindow(self.cv_window_name, 640, 480)
""" Create the cv_bridge object """
self.bridge = CvBridge()
""" Set a call back on mouse clicks on the image window """
cv.SetMouseCallback(self.node_name, self.on_mouse_click, None)
""" A publisher to output the display image back to a ROS topic """
self.output_image_pub = rospy.Publisher(self.output_image, Image)
""" Subscribe to the raw camera image topic and set the image processing callback """
self.image_sub = rospy.Subscriber(self.input_rgb_image,
Image,
self.image_callback,
queue_size=1)
self.depth_sub = rospy.Subscriber(self.input_depth_image,
Image,
self.depth_callback,
queue_size=1)
rospy.loginfo("Starting " + self.node_name)
def FPV_thread():
global camera_index
global capture
global WINDOW_NAME
global latest_frame
global FPV_thread_stop
global overlay_message # shared with application return results
global face_position # shared with application return results
FPV_init()
cv.NamedWindow(WINDOW_NAME, cv.CV_WINDOW_NORMAL)
cv.MoveWindow(WINDOW_NAME, 0, 0)
width_scale = 1.0
height_scale = 1.0
while True:
frame = cv.QueryFrame(capture)
cv.Flip(frame, None, 1)
#copy to buffer
frame_lock.acquire()
original_imagesize = (0,0)
resized_imagesize = (0,0)
if not latest_frame:
latest_frame = cv.CreateImage((640, 480), frame.depth, frame.nChannels)
original_imagesize = cv.GetSize(frame)
resized_imagesize = cv.GetSize(latest_frame)
width_scale = original_imagesize[0]*1.0/resized_imagesize[0]
height_scale = original_imagesize[1]*1.0/resized_imagesize[1]
cv.Resize(frame, latest_frame)
frame_lock.release()
#Display Result
text_start_point = (10, 50)
cv.PutText(frame, overlay_message, text_start_point, font, cv.Scalar(255,255,255))
cv.Rectangle(frame, text_start_point, (original_imagesize[0], 100), cv.Scalar(0,0,0), thickness=cv.CV_FILLED)
if face_position[0] > 0.0:
point1 = (int(face_position[0]*width_scale), int(face_position[1]*height_scale))
point2 = (int((face_position[0] + face_position[2])*width_scale), \
int((face_position[1]+face_position[3])*height_scale))
cv.Rectangle(frame, point1, point2, \
cv.Scalar(255, 255, 255), thickness=2)
cv.ShowImage(WINDOW_NAME, frame)
cv.ResizeWindow(WINDOW_NAME, 200, 100)
cv.NamedWindow(WINDOW_NAME, cv.CV_WINDOW_NORMAL);
cv.SetWindowProperty(WINDOW_NAME, 0, cv.CV_WINDOW_FULLSCREEN);
c = cv.WaitKey(10)
if c == ord('q'):
break
print "[INFO] FPV Thread is finished"
FPV_thread_stop = True
FPV_close()
def scan_receipt(file_name):
image = cv.LoadImage(RECEIPT_PATH + file_name)
if not image:
print "Error opening image"
sys.exit(1)
cv.NamedWindow('output', cv.CV_WINDOW_NORMAL)
cv.ShowImage('output', image)
cv.ResizeWindow('output', 960, 640)
cv.WaitKey()
image2 = cv2.imread(RECEIPT_PATH + file_name)
corners = detect_corners(image2)
def disparity(file1, file2):
sc = cv.CreateStereoBMState(preset=cv.CV_STEREO_BM_BASIC,
numberOfDisparities=0)
#sc2 = cv.CreateStereoGCState(16, 2)
img1 = cv.LoadImage(file1, cv.CV_LOAD_IMAGE_GRAYSCALE)
img2 = cv.LoadImage(file2, cv.CV_LOAD_IMAGE_GRAYSCALE)
img_sz = cv.GetSize(img1)
img_out = cv.CreateImage(img_sz, cv.IPL_DEPTH_32F, 1)
img_out2 = cv.CreateImage(img_sz, cv.IPL_DEPTH_32F, 1)
img_out3 = cv.CreateImage(img_sz, cv.IPL_DEPTH_32F, 1)
cv.FindStereoCorrespondenceBM(img1, img2, img_out, sc)
#cv.FindStereoCorrespondenceGC(img1, img2, img_out2, img_out3, sc2)
cv.NamedWindow("Image1", 0)
cv.NamedWindow("Image2", 0)
cv.NamedWindow("Disparity", 0)
cv.ResizeWindow("Image1", int(0.5 * img_sz[0]), int(0.5 * img_sz[1]))
cv.ResizeWindow("Image2", int(0.5 * img_sz[0]), int(0.5 * img_sz[1]))
cv.ResizeWindow("Disparity", int(0.5 * img_sz[0]), int(0.5 * img_sz[1]))
cv.ShowImage("Image1", img1)
cv.ShowImage("Image2", img2)
cv.ShowImage("Disparity", img_out)
cv.WaitKey(0)
def undistort(self, gui, cam, dist):
"""Undistort file
"""
gui.setMessage("Undistort movie... get frame count")
#open capture file
capture = cv.CaptureFromFile(self.filename)
frame = cv.QueryFrame(capture)
#count... I know it sucks
numframes=1
while frame:
frame = cv.QueryFrame(capture)
numframes +=1
capture = cv.CaptureFromFile(self.filename)
frame = cv.QueryFrame(capture) #grab a frame to get some information
self.framesize = (frame.width, frame.height)
gray = cv.CreateImage((frame.width,frame.height), 8, 1)
undistorted_frame = cv.CreateImage((frame.width,frame.height), 8, 3)
cv.NamedWindow("Uncalibrated image",cv.CV_WINDOW_NORMAL)
cv.NamedWindow("Calibrated image",cv.CV_WINDOW_NORMAL)
while frame:
cv.Undistort2(frame, undistorted_frame, cam, dist)
cv.ResizeWindow("Uncalibrated image",640,480)
cv.ResizeWindow("Calibrated image",640,480)
cv.ShowImage("Calibrated image",undistorted_frame)
cv.ShowImage("Uncalibrated image",frame)
cv.WaitKey(0)
frame = cv.QueryFrame(capture) #grab a frame to get some information
self.points = points
self.nframe = nframe
gui.setMessage("Analyze end, %d points found" % len(self.points))
def __init__(self, cModel):
self.model = cModel
windowName = "Fisheye"
cv.NamedWindow(windowName,cv.CV_WINDOW_NORMAL)
cv.NamedWindow('Image')
cv.MoveWindow('Image',1,220)
x,y = self.model.res
cv.CreateTrackbar ("Threshold", windowName, 1, 100,
self.onThresholdChange)
cv.CreateTrackbar ("Horizon", windowName, 10,
min(self.model.res)/2, self.onRadiusChange)
cv.CreateTrackbar ("North", windowName, 90, 360, self.onNorthChange)
cv.CreateTrackbar ('x', windowName, x/2, x, self.on_Xchange)
cv.CreateTrackbar ('y', windowName, y/2, y, self.on_Ychange)
cv.ResizeWindow(windowName, 1200,200)
self.onThresholdChange (0)
def __init__(self, name, x=None, y=None, w=None, h=None):
""" Create OpenCV Window.
- Auto-resize if now size is given.
- Auto-position to 0x0 if no pos given
"""
if w is not None and h is not None:
cv.NamedWindow(name, 0)
cv.ResizeWindow(name, w, h)
else:
cv.NamedWindow(name, cv.CV_WINDOW_AUTOSIZE)
if x is not None and y is not None:
cv.MoveWindow(name, x, y)
self.name = name
self.settings = {}
def nextFrame(self):
frame = self.video.fetch(self.channel)
mode = self.video.outputMode(self.channel)
if frame == None: return False
frame = (frame * 255.0).astype(numpy.uint8)
if mode == MODE_RGB:
out = array2cv(frame[:, :, ::-1])
elif mode == MODE_FLOAT:
out = array2cv(frame)
else:
raise Exception('Unsuported mode for WriteCV')
cv.ResizeWindow(self.title, frame.shape[1], frame.shape[0])
cv.ShowImage(self.title, out)
return True
def show_faces(self, mytime=1000):
"""
Show all faces that have been found for the guys.
The time for which each image will be displayed can be chosen.
:param mytime: time for which the image should be displayed (in ms) (1000)
:type mytime: int
"""
win_name = " Face Results"
cv.NamedWindow(win_name, cv.CV_WINDOW_NORMAL)
cv.ResizeWindow(win_name, 640, 480)
for a_guy in self.guys:
if self.run:
out_im = self.prepare_image(a_guy)
cv.ShowImage(win_name, out_im)
cv.WaitKey(mytime)
cv.DestroyWindow(win_name)
def analyze_webcam(width, height):
print("""
' ' : extract colors of detected face
'b' : toggle onlyBlackCubes
'd' : toggle dodetection
'm' : shift right
'n' : shift left
'r' : reset everything
'q' : print hsvs
'p' : resolve colors
'u' : toggle didassignments
's' : save image
""")
# 0 for laptop camera
# 1 for usb camera
capture = cv.CreateCameraCapture(0)
# Set the capture resolution
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, width)
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT, height)
# Create the window and set the size to match the capture resolution
cv.NamedWindow("Fig", cv.CV_WINDOW_NORMAL)
cv.ResizeWindow("Fig", width, height)
frame = cv.QueryFrame(capture)
rf = RubiksFinder(width, height)
while True:
frame = cv.QueryFrame(capture)
if not frame:
cv.WaitKey(0)
break
rf.analyze_frame(frame)
if not rf.process_keyboard_input():
break
cv.DestroyWindow("Fig")
def detect(self):
"""
project images, take and process pictures to get projector pixel to
camera pixel mappings.
"""
cv.NamedWindow(windowtitle, cv.CV_WINDOW_NORMAL)
cv.ResizeWindow(windowtitle, self.screenSize[0], self.screenSize[1])
cv.SetWindowProperty(windowtitle, 0, cv.CV_WINDOW_FULLSCREEN)
cv2.imshow(windowtitle, self.projector_image)
cv2.waitKey(500)
self.dark_baseline = self.takeSnapshot()
# light up only everything that's within the current projector's
# part of the projected image.
self.projector_image[:] = 0
self.viewport[:] = .3
cv2.imshow(windowtitle, self.projector_image)
cv2.waitKey(500)
allpixels = self.takeSnapshot()
self.bright_baseline = allpixels - self.dark_baseline
cv2.imwrite('/tmp/allpixels.png', allpixels)
self.mask = self.bright_baseline > 30
cv2.imwrite('/tmp/mask.png', self.mask * 250.)
self.projector_image[:] = 0
if self.mask.any():
for step, im in enumerate(self.imageIterator.generator()):
self.viewport[:] = im
cv2.imshow(windowtitle, self.projector_image)
cv2.waitKey(500)
image = self.takeSnapshot()
self.handleImage(step, image)
self.postProcess()
else:
logger.info(
"No visible pixels. Skipping detection for this camera pose and projector."
)
def out_display(self, im, name, time=1000, im_x=640, im_y=480):
"""
Displays the output image, for time ms.
Setting time to 0 causes the image to remains open.
Window name slightly changed to match output
:param im: the image to be saved, formatted as an OpenCV Image
:type im: IplImage
:param name: the name of the image to be saved
:type name: string
:param time: time for which the image should be displayed (in ms) (1000)
:type time: int
:param im_x: output size of the displayed image (in pixels) (640)
:type im_x: int
:param im_y: output size of the displayed image (in pixels) (480)
:type im_y: int
"""
win_name = name + " - out"
cv.NamedWindow(win_name, cv.CV_WINDOW_NORMAL)
cv.ResizeWindow(win_name, im_x, im_y)
cv.ShowImage(win_name, im)
cv.WaitKey(time)
cv.DestroyWindow(win_name)
#This is the setup
datalog = open("data.log", "w+")
datalog.write("\n~~~=== Rambler Data Log Opened, " + str(datetime.now()) + " ===~~~\n")
capture = cv.CaptureFromCAM(0)
#capture = cv.CaptureFromFile("../out2.mpg")
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, 320)
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT, 240)
polar = cv.CreateImage((360, 360), 8, 3)
unwrapped = cv.CreateImage((360, 40), 8, 3)
cam = cv.CreateImage((320, 240), 8, 3)
cones = cv.CreateImage((360, 40), 8, 1)
cv.NamedWindow('cam')
cv.ResizeWindow('cam', 320,240)
cv.NamedWindow('unwrapped')
cv.ResizeWindow('unwrapped', 360,40)
cv.NamedWindow('cones')
cv.ResizeWindow('cones', 360,40)
sleep(3)
cam = cv.QueryFrame(capture)
sleep(3)
cam = cv.QueryFrame(capture)
sleep(3)
cv.ShowImage('cam', cam)
##GUI #Enable these lines to allow mouse interaction with the polar transform
##GUI cv.SetMouseCallback('cam', on_mouse)
cv.SetMouseCallback('unwrapped', on_mouse)
def update(self):
"""Updates the window with the rendered image."""
im = self.render()
size = cv.GetSize(im)
cv.ShowImage(self.title, im)
cv.ResizeWindow(self.title, size[0], size[1] + len(self.args) * 35)
def create_and_position_window(name, xpos, ypos):
''' a function to created a named widow (from name),
and place it on the screen at (xpos, ypos) '''
cv.NamedWindow(name, 1)
cv.ResizeWindow(name, cam_width, cam_height) # resize it
cv.MoveWindow(name, xpos, ypos) # move it to (xpos,ypos) on the screen
y = (grid[2][0] + grid[2][1] * 2 + grid[2][2] * 4 + grid[2][3] * 8 +
grid[2][4] * 16 + grid[3][0] * 32 + grid[3][1] * 64 +
grid[3][2] * 128 + grid[3][3] * 256) * (grid[3][4] * -1)
sector = grid[4][0] + grid[4][1] * 2 + grid[4][2] * 4
direction = grid[4][3] + grid[4][4] * 2
print 'X:', x
print 'Y:', y
print 'Sector:', sector
print 'Direction:', direction
#loads image from a file and checks for glyphs in it
if __name__ == "__main__":
if len(sys.argv) != 2:
print "Please supply a file name"
sys.exit()
cv.NamedWindow('Glpyh Recognition', 0)
image = cv.LoadImage("../images/" + sys.argv[1],
cv.CV_LOAD_IMAGE_COLOR) #Load the image
cv.ResizeWindow('source', 600, 800)
grid = glyphRec(image)
cv.ShowImage('Glpyh Recognition', image)
while True:
cv.WaitKey(1)
def findBlobs(img, min_color, max_color, originalwindow, renderedwindow,
location, area, ratio):
blobs = cvblob.Blobs() #creates a dictionary of blobs
size = cv.GetSize(img) #gets size of image
hsv = cv.CreateImage(size, cv.IPL_DEPTH_8U, 3) #New HSV image for alter
thresh = cv.CreateImage(size, cv.IPL_DEPTH_8U,
1) #New Gray Image for later
labelImg = cv.CreateImage(size, cvblob.IPL_DEPTH_LABEL,
1) #New Blob image for later
cv.CvtColor(img, hsv, cv.CV_BGR2HSV) #converts image to hsv image
cv.InRangeS(hsv, min_color, max_color, thresh) #thresholds it
#Corrections to remove false positives
cv.Smooth(thresh, thresh, cv.CV_BLUR)
cv.Dilate(thresh, thresh)
cv.Erode(thresh, thresh)
result = cvblob.Label(thresh, labelImg,
blobs) #extracts blobs from a greyscale image
numblobs = len(
blobs.keys()) #number of blobs based off of length of blobs dictionary
#if there are blobs found
if (numblobs > 0):
avgsize = int(result / numblobs)
print str(numblobs) + " blobs found covering " + str(result) + "px"
#Removes blobs that are smaller than a certain size based off of average size
remv = []
for x in blobs:
if (blobs[x].area < avgsize / ratio):
remv.append(x)
for x in remv:
del blobs[x]
numblobs = len(
blobs.keys()) #gets the number of blobs again after removing some
print str(numblobs) + " blobs remaining"
filtered = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
cvblob.FilterLabels(
labelImg, filtered, blobs
) #Creates a binary image with the blobs formed (imgIn, imgOut, blobs)
#Centroid, area, and circle for all blobs
for blob in blobs:
location.append(cvblob.Centroid(blobs[blob]))
area.append(blobs[blob].area)
cv.Circle(img, (int(cvblob.Centroid(
blobs[blob])[0]), int(cvblob.Centroid(blobs[blob])[1])),
int(math.sqrt(int(blobs[blob].area) / 3.14)) + 25,
cv.Scalar(0, 0, 0))
imgOut = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3)
cv.Zero(imgOut)
cvblob.RenderBlobs(
labelImg, blobs, img, imgOut,
cvblob.CV_BLOB_RENDER_COLOR | cvblob.CV_BLOB_RENDER_CENTROID
| cvblob.CV_BLOB_RENDER_BOUNDING_BOX | cvblob.CV_BLOB_RENDER_ANGLE,
1.0) #Marks up the blobs image to put bounding boxes, etc on it
cv.ResizeWindow("Window", 640, 480)
cv.ResizeWindow("Rendered", 640, 480)
cv.ShowImage("Window", img) #shows the orininalimage
cv.ShowImage("Rendered", imgOut) #shows the blobs image
return blobs #returns the list of blobs
else:
print " ...Zero blobs found. \nRedifine color range for better results" #if no blobs were found print an error message
cv.ResizeWindow("Window", 640, 480)
cv.ResizeWindow("Rendered", 640, 480)
cv.ShowImage("Window", img) #show the original image
saveCount += 1
startCounter = False
nSecond = 1
smileTime=True
# Get user input
keyPressed = GPIO.input(11)
if keyPressed == ord('s'):
print "start counter"
startCounter = True
startTime = datetime.now()
keyPressTime = datetime.now()
elif cv2.waitKey(3) == ord('q'):
print "out"
# Quit the while loop
running = False
cv2.destroyAllWindows()
# Show video stream in a window
height, width = frame.shape[:2]
scaleHeight = 750#int(round(1.3*width))
scaleWidth = 800#int(round(1.3*height))
res = cv2.resize(frame,(scaleWidth, scaleHeight), interpolation = cv2.INTER_CUBIC)
cv2.imshow('video', res)
cv.ResizeWindow('video', scaleWidth, scaleHeight+20)
camObj.release()
numpy.r_[2 * x[0] - x[window_len - 1::-1], x,
2 * x[-1] - x[-1:-window_len:-1]],
mode='same')[window_len:-window_len + 1]
imagePath = sys.argv[1]
image = cv.LoadImage(imagePath)
cv_image = image # I use this as a seperate canvas to draw on.
imageThreshold = cv.CreateImage(
cv.GetSize(image), 8,
1) # The last number represents a binary image. It's the channel-depth.
cv.NamedWindow('Test', 0)
cv.ResizeWindow('Test', 1000, 600)
channelG = cv.CreateImage(
cv.GetSize(image), 8,
1) # Initializes blank image holders for the channel separation.
channelB = cv.CreateImage(cv.GetSize(image), 8, 1)
cv.Split(
image, cv.CreateImage(cv.GetSize(image), 8, 1), channelG, channelB, None
) # Splits the input image into channels (RGB). I only use B and G because the laser is green, not red.
cv.Sub(
channelG, channelB, imageThreshold
) # Subtracts the channels. Since the green laser's pixels are basically have a G value of 255, they stand out. Uncomment the next two lines to see what I mean.
#cv.ShowImage('Test', imageThreshold)
#cv.WaitKey(0)
def display(self):
tmp = clone_image(self.img)
overlay_text_on_image(tmp, "%s - %s" % (self.card_name, self.set_name), self.font)
cv.ShowImage("match", tmp)
cv.ResizeWindow("match", 800, 600)
help='separation distance')
p.add_option('-s',
action='store_true',
dest='headless',
help='headless mode')
opt, args = p.parse_args()
cameras = [
opt.cam + '/left/image_rect_color', opt.cam + '/right/image_rect_color'
]
stereo_listener = rc.ROSStereoListener(cameras)
if not opt.headless:
#cv.NamedWindow('left', 0)
#cv.NamedWindow('right', 0)
cv.NamedWindow('stereo-anaglyph', 0)
cv.ResizeWindow('stereo-anaglyph', 640, 480)
cv.WaitKey(10)
else:
bridge = CvBridge()
image_pub = rospy.Publisher('stereo_anaglyph', Image)
anaglyph_cyan_image_distance_correction = rospy.get_param(
'anaglyph_dist', opt.dist)
left = 1113937 # 65361
right = 1113939 #65363
escape = 1048603 #27
while not rospy.is_shutdown():
l, r = stereo_listener.next()
red_blue = anaglyph(l, r, anaglyph_cyan_image_distance_correction)
if not opt.headless:
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-c', dest='config', default='config.yaml')
args = parser.parse_args()
import yaml
config = yaml.load(open(args.config))
stepsize = config['detection']['stepsize']
screenSize = config['screen']['width'], config['screen']['height']
cameraSize = config['camera']['width'], config['camera']['height']
cam = instarCamera.instarCamera()
blank_image = numpy.zeros((screenSize[1], screenSize[0]),
dtype=numpy.float)
cv.NamedWindow(windowtitle, cv.CV_WINDOW_NORMAL)
cv.ResizeWindow(windowtitle, screenSize[0], screenSize[1])
cv.SetWindowProperty(windowtitle, 0, cv.CV_WINDOW_FULLSCREEN)
cv2.imshow(windowtitle, blank_image)
cv2.waitKey(50)
data = []
for shot in config['detection']['shots']:
cam.rotateTo(shot['angles'])
for projector in shot['projectors']:
projectorConfig = config['projectors'][projector]
projectorSize = projectorConfig['width'], projectorConfig['height']
projectorOffset = projectorConfig['iOffset'], projectorConfig[
'jOffset']
detector = Detector(camera=cam,
screenSize=screenSize,
projectorSize=projectorSize,
def __init__(self, node_name):
rospy.init_node(node_name)
rospy.on_shutdown(self.cleanup)
self.node_name = node_name
self.input_rgb_image = "input_rgb_image"
self.input_depth_image = "input_depth_image"
self.prevDepth = None
self.pubFaceCloud = rospy.Publisher('gaze_cloud', PointCloud2)
""" Initialize a number of global variables """
self.image = None
self.image_size = None
self.depth_image = None
self.grey = None
self.small_image = None
self.prev = None
self.prev_img = None
self.show_text = True
self.prevFrameNum = 1
self.mask = None
""" Create the display window """
self.cv_window_name = self.node_name
cv.NamedWindow(self.cv_window_name, cv.CV_NORMAL)
cv.ResizeWindow(self.cv_window_name, 640, 480)
cv.NamedWindow('face box')
""" Create the cv_bridge object """
self.bridge = CvBridge()
""" Set a call back on mouse clicks on the image window """
cv.SetMouseCallback(self.node_name, self.on_mouse_click, None)
""" Subscribe to the raw camera image topic and set the image processing callback """
self.image_sub = rospy.Subscriber(self.input_rgb_image, Image,
self.image_callback)
self.depth_sub = rospy.Subscriber(self.input_depth_image, Image,
self.depth_callback)
#rospy.Subscriber("/camera/depth/image", Image, callback,
# queue_size=1, callback_args=(pubFaceCloud,pubFaceNormals))
#rospy.Subscriber("/roi", RegionOfInterest, callback,
# queue_size=1, callback_args=(pubFaceCloud,pubFaceNormals))
""" Set up the face detection parameters """
self.cascade_frontal_alt = rospy.get_param("~cascade_frontal_alt", "")
self.cascade_frontal_alt2 = rospy.get_param("~cascade_frontal_alt2",
"")
self.cascade_profile = rospy.get_param("~cascade_profile", "")
self.cascade_frontal_alt = cv.Load(self.cascade_frontal_alt)
self.cascade_frontal_alt2 = cv.Load(self.cascade_frontal_alt2)
self.cascade_profile = cv.Load(self.cascade_profile)
self.camera_frame_id = "kinect_depth_optical_frame"
self.depthFrameNum = 1
self.drag_start = None
self.selections = []
# viola jones parameters
self.min_size = (20, 20)
self.image_scale = 2
self.haar_scale = 1.5
self.min_neighbors = 1
self.haar_flags = cv.CV_HAAR_DO_CANNY_PRUNING
self.seeds = None
self.cps = 0 # Cycles per second = number of processing loops per second.
self.cps_values = list()
self.cps_n_values = 20
self.featureFile = open(
'/home/ben/Desktop/features/batch9_features.dat', 'w')
self.clusters = [5, 4, 4, 3, 3, 5, 4, 3, 3][9 - 1]
""" Wait until the image topics are ready before starting """
rospy.wait_for_message(self.input_rgb_image, Image)
rospy.wait_for_message(self.input_depth_image, Image)
rospy.loginfo("Starting " + self.node_name)
def display(image):
cv.NamedWindow("Red Eye Test", cv.CV_WINDOW_AUTOSIZE)
cv.ResizeWindow("Red Eye Test", 10, 10)
cv.ShowImage("Red Eye Test", image)
cv.WaitKey(0)
cv.DestroyWindow("Red Eye Test")
def analyze_file(filename):
"""
Assuming filename is a png that contains a rubiks cube, return
the RGB values for all 9 squares
"""
img = cv.LoadImage(filename)
(S1, S2) = cv.GetSize(img)
rf = RubiksFinder(S1, S2)
if display_window:
cv.NamedWindow("Fig", cv.CV_WINDOW_NORMAL)
cv.ResizeWindow("Fig", rf.width, rf.height)
ATTEMPTS = 100
rf.extract = True
for x in xrange(ATTEMPTS):
rf.analyze_frame(img)
# we can "track" (find the cube in the pic) but it takes ~30 attempts...why ~30?
log.info("analyze_frame %d/%d: tracking %s, THR %s" %
(x, ATTEMPTS - 1, rf.tracking, rf.THR))
if rf.tracking:
# log.warning("analyze_frame selected %s\ncolors\n%s\n\nhsvs\n%s\n\n" %
# (rf.selected,
# pformat(rf.colors),
# pformat(rf.hsvs)))
if display_window:
cv.ShowImage('foobar', img)
cv.WaitKey(0)
break
else:
raise Exception("Could not find the cube in %s" % filename)
if display_window:
cv.DestroyWindow("Fig")
# When analyzing a file we are only examining one side so use index 0 for colors and center_pixels
colors = rf.colors[0]
center_pixels = rf.center_pixels[0]
colors_final = []
# log.warning("rf.colors\n %s" % pformat(rf.colors))
# log.warning("rf.center_pixels\n%s" % pformat(rf.center_pixels))
# log.warning("colors\n %s" % pformat(colors))
# log.warning("center_pixels\n%s" % pformat(center_pixels))
# opencv returns BGR, not RGB
# http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_core/py_basic_ops/py_basic_ops.html#basic-ops
for ((x, y), (blue, green, red, _)) in zip(center_pixels, colors):
# Save in RGB, this makes the colors much easier to print on a web page
# for troubleshooting, it is also the format expected by rubiks_rgb_solver.py
colors_final.append({
'x': x,
'y': y,
'red': int(red),
'green': int(green),
'blue': int(blue)
})
return colors_final
cascade_file_path = '/usr/local/share/opencv/haarcascades/'
cascade_files = [
'haarcascade_frontalface_alt.xml',
'haarcascade_mcs_eyepair_big.xml',
]
detector_names = [
'face',
'eyes',
]
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, .75, .75, .12, 2)
cv.NamedWindow("Whole Image")
cv.ResizeWindow("Whole Image", *(640, 480))
cv.NamedWindow("ROI")
cv.ResizeWindow("ROI", *(200, 200))
cv.MoveWindow("ROI", *(640, 0))
i = 0
for name in detector_names:
if name != 'face' and name != 'profile':
cv.NamedWindow(name)
cv.ResizeWindow(name, *(320, 200))
cv.MoveWindow(name, *(0, 480 + (200 * i)))
i = i + 1
capture = cv.CaptureFromCAM(0)
feature_detectors = []
for file in cascade_files:
capture = scanCard.check_for_card()
if capture is not None:
print "Card captured, proceeding to find a match"
(card,
set_name), is_sure = match_card.match_card(capture, known, cache)
# Display matched information
if is_sure == True:
print "\tMatch Found!"
#card = unicode(card.decode('UTF-8'))
path = os.path.join(BASE_SET_DIR, set_name, card + ".full.jpg")
try:
tmp = cv.LoadImage(path)
overlay_text_on_image(tmp, "%s - %s" % (card, set_name), font)
cv.ShowImage("match", tmp)
cv.ResizeWindow("match", 800, 600)
match_pending = True
except IOError:
print "test.py Could not load card %s" % (path)
else:
print "\tMatch not found"
scanCard.display_snapshot()
key_code = cv.WaitKey(10)
if key_code == 114:
scanCard.update_background()
scanCard.display_background()
print "Updated background image"
