def callback(data):
global zero, prev
#cv2.namedWindow("flow",1)
#cv2.moveWindow("flow",500,00)
#cv2.namedWindow("zero_image",1)
#cv2.moveWindow("zero_image",600,0)
bridge = CvBridge()
if zero:
prev = bridge.imgmsg_to_cv2(data, "mono8")
cv_image = cv2.flip(prev,1)
#ret1,prev = cv2.threshold(prev, 0, 0,cv2.THRESH_BINARY)
zero = False
#cv2.imshow("zero_image", prev)
# cv_image = bridge.imgmsg_to_cv2(data, "bgr8")
cv_image = bridge.imgmsg_to_cv2(data, "mono8")
#gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
cv_image = cv2.flip(cv_image,1)
#cv2.imshow("motion_detector", cv_image)
motion_detector(cv_image, prev)
def imageFlipMirror(im, mirrored,flipped):
''' Flip and/or mirror the given image.
Parameters
-----------
im : np.array
2D array depicting an image as an numpy array
mirrored : np.array
self explanatory boolean parameter (left - right)
fliped np.array
self explanatory boolean parameter (top - bottom)
Returns
-----------
im : np.array
image array processed accordingly.
'''
if mirrored == 1 and flipped == 0:
im = cv2.flip(im, 1)
elif mirrored == 0 and flipped == 1:
im = cv2.flip(im, 0)
elif mirrored == 1 and flipped == 1:
im = cv2.flip(im, -1)
return im
def data_augmentation(img0):
global imgid
mirror_idx = [0,1] #0: not mirroing, #1 mirroring
scaling_vals = [1.0,1.2,1.4] #scaling factor
blur_vals = [0.0,1.2,1.5] #blur values, but 0.0 indicates not blurring
h0 = img0.shape[0]
w0 = img0.shape[1]
imgs = []
pathes = []
for m_idx in mirror_idx:
for scl in scaling_vals:
x1 = 0 + (w0 * scl - w0) / 2.0
y1 = 0 + (h0 * scl - h0) / 2.0
x2 = x1 + w0
y2 = y1 + h0
for blur_val in blur_vals:
img = img0.copy()
if m_idx == 1:
cv2.flip(img,1,img)
img = cv2.resize(img,(int(w0*scl), int(h0*scl)))
img = img[y1:y2, x1:x2]
if blur_val > 0.0:
img = cv2.GaussianBlur(img, (0,0), blur_val)
imgs.append(img)
path = 'pos%d.png' % (imgid)
imgid += 1
pathes.append(path)
return imgs, pathes
def getImage(self):
img = self.image
# Rotate image if it was recorded upside down.
if self.upside_down:
img = cv2.flip(img, 0)
img = cv2.flip(img, 1)
return img
def cv2rotateimage(image, angle):
"""Efficient rotation if 90 degrees rotations, slow otherwise.
Not a tensorflow function, using cv2 and scipy on numpy arrays.
Args:
image: a numpy array with shape [height, width, channels].
angle: the rotation angle in degrees in the range [-180, 180].
Returns:
The rotated image.
"""
# Limit angle to [-180, 180] degrees.
assert angle <= 180 and angle >= -180
if angle == 0:
return image
# Efficient rotations.
if angle == -90:
image = cv2.transpose(image)
image = cv2.flip(image, 0)
elif angle == 90:
image = cv2.transpose(image)
image = cv2.flip(image, 1)
elif angle == 180 or angle == -180:
image = cv2.flip(image, 0)
image = cv2.flip(image, 1)
else: # Slow rotation.
image = ndimage.interpolation.rotate(image, 270)
return image
def FindWand():
global rval,old_frame,old_gray,p0,mask,color,ig,img,frame
try:
rval, old_frame = cam.read()
cv2.flip(old_frame,1,old_frame)
old_gray = cv2.cvtColor(old_frame,cv2.COLOR_BGR2GRAY)
equalizeHist(old_gray)
old_gray = GaussianBlur(old_gray,(9,9),1.5)
dilate_kernel = np.ones(dilation_params, np.uint8)
old_gray = cv2.dilate(old_gray, dilate_kernel, iterations=1)
clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
old_gray = clahe.apply(old_gray)
#TODO: trained image recognition
p0 = cv2.HoughCircles(old_gray,cv2.HOUGH_GRADIENT,3,50,param1=240,param2=8,minRadius=4,maxRadius=15)
if p0 is not None:
p0.shape = (p0.shape[1], 1, p0.shape[2])
p0 = p0[:,:,0:2]
mask = np.zeros_like(old_frame)
ig = [[0] for x in range(20)]
print "finding..."
threading.Timer(3, FindWand).start()
except:
e = sys.exc_info()[1]
print "Error: %s" % e
exit
def trackRobot(self, imagePath):
'''this function track the robot and return its coordinates'''
img = cv2.imread(imagePath)
img = cv2.flip(img, 1)
img = cv2.flip(img, 0)
# convert into hsv
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
# Find mask that matches
green_mask = cv2.inRange(hsv, np.array((50., 30., 0.)), np.array((100., 255., 255.)))
green_mask = cv2.erode(green_mask, None, iterations=2)
green_mask = cv2.dilate(green_mask, None, iterations=2)
green_cnts = cv2.findContours(green_mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]
green_c = max(green_cnts, key=cv2.contourArea)
# fit an ellipse and use its orientation to gain info about the robot
green_ellipse = cv2.fitEllipse(green_c)
# This is the position of the robot
green_center = (int(green_ellipse[0][0]), int(green_ellipse[0][1]))
red_mask = cv2.inRange(hsv, np.array((0., 100., 100.)), np.array((80., 255., 255.)))
red_mask = cv2.erode(red_mask, None, iterations=2)
red_mask = cv2.erode(red_mask, None, iterations=2)
red_cnts = cv2.findContours(red_mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]
red_c = max(red_cnts, key=cv2.contourArea)
red_ellipse = cv2.fitEllipse(red_c)
red_center = (int(red_ellipse[0][0]), int(red_ellipse[0][1]))
return green_center, red_center
def start_anim(self):
self.style_texture.blit_buffer(cv2.flip(root.art_style, 0).tostring(), colorfmt='bgr', bufferfmt='ubyte')
self.photo_texture.blit_buffer(cv2.flip(root.photo_content, 0).tostring(), colorfmt='bgr', bufferfmt='ubyte')
w, h = Window.width, Window.height
rh = int(h *0.8)
rw = rh*4//3
self.output_rect.pos =((w-rw)//2,0)
self.output_rect.size = (rw, rh)
rh2 = int(h *0.3)
rw2 = rh2*4//3
self.photo_rect.pos =( -rw2,rh2+int(0.15*h))
self.style_rect.pos =( -rw2,int(0.05*h))
self.style_rect.size = (rw2, rh2)
self.photo_rect.size = (rw2, rh2)
self.canvas.ask_update()
rh = int(h *0.6)
rw = rh*4//3
xpos2 = int((w-(rw+rw2))/3)
idle1 = Animation(duration=1.)
idle2 = Animation(duration=2.)
idle3 = Animation(duration=3.)
move1 = Animation(pos=(xpos2, rh2+int(0.15*h)), duration=2.)
move2 = Animation(pos=(xpos2, int(0.05*h)) ,duration=2.)
move3 = Animation(pos=(2*xpos2+rw2,int(0.1*h)), size=(rw, rh), duration=2.)
(idle3 + move1).start(self.photo_rect)
(idle2 + move2).start(self.style_rect)
(idle1 + move3).start(self.output_rect)
def detect(self, img):
"""
:param img:{numpy}
:return:
"""
# vis为img副本
vis = img.copy()
# 转换为灰度图
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 直方图均衡处理
gray = cv2.equalizeHist(gray)
# 通过分类器得到rects
rects = detect(gray, self.frontCascade)
if len(rects) == 0:
# 侧脸检测
rects = detect(gray, self.profileCascade)
if len(rects) == 0:
# 镜像 在侧脸检测
gray = cv2.flip(gray, 1)
rects = detect(gray, self.profileCascade)
vis = cv2.flip(vis, 1)
result = []
# 画矩形
draw_rects(vis, rects, (0, 255, 0))
if len(rects) != 0:
for x1, y1, x2, y2 in rects:
result.append(vis[y1:y2, x1:x2])
else:
result.append(vis)
return result
def capture(flip_v = False, device = "/dev/spidev0.0"):
with Lepton(device) as l:
a,s = l.capture()
if flip_v:
cv2.flip(a,-1,a) #a flag to specify how to flip the array; 0 means flipping around the x-axis and positive value (for example, 1) means flipping around y-axis. Negative value (for example, -1) means flipping around both axes.
return a,s
def _tick(self, *args):
ret, img = self.cap.read()
img = cv2.flip(img, 1)
img2 = cv2.addWeighted(img, 0.7, self.art_style, 0.3, 0)
"""
mask = None
for bg in self.bgs:
diff = (np.linalg.norm(img.astype(float)-bg, axis=2)/3).astype(np.uint8)
r, mask0 = cv2.threshold(diff,6,255,cv2.THRESH_BINARY)
if mask is None:
mask = mask0
else:
mask = cv2.bitwise_or(mask, mask0)
mask_inv = cv2.bitwise_not(mask)
style2 = (cv2.bitwise_and(self.art_style, self.art_style, mask=mask_inv)*0.5).astype(np.uint8)
img3 = cv2.bitwise_and(img, img, mask=mask)
img2 = cv2.add(img3, style2)
"""
image = cv2.flip(img2, 0)
self.video_texture.blit_buffer(image.tostring(), colorfmt='bgr', bufferfmt='ubyte')
self.canvas.ask_update()
img2 = img
if self.state is not 'wait':
if self.state == 0:
print("照相")
root.photo_content = img2
root.art_style = self.art_style
root.transition = NoTransition()
root.current = "process"
if self.state%20 == 0:
self.ids.w_info.text = "倒數 %d 照相 (按鍵取消重選)"%(self.state//30)
self.ids.w_info.font_size = 32
self.state -=1
def read_im_and_landmarks(fname):
blur_amount = 31
im = cv2.imread(fname, cv2.IMREAD_COLOR)
im_core = cv2.resize(im, (im.shape[1] * faceswap.SCALE_FACTOR,
im.shape[0] * faceswap.SCALE_FACTOR))
core_shape = im_core.shape
left = int(core_shape[1] - 0.25 * core_shape[1])
right = int(2 * core_shape[1] + 0.25 * core_shape[1])
top = int(core_shape[0] - 0.25 * core_shape[0])
bottom = int(2 * core_shape[0] + 0.25 * core_shape[0])
# print("L,R,T,B {},{},{},{}".format(left, right, top, bottom))
im_blur = cv2.GaussianBlur(im_core, (blur_amount, blur_amount), 0)
im_blur = cv2.GaussianBlur(im_blur, (blur_amount, blur_amount), 0)
blur_flipx = cv2.flip(im_blur, 1)
blur_flipy = cv2.flip(im_blur, 0)
blur_flipxy = cv2.flip(im_blur, -1)
im_row1 = np.concatenate((blur_flipxy, blur_flipy, blur_flipxy), axis=1)
im_row2 = np.concatenate((blur_flipx, im_core, blur_flipx), axis=1)
im_row3 = np.concatenate((blur_flipxy, blur_flipy, blur_flipxy), axis=1)
im_buffered = np.concatenate((im_row1, im_row2, im_row3), axis=0)
im_final = im_buffered[top:bottom, left:right, :].astype(np.uint8)
s = faceswap.get_landmarks(im_final)
return im_final, s
def update_all(root, canvas, cam, fps_label):
#update_image(canvas, cam)
ret, img = cam.read()
cv2.flip(img,1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.equalizeHist(gray)
rects = detect(gray, cascade)
vis = img.copy()
vis = vis[...,::-1]#converts BGR to RGB
a = Image.fromarray(vis)
faces=[]
for x1, y1, x2, y2 in rects:
faces.append([[(x1+x2)/2,(y1+y2)/2]])
draw_sprites.draw_sprites(a,faces)
b = ImageTk.PhotoImage(image=a)
#canvas.delete(tk.ALL)
#canvas.delete('all')
global frame
frame = canvas.create_image(0,0,image=b,anchor=tk.NW)
root.update()
time.sleep(.001)
update_fps(fps_label)
root.after(0, func=lambda: update_all(root, canvas, cam, fps_label))
def main(self, mode, path):
"""Main loop.
"""
if not self.capture or not self.capture.isOpened() or self.mode != mode:
self.capture = cv2.VideoCapture(path)
self.mode = mode
if not self.capture.isOpened():
print "Couldn't read media " + path
while self.capture.isOpened():
if self.stopped:
break
ret, frame = self.capture.read()
if frame is None:
#self.capture = cv2.VideoCapture(path)
#ret, frame = self.capture.read()
if frame is None:
break
if mode == self.mw.SOURCE_CAMERA:
cv2.flip(frame, 1, frame)
self.mw.displayImage(frame)
QApplication.processEvents()
if self.nextFrame:
self.setNextFrameMode(False)
break
def loadMonitorImage(self,fname, allconts=False, testmc=False):
if fname[-4:].lower()==".avi":
#TODO get first frame - look this up
pass
elif fname[-4:].lower()==".png" or fname[-4:].lower()==".jpg":
a=cv2.imread(fname, 0) #note 0 implies grayscale
#getcontours
else:
#Error
pass
if self.mcflipx==True and self.mcflipy==True:
a=cv2.flip(a,-1)
elif self.mcflipx==True and self.mcflipy==False:
a=cv2.flip(a,0)
if self.mcflipy==True and self.mcflipx==False:
a=cv2.flip(a,1)
if self.crop1!=None and self.crop2!=None:
#print str(self.crop1)
#print str(self.crop2)
a=a[np.min([self.crop1[1],self.crop2[1]]):np.max([self.crop1[1],self.crop2[1]]),np.min([self.crop1[0],self.crop2[0]]):np.max([self.crop1[0],self.crop2[0]])]
#TODO add other digit sizes
if testmc==True:
self.trlist=[]
for dsize in self.dsizes:
(self.tmonimage,self.dlist,rlist)=self.getContours(a,dsize)
self.trlist+=rlist
self.drawMonitorTest()
else:
if allconts==False:
(self.monimage,self.dlist,self.rlist)=self.getContours(a,self.d1size)
self.drawMonitor()
else:
(self.monimage,self.rlist1,self.rlist2)=self.getAllContours(a)
self.drawMonitor(allconts=True)
def rotate_imgs(self): ''' Rotates left and right images to proper orientation. Note this is done with transpose and flip as opposed to cv2.warpAffine to improve speed. ''' self.rotated_image_left = cv2.flip(cv2.transpose(self.raw_image_left), 0) self.rotated_image_right = cv2.flip(cv2.transpose(self.raw_image_right), 1)
def callback(data): bridge = CvBridge() # cv_image = bridge.imgmsg_to_cv2(data, "bgr8") cv_image = bridge.imgmsg_to_cv2(data, "mono8") cv2.flip(cv_image,1) color_presentation(cv_image)
def play(dev=0):
cap = cv.VideoCapture(dev)
# Background subtractor with default parameters: history = 500,
# varThreshold = 16 and detectShadows = True
bgsub = cv.createBackgroundSubtractorMOG2(500, 16, False)
key = 0
pause = False
list_frames = []
img_index = 0
while(True):
key = cv.waitKey(1) & 0xFF
ret, frame = cap.read()
bgs = bgsub.apply(frame)
bgs_count = sum(sum(bgs))
if bgs_count > MAX_BGS:
list_frames.append(frame)
if len(list_frames) > MAX_FRAMES:
cv.imwrite(path + 'capt' + str(img_index) + '.png', cv.flip(frame, 1))
img_index+=1
list_frames = []
cv.imshow('frame', cv.flip(bgs, 1))
if key == 27:
break
if key == 32:
pause = not pause
if pause:
continue
cv.destroyAllWindows()
def run(self):
i = 0
cv2.namedWindow("image")
cv2.moveWindow("image", 50, 50)
while True:
p = self.get_next_image_file()
if p is None:
break
img = np.memmap(p, dtype=np.uint8, mode="r", shape=self.shape)
F = LabeledMovieFrame(internal_storage_method=self.format, compression_level=int(self.quality))
if self.rotate is not None and self.rotate in ["90", "180", "270"]:
img = np.rot90(img)
if self.rotate in ["180", "270"]:
img = np.rot90(img)
if self.rotate in ["270"]:
img = np.rot90(img)
if self.flip_vert:
img = cv2.flip(img, 0)
if self.flip_hor:
img = cv2.flip(img, 1)
if self.dsize.count("x") == 1:
osize = tuple(map(lambda x: int(x), self.dsize.split("x")))
else:
factor = float(self.dsize)
osize = int(img.shape[1]*factor), int(img.shape[0]*factor)
img = cv2.resize(img, dsize=osize, interpolation=cv2.INTER_CUBIC)
F.set_image(img)
cv2.imshow("image", img)
cv2.waitKey(40)
i += 1
self.frame_collection.append(F)
self.frame_collection.write_to_file(self.output_file)
def random_flip_img(img, horizontal_chance=0, vertical_chance=0):
import cv2
flip_horizontal = False
if random.random() < horizontal_chance:
flip_horizontal = True
flip_vertical = False
if random.random() < vertical_chance:
flip_vertical = True
if not flip_horizontal and not flip_vertical:
return img
flip_val = 1
if flip_vertical:
flip_val = -1 if flip_horizontal else 0
if not isinstance(img, list):
res = cv2.flip(img, flip_val) # 0 = X axis, 1 = Y axis, -1 = both
else:
res = []
for img_item in img:
img_flip = cv2.flip(img_item, flip_val)
res.append(img_flip)
return res
def getUImg(sid): #size can be m=hashlib.sha256() m.update(sid) hsh=m.hexdigest() npar=np.zeros((8,8,3),np.uint8) img=np.zeros((256,256,3),np.uint8) n=0 for i in range(0,8): for j in range(0,8): if(n==3): n=0 npar[i][j][n]=17*int(hsh[(i+1)*(j+1)-1],16) npar[i][j][(n+1)%3]=255-npar[i][j][n] n+=1 npar=cv2.resize(npar,(128,128)) imgLU=npar imgRU=cv2.flip(npar,1) img[:128,:128]=imgLU img[:128,128:256]=imgRU img[128:256,:256]=cv2.flip(img[:128,:256],0) return img
def PopulateImages(self):
"""
Populate necessary images for opencv to use
:return: 0 if the video is done
"""
if self.csvFlag:
try:
points = self.PointsFromCSV()
except:
return 0
self.img0 = self.PointsForJointsCSV(points) # img0 is a list of lists of points. each sublist corresponds to a joint. The last sublist corresponds to roguepoints
else:
ret, frame = self.cam.read()
if frame is None:
return 0# video done streaming
if self.rotation != 0:
if self.rotation == 90:
frame = cv2.flip(cv2.transpose(frame), 1)
elif self.rotation == -90:
frame = cv2.flip(cv2.transpose(frame), 0)
elif abs(self.rotation) == 180:
frame = cv2.flip(cv2.flip(frame,0), 1)
else:
raise Exception("Improper rotation value passed.")
if prm.DEBUG:
self.vis = frame.copy()
self.frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
return 1#Good flag
def transformImages(self, images, classes=None, rotate=False, crop=False):
transformedImages = []
transformedClasses = []
for i in range(0, len(images)):
image = images[i]
transformedImages.append(image) # Cargo las imagenes en formato cv2
transformedImages.append(cv2.flip(image, 1)) # Cargo el mirror horizontal
transformedImages.append(cv2.flip(image, 0)) # Cargo el mirror vertical
if rotate:
transformedImages.append(self._rotateImage(image, 90))
transformedImages.append(self._rotateImage(image, 270))
if crop:
transformedImages += self._getCrops(image)
# TODO: Agregar esta transformacion: http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_imgproc/py_geometric_transformations/py_geometric_transformations.html#affine-transformation
if(classes is not None):
animalClass = classes[i]
transformedClasses.append(animalClass) # Al agregar la imagen y su clase en el mismo orden no pierdo la relacion
transformedClasses.append(animalClass) # Agrego la clase del mirror Horizontal
transformedClasses.append(animalClass) # Agrego la clase del mirror vertical
if rotate:
transformedClasses.append(animalClass)
transformedClasses.append(animalClass)
if crop:
for j in range(6):
transformedClasses.append(animalClass)
return (transformedImages, transformedClasses)
def getImage(i, imOriginal, mean):
if i == 0: #return a central crop of 99x99 pixels
resized = cv2.resize(imOriginal, (128, 128))
resized = resized * 256.0 - mean
return resized[14:113, 14:113]
rot = np.random.uniform(0,360,1).astype(int)[0] #Random rotations
rot = 90 * np.random.uniform(0,4,1).astype(int)[0] #Random rotations
# rot = 0
im_size = imOriginal.shape[0]
if (np.random.rand() > 0.5):
if (np.random.rand() > 0.5):
imOriginal = cv2.flip(imOriginal,0)
else:
imOriginal = cv2.flip(imOriginal,1)
scale = np.random.uniform(0.9,1.1)
mat = cv2.getRotationMatrix2D((im_size / 2, im_size / 2), rot, scale=scale)
resized = cv2.warpAffine(img_out, mat, (im_size, im_size), borderValue=(255,255,255))
img_out = np.zeros((resized.shape[0], resized.shape[1], 3), dtype=np.uint8)
img_orig = resized[:,:,0]
img_btop = 255-black_tophat(img_orig, selem)
img_wtop = 255-white_tophat(img_orig, selem)
img_out[:, :, 1] = img_btop
img_out[:, :, 2] = img_wtop
resized = cv2.resize(img_out, (128, 128))
resized = resized * 256.0 - mean #Geht richtig in den Keller auf Werte um 4, wenn man mean nicht abzieht
# offsetX = np.random.uniform(10,18,1).astype(int)[0]
# offsetY = np.random.uniform(10,18,1).astype(int)[0]
offsetX = np.random.uniform(0,28,1).astype(int)[0] #Random rotations
offsetY = np.random.uniform(0,28,1).astype(int)[0] #Random rotations
return resized[offsetY:(99+offsetY), offsetX:(99+offsetX)]
def drawHistogram(height, histogram, k):
nhist = len(histogram)
s = 2
while (2*height > s*nhist-1): s += 1
himage = 220 * numpy.ones( (height, s*nhist-1, 3), dtype='uint8' )
hmax = numpy.max(histogram)
for c in range(nhist):
label = c / k
color = ccolors[ label % len(ccolors) ]
hc = histogram[c] / hmax
y = int(hc*height)
if (y):
startcol = s*c
endcol = s*(c+1)-1
color = numpy.array(color).reshape( (1,1,3) )
himage[0:y, startcol:endcol, :] = color
cv2.flip(himage, 0, himage)
return himage
def flippingOp(self):
# read image
im = cv2.imread(self.Image)
# flip the image horizontally
flipped = cv2.flip(im, 1)
cv2.imshow("Flipped Horizontally", flipped)
(b, g, r) = flipped[235, 259]
print("red=%d, green=%d, blue=%d" % (r,g,b))
cv2.waitKey(0)
# flip the image vertically
flipped = cv2.flip(im, 0)
cv2.imshow("Flipped Vertically", flipped)
cv2.waitKey(0)
# flip on both axis
flipped = cv2.flip(im, -1)
cv2.imshow("Flipped on both axis", flipped)
cv2.waitKey(0)
flipped = cv2.flip(im, 1)
cv2.imshow("1", flipped)
cv2.waitKey(0)
rotated = imutils.rotate(flipped, 45)
cv2.imshow("2", rotated)
cv2.waitKey(0)
flippedAgain = cv2.flip(rotated, 0)
cv2.imshow("3", flippedAgain)
cv2.waitKey(0)
(b, g, r) = flippedAgain[189, 441]
print("red=%d, green=%d, blue=%d" % (r,g,b))
return
def grabFrames(): global imageLeft global imageRight # global filterStackLeft # global filterStackRight returnLeft, tempLeft = captureLeft.read() returnLeft, tempRight = captureRight.read() imageLeft = cv2.flip(cv2.transpose(tempLeft), 0) #imageLeft = cv2.flip(tempLeft, -1) imageRight = cv2.flip(cv2.transpose(tempRight), 0) #imageRight = tempRight# # grayL = cv2.cvtColor(imageLeft, cv2.COLOR_RGBA2GRAY) # grayR = cv2.cvtColor(imageRight, cv2.COLOR_RGBA2GRAY) # filterStackLeft = np.roll(filterStackLeft, 1, axis=0) # filterStackLeft[0] = grayL # filterStackRight = np.roll(filterStackRight, 1, axis=0) # filterStackRight[0] = grayR imageLeft = bilateralFilter(imageLeft) imageRight = bilateralFilter(imageRight)
def convert_to_pickle(infilename, outfilename, dsize, channel, rotate, format, quality, flip_vert, flip_hor):
cam = cv2.VideoCapture(infilename)
fc = lm.FrameCollection()
cv2.namedWindow("Image")
cv2.moveWindow("Image", 50, 50)
while True:
(ret, im) = cam.read()
if not ret:
break
if dsize is not None:
osize = tuple(map(lambda x: int(x), dsize.split("x")))
im=cv2.resize(im, dsize=osize, interpolation=cv2.INTER_CUBIC)
if rotate is not None and rotate in ["90", "180", "270"]:
im = np.rot90(im)
if rotate in ["180", "270"]:
im = np.rot90(im)
if rotate in ["270"]:
im = np.rot90(im)
if flip_vert:
im = cv2.flip(im, 0)
if flip_hor:
im = cv2.flip(im, 1)
cv2.imshow("Image", im)
key = cv2.waitKey(1)
if key == 27:
quit()
f = lm.LabeledMovieFrame(internal_storage_method=format, compression_level=int(quality))
f.create_channel(channel=channel)
f.set_image(im, channel=channel)
f.set_default_channel(channel=channel)
fc.append(f)
fc.write_to_file(outfilename)
def rotate(input_file,output_file,mode) : img = cv2.imread(input_file,cv2.IMREAD_GRAYSCALE) rows,cols= img.shape temp = np.zeros((cols,rows),np.uint8) cv2.transpose(img,temp) cv2.flip(temp,mode,temp) cv2.imwrite(output_file,temp)
def process_context_detail_args(args):
# TODO: validate destination path up-front
# TODO: validate mole names up-front
context_image = mel.lib.image.load_image(args.context)
detail_image = mel.lib.image.load_image(args.detail)
if args.rot90:
context_image = rotated90(context_image, args.rot90)
detail_image = rotated90(detail_image, args.rot90)
if args.rot90_context:
context_image = rotated90(context_image, args.rot90_context)
if args.rot90_detail:
context_image = rotated90(detail_image, args.rot90_detail)
if args.h_mirror:
context_image = cv2.flip(context_image, 1)
detail_image = cv2.flip(detail_image, 1)
if args.h_mirror_context:
context_image = cv2.flip(context_image, 1)
if args.h_mirror_detail:
detail_image = cv2.flip(detail_image, 1)
return context_image, detail_image
def update_frame(self):
ret, self.image = self.capture.read()
self.image = cv2.flip(self.image, 1)
self.displayImage(self.image, 1)
import cv2, pickle
import numpy as np
import pyrealsense2 as rs
from coordinate_convert import *
coor = None
pipeline = init_color_camera()
try:
while True:
frames = pipeline.wait_for_frames()
color_frame = frames.get_color_frame()
if not color_frame:
continue
color_image = np.asanyarray(color_frame.get_data())
color_image = cv2.flip(color_image, 0)
cap = detect_cap(color_image)
coor = get_axis(cap)
for one_cap in cap:
color_image = cv2.circle(color_image, (one_cap[0], one_cap[1]), one_cap[2], (0, 255, 0))
if coor is not None:
print(coor, end='\r')
else:
print('{0} CAP(S) DETECTED '.format(len(cap)), end='\r')
# Show images
cv2.namedWindow('RealSense', cv2.WINDOW_AUTOSIZE)
cv2.imshow('RealSense', color_image)
key = cv2.waitKey(100)
if key == 27:
def flip(img, dir):
return cv2.flip(img, dir)
def main(**kwargs):
opt._parse(kwargs)
# n_gpu = utils.set_gpu(opt.gpu)
test_dataset = FashionAIKeypoints(opt, phase='test')
encoder = test_dataset.encoder
df = utils.data_frame_template()
print('Testing: {}'.format(opt.category))
print('Testing sample number: {}'.format(len(val_dataset)))
cudnn.benchmark = True
net1 = getattr(models, opt.model[0])(opt)
checkpoint = torch.load(opt.load_checkpoint_path) # Must be before cuda
net1.load_state_dict(checkpoint['state_dict'])
net1 = net1.cuda()
# net1 = DataParallel(net)
net1.eval()
net2 = getattr(models, opt.model[1])(opt)
checkpoint = torch.load(opt.load_checkpoint_path_2) # Must be before cuda
net2.load_state_dict(checkpoint['state_dict'])
net2 = net2.cuda()
# net2 = DataParallel(net2)
net2.eval()
for idx in tqdm(range(len(test_dataset))):
img_path = test_dataset.get_image_path(idx)
img0 = cv2.imread(img_path) # BGR
img0_flip = cv2.flip(img0, 1)
img_h, img_w, _ = img0.shape
scale = opt.img_max_size / max(img_w, img_h)
hm_pred = utils.compute_keypoints(opt, img0, net, encoder)
hm_pred_flip = utils.compute_keypoints(opt,
img0_flip,
net,
encoder,
doflip=True)
hm_pred2 = utils.compute_keypoints(opt, img0, net2, encoder)
hm_pred_flip2 = utils.compute_keypoints(opt,
img0_flip,
net2,
encoder,
doflip=True)
x, y = encoder.decode_np(
hm_pred + hm_pred_flip + hm_pred2 + hm_pred_flip2, scale,
opt.hm_stride, (img_w / 2, img_h / 2))
keypoints = np.stack([x, y, np.ones(x.shape)], axis=1).astype(np.int16)
row = test_dataset.anno_df.iloc[idx]
df.at[idx, 'image_id'] = row['image_id']
df.at[idx, 'image_category'] = row['image_category']
for k, kpt_name in enumerate(opt.keypoints[opt.category]):
df.at[idx, kpt_name] = str(keypoints[k, 0]) + '_' + str(
keypoints[k, 1]) + '_1'
if args.visual:
kp_img = utils.draw_keypoints(img0, keypoints)
save_img_path = str(
opt.db_path /
'tmp/ensemble_{0}{1}.png'.format(opt.category, idx))
cv2.imwrite(save_img_path, kpt_img)
df.fillna('-1_-1_-1', inplace=True)
print(df.head(5))
df.to_csv(opt.pred_path / 'ensemble_{}.csv'.format(opt.category),
index=False)
def update(self):
"""
Updates the current display based on current information of the agent
"""
if self.step % settings.steps_slam == 0:
self.agent.slam(self.bytearray)
array = np.frombuffer(self.bytearray, dtype=np.uint8)
self.grid = np.reshape(array,
[settings.image_size, settings.image_size])
self.im = self.to_image()
self.draw_agent(self.im)
# self.im = cv2.cvtColor(cv2.Canny(self.im, 100,150), cv2.COLOR_GRAY2RGB)
self.draw_closest(self.im)
self.draw_trajectory(self.im)
self.draw_frontier_centroids(self.im)
self.draw_wps_delayed(self.im, self.waypoints)
self.im = cv2.flip(self.im, 0)
self.draw_elements(self.im)
self.draw_speed(self.im)
# im = cv2.filter2D(im,-1,np.ones((5,5),np.float32)/25)
self.im = cv2.blur(self.im, (3, 3))
cv2.imshow('Simultaneous Localization and Mapping (SLAM)', self.im)
key = cv2.waitKey(1) & 0xFF
self.step += 1
array = np.frombuffer(self.bytearray, dtype=np.uint8)
gray = np.reshape(array, [settings.image_size, settings.image_size])
#self.agent.current_target = (450, 400)
print("pos:", self.agent.pos)
# planning part
if self.step % settings.steps_lee == 0 and len(self.centroids) != 0:
print("***start path planning")
print("***agent pos:", self.agent.pos)
print("***target:", self.centroids[0])
array = np.frombuffer(self.bytearray, dtype=np.uint8)
grid = np.reshape(array,
[settings.image_size, settings.image_size])
obst = preprocess_grid(grid, True)
obst = grow_obstacle(obst)
waypoints = lee_planning_path(
obst, (self.agent.pos[0], self.agent.pos[1]),
self.centroids[0])
print("***end path planning")
if waypoints:
self.agent.current_target = waypoints[0]
self.waypoints = waypoints
print("wp in action:", self.agent.current_target)
print("all_waypoints:", self.waypoints)
if self.agent.current_target:
cv2.drawMarker(
self.im,
(self.agent.current_target[0], -self.agent.current_target[1]),
(0, 255, 0),
markerSize=25,
markerType=cv2.MARKER_STAR)
(255, 255, 255), 2, cv2.LINE_AA)
cv2.namedWindow('Paint', cv2.WINDOW_AUTOSIZE)
# Load the video
camera = cv2.VideoCapture(0, cv2.CAP_DSHOW)
letterToDraw = 97
correct = False
incorrect = False
# Keep looping
while True:
# Grab the current paintWindow
(grabbed, frame) = camera.read()
frame = cv2.flip(frame, 1)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# Add the coloring options to the frame
frame = cv2.rectangle(frame, (40, 1), (140, 65), (122, 122, 122), -1)
frame = cv2.rectangle(frame, (160, 1), (255, 65), colors[0], -1)
frame = cv2.rectangle(frame, (275, 1), (370, 65), colors[1], -1)
frame = cv2.rectangle(frame, (390, 1), (485, 65), colors[2], -1)
frame = cv2.rectangle(frame, (505, 1), (600, 65), colors[3], -1)
cv2.putText(frame, "CLEAR ALL", (49, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "BLACK", (185, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "GREEN", (298, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(frame, "RED", (420, 33), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
r = 0
t = 2020
b = 0
#################################################################
pixelDraw = 5
pre_predict = -1
is_start_time_back = -1 # tính giờ cho back nếu lớn hơn 1,5s xóa hết
is_start_time_write = -1
while True:
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
ret, image_np = cap.read()
if not ret:
continue
image_np = cv2.flip(image_np, 1)
try:
image_np = cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB)
except:
print("Error converting to RGB")
# actual detection
boxes, scores, classes = detector_utils.detect_objects(
image_np, detection_graph, sess)
# DRAWWWW
(left, right, top, bottom) = (boxes[0][1] * im_width, boxes[0][3] * im_width,
boxes[0][0] * im_height, boxes[0][2] * im_height)
cv2.putText(image_np, str(scores[0]), (30,30), cv2.FONT_HERSHEY_COMPLEX, 1, (0,255,222))
def generate_depth_env_maps(self, depth_maps):
depth_env_maps = []
h_depth_map, w_depth_map = depth_maps[0].shape
center = np.array(
[int(depth_maps.shape[2] / 2),
int(depth_maps.shape[1] / 2)])
# getting max and min co-ords of the fish eye image
max_x, max_y = self.max_coord(center)
min_x, min_y = self.min_coord(center)
cyl = np.zeros((h_depth_map, int(max_x - min_x) + 1), np.float32)
mask = np.zeros((cyl.shape[0], cyl.shape[1]))
xyz_all = np.zeros((h_depth_map, w_depth_map, 3))
# creating co-ord matrix
x = np.arange(w_depth_map)
y = np.arange(h_depth_map)
xx, yy = np.meshgrid(x, y)
xyz_all[:, :, 0] = yy - center[1]
xyz_all[:, :, 1] = xx - center[0]
# fish-eye co-ord mapping
xy = np.round(self.convert2cyl_whole(xyz_all, center))
xy[:, :, 1] = xy[:, :, 1] - min_x
ind_vals, ind = np.unique(xy.astype(np.int32).reshape(-1, 2),
axis=0,
return_index=True)
cyl[ind_vals[:, 0], ind_vals[:, 1]] = depth_maps[0].reshape((-1))[ind]
mask[ind_vals[:, 0], ind_vals[:, 1]] = 255
for depthMapNo in range(depth_maps.shape[0]):
cyl[ind_vals[:, 0],
ind_vals[:, 1]] = depth_maps[depthMapNo].reshape((-1))[ind]
mask[ind_vals[:, 0], ind_vals[:, 1]] = 255
# fill the top part
mask_temp = mask[:mask.shape[0] // 2, :]
cyl_temp = cyl[:cyl.shape[0] // 2, :]
cyl_temp[np.where(mask_temp == 0)[0],
np.where(mask_temp == 0)[1]] = cyl[self.fillMatUp[:, 0],
self.fillMatUp[:, 1]]
cyl[:cyl.shape[0] // 2, :] = cyl_temp
# fill the bottom part
mask_temp = cv2.flip(mask, 0)[:mask.shape[0] // 2, :]
cyl_temp = cv2.flip(cyl, 0)[:cyl.shape[0] // 2, :]
cyl_temp[np.where(mask_temp == 0)[0],
np.where(mask_temp == 0)[1]] = cv2.flip(
cyl, 0)[self.fillMatDown[:, 0], self.fillMatDown[:,
1]]
cyl[cyl.shape[0] // 2:, :] = cv2.flip(cyl_temp, 0)
# expanding the map by pasting flipped cropped images on left and right
result = cv2.copyMakeBorder(cyl,
0,
0,
int(cyl.shape[1] / 2),
int(cyl.shape[1] / 2),
cv2.BORDER_CONSTANT,
value=(0, 0, 0))
# paste left
side = cyl[:, 0:int(cyl.shape[1] / 2)]
side = cv2.flip(side, 1)
result[:, 0:side.shape[1]] = side
# paste right
side = cyl[:, int(cyl.shape[1] / 2):cyl.shape[1]]
side = cv2.flip(side, 1)
result[:, result.shape[1] - side.shape[1]:result.shape[1]] = side
depth_env_maps.append(result)
return np.array(depth_env_maps)
text_colour = (255, 0, 0)
return lower, upper, text_colour
cap = cv2.VideoCapture(0)
# Use trackbar to switch between tracking a red, blue or green object
cv2.namedWindow('img')
cv2.createTrackbar('RGB', 'img', 0, 2, choose_colour)
# i = 0
colour_dict = {0: "Red", 1: "Green", 2: "Blue"}
while (True):
ret, frame = cap.read()
img = cv2.flip(frame, 1)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
# Obtain position of trackbar to pick which colour to track
a_pos = cv2.getTrackbarPos('RGB', 'img')
text = colour_dict[a_pos]
# Use position of trackbar to pick colour and then isolate objects of matching colour
lower, upper, text_colour = choose_colour(a_pos)
fnres = color_isolate(hsv, lower, upper)
# Extract contours from image after processing
_, contours, _ = cv2.findContours(fnres, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
try:
# Obtain contour of greatest size
box_size[0], box_size[1])
bbox = bbox_initial
# Tracking status, -1 for not tracking, 0 for unsuccessful tracking, 1 for successful tracking
tracking = -1
# Text display positions
positions = {'fps': (15, 20)}
for frame in camera.capture_continuous(rawCapture,
format="bgr",
use_video_port=True):
# grab the raw NumPy array representing the image, then initialize the timestamp
# and occupied/unoccupied text
image = frame.array
image = cv2.flip(image, 1)
timer = cv2.getTickCount()
diff = cv2.absdiff(bg, image)
mask = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
# Threshold the mask
th, thresh = cv2.threshold(mask, 10, 255, cv2.THRESH_BINARY)
# Opening, closing and dilation
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel)
img_dilation = cv2.dilate(closing, kernel, iterations=2)
# Get mask indexes
imask = img_dilation > 0
# Get foreground from mask
foreground = mask_array(image, imask)
foreground_display = foreground.copy()
def load_data(self, is_train, repeat, mirror=None):
if (mirror is not None):
with open(mirror, 'r') as f:
lines = f.readlines()
assert len(lines) == 1
mirror_idx = lines[0].strip().split(',')
mirror_idx = list(map(int, mirror_idx))
xy = np.min(self.landmark, axis=0).astype(np.int32)
zz = np.max(self.landmark, axis=0).astype(np.int32)
wh = zz - xy + 1
center = (xy + wh/2).astype(np.int32)
img = cv2.imread(self.path)
boxsize = int(np.max(wh)*1.2)
xy = center - boxsize//2
x1, y1 = xy
x2, y2 = xy + boxsize
height, width, _ = img.shape
dx = max(0, -x1)
dy = max(0, -y1)
x1 = max(0, x1)
y1 = max(0, y1)
edx = max(0, x2 - width)
edy = max(0, y2 - height)
x2 = min(width, x2)
y2 = min(height, y2)
# for x, y in (self.landmark + 0.5).astype(np.int32):
# cv2.circle(img, (x, y), 1, (0, 0, 255))
imgT = img[y1:y2, x1:x2]
if (dx > 0 or dy > 0 or edx > 0 or edy > 0):
imgT = cv2.copyMakeBorder(imgT, dy, edy, dx, edx, cv2.BORDER_CONSTANT, 0)
# if imgT.shape[0] == 0 or imgT.shape[1] == 0:
# imgTT = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
# for x, y in (self.landmark+0.5).astype(np.int32):
# cv2.circle(imgTT, (x, y), 1, (0, 0, 255))
# cv2.imshow('0', imgTT)
# if cv2.waitKey(0) == 27:
# exit()
if is_train:
imgT = cv2.resize(imgT, (self.image_size, self.image_size))
landmark = (self.landmark - xy)/boxsize
assert (landmark >= 0).all(), str(landmark) + str([dx, dy])
assert (landmark <= 1).all(), str(landmark) + str([dx, dy])
self.imgs.append(imgT)
self.landmarks.append(landmark)
if is_train:
while len(self.imgs) < repeat:
angle = np.random.randint(-20, 20)
cx, cy = center
cx = cx + int(np.random.randint(-boxsize*0.1, boxsize*0.1))
cy = cy + int(np.random.randint(-boxsize * 0.1, boxsize * 0.1))
M, landmark = rotate(angle, (cx, cy), self.landmark)
imgT = cv2.warpAffine(img, M, (int(img.shape[1]*1.1), int(img.shape[0]*1.1)))
# for x, y in (landmark + 0.5).astype(np.int32):
# cv2.circle(imgT, (x, y), 1, (0, 0, 255))
wh = np.ptp(landmark, axis=0).astype(np.int32) + 1
size = np.random.randint(int(np.min(wh)), np.ceil(np.max(wh) * 1.25))
xy = np.asarray((cx - size // 2, cy - size//2), dtype=np.int32)
landmark = (landmark - xy) / size
if (landmark < 0).any() or (landmark > 1).any():
continue
x1, y1 = xy
x2, y2 = xy + size
height, width, _ = imgT.shape
dx = max(0, -x1)
dy = max(0, -y1)
x1 = max(0, x1)
y1 = max(0, y1)
edx = max(0, x2 - width)
edy = max(0, y2 - height)
x2 = min(width, x2)
y2 = min(height, y2)
imgT = imgT[y1:y2, x1:x2]
if (dx > 0 or dy > 0 or edx >0 or edy > 0):
imgT = cv2.copyMakeBorder(imgT, dy, edy, dx, edx, cv2.BORDER_CONSTANT, 0)
imgT = cv2.resize(imgT, (self.image_size, self.image_size))
if mirror is not None and np.random.choice((True, False)):
landmark[:, 0] = 1 - landmark[:, 0]
landmark = landmark[mirror_idx]
imgT = cv2.flip(imgT, 1)
self.imgs.append(imgT)
self.landmarks.append(landmark)
def generate_map(self, background):
# Easier if everything is in int due to cv2 calls
background = (background * 255).astype(np.uint8)
center = np.array(
[int(background.shape[1] // 2),
int(background.shape[0] // 2)])
max_x, max_y = self.max_coord(center)
min_x, min_y = self.min_coord(center)
mask = np.zeros((background.shape[0], int(max_x - min_x) + 1),
np.uint8)
# creating co-ord matrix
xyz_all = np.zeros((background.shape[0], background.shape[1], 3))
x = np.linspace(0, background.shape[1] - 1, background.shape[1])
y = np.linspace(0, background.shape[0] - 1, background.shape[0])
xx, yy = np.meshgrid(x, y)
xyz_all[:, :, 0] = yy - center[1]
xyz_all[:, :, 1] = xx - center[0]
# fish-eye co-ord mapping
xy = np.round(self.convert2cyl_whole(xyz_all, center))
xy[:, :, 1] = xy[:, :, 1] - min_x
ind_vals, ind = np.unique(xy.astype(np.int32).reshape(-1, 2),
axis=0,
return_index=True)
# creating fish-eye image
if background.ndim == 3:
cyl = np.zeros((background.shape[0], int(max_x - min_x) + 1, 3),
np.uint8)
cyl[ind_vals[:, 0], ind_vals[:, 1]] = background.reshape(
(-1, 3))[ind]
else:
cyl = np.zeros((background.shape[0], int(max_x - min_x) + 1),
np.float64)
cyl[ind_vals[:, 0], ind_vals[:, 1]] = background.reshape((-1))[ind]
mask[ind_vals[:, 0], ind_vals[:, 1]] = 255
self.fillMatUp, self.fillMatDown = self.fill_matrices(cyl, mask)
# filling the bottom portion
mask_temp = cv2.flip(mask, 0)[:mask.shape[0] // 2, :]
cyl_temp = cv2.flip(cyl, 0)[:cyl.shape[0] // 2, :]
cyl_temp[np.where(mask_temp == 0)[0],
np.where(mask_temp == 0)[1]] = cv2.flip(
cyl, 0)[self.fillMatDown[:, 0], self.fillMatDown[:, 1]]
cyl[-cyl_temp.shape[0]:, :] = cv2.flip(cyl_temp, 0)
# filling gaps
# filling the top portion
mask_temp = mask[:mask.shape[0] // 2, :]
cyl_temp = cyl[:cyl.shape[0] // 2, :]
cyl_temp[np.where(mask_temp == 0)[0],
np.where(mask_temp == 0)[1]] = cyl[self.fillMatUp[:, 0],
self.fillMatUp[:, 1]]
cyl[:cyl_temp.shape[0], :] = cyl_temp
result = cv2.copyMakeBorder(
cyl,
0,
0,
int(cyl.shape[1] / 2),
int(cyl.shape[1] / 2),
cv2.BORDER_CONSTANT,
value=(0, 0, 0)) # TODO: check issue with float values ?
mask_result = cv2.copyMakeBorder(
mask,
0,
0,
int(mask.shape[1] / 2),
int(mask.shape[1] / 2),
cv2.BORDER_CONSTANT,
value=0) # TODO: check issue with float values ?
# attaching cropped flipped image to left image and mask
side = cyl[:, 0:int(cyl.shape[1] / 2)]
side = cv2.flip(side, 1) # TODO: check issue with float values ?
result[:, 0:side.shape[1]] = side
mask_side = mask[:, :cyl.shape[1] // 2]
mask_side = cv2.flip(mask_side,
1) # TODO: check issue with float values ?
mask_result[:, :mask_side.shape[1]] = mask_side
# attaching cropped flipped image to right
side = cyl[:, cyl.shape[1] // 2:]
side = cv2.flip(side, 1) # TODO: check issue with float values ?
result[:, result.shape[1] - side.shape[1]:result.shape[1]] = side
mask_side = mask[:, cyl.shape[1] // 2:]
mask_side = cv2.flip(mask_side,
1) # TODO: check issue with float values ?
mask_result[:, mask_result.shape[1] - side.shape[1]:] = mask_side
if result.ndim == 3:
blur = cv2.GaussianBlur(result, (15, 15),
0) # TODO: check issue with float values ?
mask_result = np.tile(np.expand_dims(mask_result, axis=-1),
(1, 1, 3))
result = result + ((blur - result) & ~mask_result)
return result / 255.0
def match_face(unlockFaceId):
faceCascPath = "modules/face_lock_unlock/face_recognition/haarcascade_frontalface_default.xml"
eyeCascadePath = "modules/face_lock_unlock/face_recognition/haarcascade_eye.xml"
faceCascade = cv2.CascadeClassifier(faceCascPath)
eyeCascade = cv2.CascadeClassifier(eyeCascadePath)
cam = cv2.VideoCapture(1)
if cam.read()[0] == False:
cam = cv2.VideoCapture(0)
recog = cv2.face.LBPHFaceRecognizer_create()
recog.read(
'modules/face_lock_unlock/face_recognition/recognized/training.yml')
#os.system("dir")
faceId = 0
matchFrameCount = 0
flagFaceMatched = False
while True:
img = cam.read()[1]
img = cv2.flip(img, 1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(gray,
1.1,
5,
flags=cv2.CASCADE_SCALE_IMAGE)
for (x, y, w, h) in faces:
face = gray[y:y + h, x:x + w]
eyes = eyeCascade.detectMultiScale(face,
1.1,
5,
flags=cv2.CASCADE_SCALE_IMAGE)
if len(eyes) == 2:
faceId, confidence = recog.predict(face)
if confidence < 50:
profile = getProfileDataById(str(faceId))
name = profile[1]
if faceId in unlockFaceId:
matchFrameCount += 0.5
else:
matchFrameCount = 0
else:
name = "Unknown"
matchFrameCount = 0
cv2.rectangle(img, (x, y), (x + w, y + h), 2)
cv2.putText(img, "Name- " + name, (x, y + h),
cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 0, 0), 2)
matchFrameCountPercentage = int(matchFrameCount * 100 / 10)
if matchFrameCountPercentage <= 10:
cv2.putText(img, "Matching... " +
str(matchFrameCountPercentage) + "%",
(x, y + h + 20), cv2.FONT_HERSHEY_PLAIN, 1.5,
(0, 0, 255), 2) #red
elif matchFrameCountPercentage <= 20:
cv2.putText(img, "Matching... " +
str(matchFrameCountPercentage) + "%",
(x, y + h + 20), cv2.FONT_HERSHEY_PLAIN, 1.5,
(0, 165, 255), 2) #orange
elif matchFrameCountPercentage <= 60:
cv2.putText(img, "Matching... " +
str(matchFrameCountPercentage) + "%",
(x, y + h + 20), cv2.FONT_HERSHEY_PLAIN, 1.5,
(0, 255, 255), 2) #yellow
elif matchFrameCountPercentage <= 99:
cv2.putText(img, "Matching... " +
str(matchFrameCountPercentage) + "%",
(x, y + h + 20), cv2.FONT_HERSHEY_PLAIN, 1.5,
(50, 205, 154), 2) #lime green
else:
cv2.putText(
img, "Matched " + str(matchFrameCountPercentage) + "%",
(x, y + h + 20), cv2.FONT_HERSHEY_PLAIN, 1.5,
(0, 255, 0), 2)
flagFaceMatched = True
with open("match_face_result", "w") as f:
f.write("True")
break
#print ("id = " + str(faceId) + " , confidence = " + str(confidence))
if flagFaceMatched == True:
break
cv2.imshow("Face Recognition Running", img)
cv2.waitKey(1)
cam.release()
cv2.destroyAllWindows()
return flagFaceMatched
sys.path.append('/usr/local/lib/python3.5/site-packages')
import cv2
import os
cam = cv2.VideoCapture(0)
cam.set(3, 640) # set video width
cam.set(4, 480) # set video height
face_detector = cv2.CascadeClassifier(
'/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml')
# For each person, enter one numeric face id 输入id和姓名
face_id = input('\n enter user id end press <return> ==> ')
print("\n [INFO] Initializing face capture. Look the camera and wait ...")
# Initialize individual sampling face count
count = 0
while (True):
ret, img = cam.read()
img = cv2.flip(img, -1) # flip video image vertically
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_detector.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
count += 1
# Save the captured image into the datasets folder
cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg",
gray[y:y + h, x:x + w])
cv2.imshow('image', img)
k = cv2.waitKey(100) & 0xff # Press 'ESC' for exiting video
if k == 27:
break
elif count >= 30: # Take 30 face sample and stop video
break
# Do a bit of cleanup
for line in lines:
source_path = line[2]
filename = source_path.split('/')[-1]
current_path = 'data/IMG/' + filename
image = cv2.imread(current_path)
images.append(image)
measurement = float(line[3]) - correction
measurements.append(measurement)
#Flipping Images and Steering Measurements
augmented_images, augmented_measurements = [],[]
for image, measurement in zip(images, measurements):
augmented_images.append(image)
augmented_measurements.append(measurement)
augmented_images.append(cv2.flip(image,1))
augmented_measurements.append(measurement * -1.0)
##
#X_train = np.array(images)
#Y_train = np.array(measurements)
X_train = np.array(augmented_images)
Y_train = np.array(augmented_measurements)
from keras.models import Sequential
from keras.layers import Flatten, Dense, Lambda
from keras.layers.convolutional import Convolution2D
from keras.layers.pooling import MaxPooling2D
from keras.layers import Cropping2D
from keras.models import Model
import matplotlib.pyplot as plt
def engine():
frame_num = 0
top, right, bottom, left = 10, 350, 225, 590
aWeight = 0.5
capture_video = cv2.VideoCapture(0)
capture_video.set(3, 320)
capture_video.set(4, 240)
width = int(capture_video.get(cv2.CAP_PROP_FRAME_WIDTH) + 0.5)
height = int(capture_video.get(cv2.CAP_PROP_FRAME_HEIGHT) + 0.5)
four_cc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter('output.mp4', four_cc, 20.0, (640, 480))
while (capture_video.isOpened()):
ret, frame = capture_video.read()
if ret == True:
frame = cv2.flip(frame, 1)
frame = imutils.resize(frame, width=640)
frame_cloned = frame.copy()
roi = frame[top:bottom, right:left]
gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
if frame_num < 30:
img_procession.run_avg(gray, aWeight)
else:
hand = img_procession.segment(gray)
horizontal, vertical = img_procession.get_move_direction(gray)
if horizontal == -1:
tmanip.move_left()
elif horizontal == 1:
tmanip.move_right()
if vertical == -1:
tmanip.move_down()
elif vertical == 1:
tmanip.move_up()
if hand is not None:
(threshold, segmented) = hand
cv2.drawContours(frame_cloned, [segmented + (right, top)],
-1, (0, 0, 255))
#cv2.imshow( "Thresholded", threshold )
cv2.rectangle(frame_cloned, (left, top), (right, bottom),
(0, 255, 0), 2)
frame_num += 1
out.write(frame)
#cv2.imshow( 'frame', frame )
if (cv2.waitKey(1) & 0xFF) == ord('q'):
break
else:
print("Error happend. Is camera still working?")
break
out.release()
capture_video.release()
cv2.destroyAllWindows()
def generator(samples, batch_size=32):
num_samples = len(samples)
while 1: # Loop forever so the generator never terminates
shuffle(samples)
for offset in range(0, num_samples, batch_size):
batch_samples = samples[offset:offset+batch_size]
images = []
angles = []
for batch_sample in batch_samples:
name_c = '../data_2/IMG/'+batch_sample[0].split('/')[-1]#center
name_l = '../data_2/IMG/'+batch_sample[1].split('/')[-1]#left
name_r = '../data_2/IMG/'+batch_sample[2].split('/')[-1]#right
center_image = cv2.imread(name_c)
left_image = cv2.imread(name_l)
right_image = cv2.imread(name_r)
#Reorder BGR to RGB
#CV2 import BGR but we infere the steering in RGB
center_image = center_image[:, :, (2, 1, 0)]
left_image = left_image[:, :, (2, 1, 0)]
right_image = right_image[:, :, (2, 1, 0)]
correction = 0.2 # this is a parameter to tune
center_angle = float(batch_sample[3])
left_angle = center_angle + correction
right_angle = center_angle - correction
aug_center_image = []
aug_center_angle = []
aug_right_image = []
aug_right_angle = []
aug_left_image = []
aug_left_angle = []
aug_center_image, aug_center_angle = data_aug(center_image, center_angle)
aug_right_image, aug_right_angle = data_aug(right_image, right_angle)
aug_left_image, aug_left_angle = data_aug(left_image, left_angle)
#aug_center_image = cv2.flip(center_image,1)
#aug_center_angle = center_angle*-1.0
#images.append(center_image)
#angles.append(center_angle)
#images.append(aug_center_image)
#angles.append(aug_center_angle)
# add images and angles to data set
images.append(left_image)
images.append(cv2.flip(left_image,1))
images.append( center_image)
images.append(cv2.flip(center_image,1))
images.append(right_image)
images.append(cv2.flip(right_image,1))
angles.append(left_angle)
angles.append(left_angle*-1.0)
angles.append( center_angle)
angles.append( center_angle*-1.0)
angles.append(right_angle)
angles.append(right_angle*-1.0)
#images.extend(aug_left_image, aug_center_image, aug_right_image)
#angles.extend(aug_left_angle, aug_center_angle, aug_right_angle)
# trim image to only see section with road
X_train = np.array(images)
y_train = np.array(angles)
yield sklearn.utils.shuffle(X_train, y_train)
def recognize():
# Voice Authentication
FORMAT = pyaudio.paInt16
CHANNELS = 2
RATE = 44100
CHUNK = 1024
RECORD_SECONDS = 4
FILENAME = "./test.wav"
audio = pyaudio.PyAudio()
# start Recording
stream = audio.open(format=FORMAT, channels=CHANNELS,
rate=RATE, input=True,
frames_per_buffer=CHUNK)
time.sleep(2.0)
print("recording...")
frames = []
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
data = stream.read(CHUNK)
frames.append(data)
print("finished recording")
# stop Recording
stream.stop_stream()
stream.close()
audio.terminate()
# saving wav file
waveFile = wave.open(FILENAME, 'wb')
waveFile.setnchannels(CHANNELS)
waveFile.setsampwidth(audio.get_sample_size(FORMAT))
waveFile.setframerate(RATE)
waveFile.writeframes(b''.join(frames))
waveFile.close()
modelpath = "./gmm_models/"
gmm_files = [os.path.join(modelpath,fname) for fname in
os.listdir(modelpath) if fname.endswith('.gmm')]
models = [pickle.load(open(fname,'rb')) for fname in gmm_files]
speakers = [fname.split("/")[-1].split(".gmm")[0] for fname
in gmm_files]
if len(models) == 0:
print("No Users in the Database!")
return
#read test file
sr,audio = read(FILENAME)
# extract mfcc features
vector = extract_features(audio,sr)
log_likelihood = np.zeros(len(models))
#checking with each model one by one
for i in range(len(models)):
gmm = models[i]
scores = np.array(gmm.score(vector))
log_likelihood[i] = scores.sum()
pred = np.argmax(log_likelihood)
identity = speakers[pred]
# if voice not recognized than terminate the process
if identity == 'unknown':
print("Not Recognized! Try again...")
return
print( "Recognized as - ", identity)
# face recognition
print("Keep Your face infront of the camera")
cap = cv2.VideoCapture(0)
cap.set(3, 640)
cap.set(4, 480)
cascade = cv2.CascadeClassifier('./haarcascades/haarcascade_frontalface_default.xml')
#loading the database
database = pickle.load(open('face_database/embeddings.pickle', "rb"))
time.sleep(1.0)
start_time = time.time()
while True:
curr_time = time.time()
_, frame = cap.read()
frame = cv2.flip(frame, 1, 0)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
face = cascade.detectMultiScale(gray, 1.3, 5)
name = 'unknown'
if len(face) == 1:
for (x, y, w, h) in face:
roi = frame[y-10:y+h+10, x-10:x+w+10]
fh, fw = roi.shape[:2]
min_dist = 100
#make sure the face is of required height and width
if fh < 20 and fh < 20:
continue
#resizing image as required by the model
img = cv2.resize(roi, (96, 96))
#128 d encodings from pre-trained model
encoding = img_to_encoding(img)
# loop over all the recorded encodings in database
for knownName in database:
# find the similarity between the input encodings and recorded encodings in database using L2 norm
dist = np.linalg.norm(np.subtract(database[knownName], encoding) )
# check if minimum distance or not
if dist < min_dist:
min_dist = dist
name = knownName
# if min dist is less then threshold value and face and voice matched than unlock the door
if min_dist <= 0.4 and name == identity:
print ("Door Unlocked! Welcome " + str(name))
break
#open the cam for 3 seconds
if curr_time - start_time >= 3:
break
cv2.waitKey(1)
cv2.imshow('frame', frame)
cap.release()
cv2.destroyAllWindows()
if len(face) == 0:
print('There was no face found in the frame. Try again...')
elif len(face) > 1:
print("More than one faces found. Try again...")
elif min_dist > 0.4 or name != identity:
print("Not Recognized! Try again...")
def random_horizontal_flip(img, gt, u=0.5):
if np.random.random() < u:
img = cv2.flip(img, 1)
gt = cv2.flip(gt, 1)
return img, gt
_, frame = cap.read()
# Convert BGR to HSV
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# define range of blue color in HSV
lower_blue = np.array([75, 75, 50])
upper_blue = np.array([130, 200, 255])
# Threshold the HSV image to get only blue colors
mask = cv2.inRange(hsv, lower_blue, upper_blue)
# Bitwise-AND mask and original image
res = cv2.bitwise_and(frame, frame, mask=mask)
flip = cv2.flip(frame, 180)
blur = cv2.GaussianBlur(res, (5, 5), 0)
R1.draw()
R1.move()
R2.draw()
R2.move()
R3.draw()
R3.move()
cv2.imshow('frame', flip)
#cv2.imshow('mask',mask)
#cv2.imshow('res',blur)
target_v = 20 if end_dist > 30 else 0
next_a = 1 * (target_v - car.v)
# Stanley Lateral Control
state = {
"x": car.x,
"y": car.y,
"yaw": car.yaw,
"delta": car.delta,
"v": car.v,
"l": car.l,
"dt": car.dt
}
next_delta, target = controller.feedback(state)
car.control(next_a, next_delta)
# Update State & Render
car.update()
img = img_path.copy()
cv2.circle(img, (int(target[0]), int(target[1])), 3, (1, 0.3, 0.7),
2) # target points
img = car.render(img)
img = cv2.flip(img, 0)
cv2.imshow("LQR Control Test", img)
k = cv2.waitKey(1)
if k == ord('r'):
car.init_state(start)
if k == 27:
print()
break
def random_vertical_flip(img, gt, u=0.5):
if np.random.random() < u:
img = cv2.flip(img, 0)
gt = cv2.flip(gt, 0)
return img, gt
def drumbackend(self):
pygame.mixer.music.pause()
lower_red = numpy.array([-10, 100, 100])
upper_red = numpy.array([10, 255, 255])
lower_blue = numpy.array([80, 100, 100])
upper_blue = numpy.array([100, 255, 255])
frequencybeep = 2500 # Set Frequency To 2500 Hertz
durationbeep = 50 # Set Duration To 1000 ms == 1 second
kernelOpen = numpy.ones((10, 10))
kernelClose = numpy.ones((20, 20))
cap = cv2.VideoCapture(0)
cap.set(3, 1920)
cap.set(4, 1080)
retval, frame = cap.read()
runningcam = True
while runningcam:
cv2.flip(frame, 1, frame) #mirror the image
self.screen.fill(0)
retval, frame = cap.read()
frame = numpy.rot90(frame)
frame = numpy.ascontiguousarray(frame, dtype=numpy.uint8)
cv2.rectangle(frame, (450, 200), (550, 300), (0, 255, 0), 2)
cv2.rectangle(frame, (450, 600), (550, 700), (0, 255, 0), 2)
cv2.rectangle(frame, (450, 1000), (550, 1100), (0, 255, 0), 2)
cv2.rectangle(frame, (250, 400), (350, 500), (0, 255, 0), 2)
cv2.rectangle(frame, (250, 800), (350, 900), (0, 255, 0), 2)
frameHSV = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask1 = cv2.inRange(frameHSV, lower_red, upper_red)
mask2 = cv2.inRange(frameHSV, lower_blue, upper_blue)
#res = cv2.bitwise_and(frame,frame, mask= mask1)
maskOpen1 = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, kernelOpen)
maskClose1 = cv2.morphologyEx(maskOpen1, cv2.MORPH_CLOSE,
kernelClose)
maskOpen2 = cv2.morphologyEx(mask2, cv2.MORPH_OPEN, kernelOpen)
maskClose2 = cv2.morphologyEx(maskOpen2, cv2.MORPH_CLOSE,
kernelClose)
maskClose = maskClose1 + maskClose2
maskFinal = maskClose
img, contours, h = cv2.findContours(maskFinal.copy(),
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
for contour in contours:
area = cv2.contourArea(contour)
if area > 1000:
cv2.drawContours(frame, contour, -1, (0, 255, 255), 3)
for i in range(len(contours)):
from playsound import playsound
x, y, w, h = cv2.boundingRect(contour[i])
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3)
#print(x,y)
if x > 450 and y > 200 and x + w < 550 and y + h < 300:
cv2.rectangle(frame, (450, 200), (550, 300), (0, 255, 255),
3)
# from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 1-[AudioTrimmer.com].wav"
)
elif x > 450 and y > 600 and x + w < 550 and y + h < 700:
cv2.rectangle(frame, (450, 600), (550, 700), (0, 255, 255),
3)
# from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 2-[AudioTrimmer.com].wav"
)
elif x > 450 and y > 1000 and x + w < 550 and y + h < 1100:
cv2.rectangle(frame, (450, 1000), (550, 1100),
(0, 255, 255), 3)
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 3-[AudioTrimmer.com].wav"
)
elif x > 250 and y > 400 and x + w < 350 and y + h < 500:
cv2.rectangle(frame, (250, 400), (350, 500), (0, 255, 255),
3)
#from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 4-[AudioTrimmer.com].wav"
)
elif x > 250 and y > 800 and x + w < 350 and y + h < 900:
cv2.rectangle(frame, (250, 800), (350, 900), (0, 255, 255),
3)
#from playsound import playsound
playsound(
"F:\\openCV-jay\\raunak files\\drum\\sound\\sound\\New folder\\New folder\\sound 5-[AudioTrimmer.com].wav"
)
framepygame = frame
framepygame = cv2.cvtColor(framepygame, cv2.COLOR_BGR2RGB)
framepygame = pygame.surfarray.make_surface(framepygame)
framepygame = pygame.transform.scale(framepygame, (1920, 1080))
self.screen.blit(framepygame, (0, 0))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
runningcam = False
cap.release()
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.mixer.music.unpause()
runningcam = False
self.draw()
if event.key == pygame.K_q:
runningcam = False
cap.release()
pygame.quit()
sys.exit()
import numpy as np
import cv2
cap = cv2.VideoCapture(0)
cap.set(3,640) #넓이 설정
cap.set(4,480) #높이 설정
while(True):
ret, frame = cap.read()
frame = cv2.flip(frame, -1) #상하반전
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
cv2.imshow('frame',frame)
cv2.imshow('gray',gray)
k = cv2.waitKey(30) & 0xff
if k == 27: #press 'ESC' to quit
break
cap.release()
cv2.destroyAllWindows()
def do_flip(self, img):
if np.random.rand() > 0.5:
img = cv2.flip(img, 1)
return img
def concatenate_crop_ROI(nb_pixel, delta, fov_oct, Folders, offset, setup):
#concatenate FOVs, then crop ROI
pixel_size = 0.365623 * 10**-6
size_cropping = fov_oct + 2 * delta
n_pixels_map = round(size_cropping / pixel_size)
fov_nh_x, fov_nh_y = compute_fov_nh(pixel_size)
fov_nh_x = nb_pixel['x'] * pixel_size #nh = nighthawk, i.e. high mag
fov_nh_y = nb_pixel['y'] * pixel_size
for filename in tqdm(os.listdir(Folders['lowMag'])):
if filename.startswith('._'):
continue
if 'fluorescent' in filename:
print(filename)
if setup == 1:
low_mag_id_1 = int(filename[1:3]) #along y
low_mag_id_2 = int(filename[4:6]) #along x
elif setup == 2:
low_mag_id_1 = int(filename[1:5]) #along y
low_mag_id_2 = int(filename[6:10]) #along x
full_image_name = str(low_mag_id_1) + '_' + str(low_mag_id_2)
if os.path.exists(Folders['Virtual'] + full_image_name +
'_ch1.png'):
print("skipping")
continue
#here, we apply the offset depending on which part of the scan we are using
#it is a temporary fix until we can to handle the overlap properly
#it needs a bit more thinking
if setup == 2:
y_start = max(
max(low_mag_id_1 * fov_oct - delta, 0) + offset['y'], 0)
x_start = max(low_mag_id_2 * fov_oct - delta, 0) + offset['x']
partnb = 1
elif low_mag_id_2 < 5:
y_start = max(
max(low_mag_id_1 * fov_oct - delta, 0) + offset['y'], 0)
x_start = max(low_mag_id_2 * fov_oct - delta, 0) + offset['x']
partnb = 1
elif low_mag_id_2 > 6:
y_start = max(
max(low_mag_id_1 * fov_oct - delta, 0) + offset['y'],
0) #-offset['y_part2']
x_start = max(low_mag_id_2 * fov_oct - delta,
0) + offset['x'] #-offset['x_part2']
partnb = 2
else:
continue #currently ignoring some files
y_end = y_start + fov_oct + 2 * delta
x_end = x_start + fov_oct + 2 * delta
#loop through the frames
#identify which ones are the limit ones
nb_im_x = 23
print("x_s, x_e: ", x_start, x_end)
print("y_s, y_e: ", y_start, y_end)
for i in range(nb_im_x):
if i * fov_nh_x <= x_start and (i + 1) * fov_nh_x >= x_start:
frame_x_start = i + 1
if i * fov_nh_x <= x_end and (i + 1) * fov_nh_x >= x_end:
frame_x_end = i + 1
if i * fov_nh_y <= y_start and (i + 1) * fov_nh_y >= y_start:
frame_y_start = i + 1
if i * fov_nh_y <= y_end and (i + 1) * fov_nh_y >= y_end:
frame_y_end = i + 1
#compatibility check
if frame_x_start <= 10 and frame_x_end > 10 and setup == 1: #it needs frames from both parths
print(
"This frame has not been neglected, it needs FOVs from both parts!"
)
continue
elif frame_x_start > 10 and partnb == 2 and setup == 1: #we are just changing the name for proper loading, surely to be changed afterwards when dealing with overlap
frame_x_start -= 10
frame_x_end -= 10
#assuming there is an overlap of one row between part 1 and 2
frame_x_start += 1
frame_x_end += 1
#create blank picture
print("frame y start", frame_y_start)
print("frame y end: ", frame_y_end)
print("frame x start: ", frame_x_start)
print("frame x end: ", frame_x_end)
full_image = np.zeros(
(nb_pixel['y'] * (frame_y_end - frame_y_start + 1),
nb_pixel['x'] * (frame_x_end - frame_x_start + 1), 3))
idx_x = np.arange(frame_x_end, frame_x_start - 1, -1)
idx_y = np.arange(frame_y_end, frame_y_start - 1, -1)
#iterate over the different frames making up the tiling
for i in range(idx_x.shape[0]):
for j in range(idx_y.shape[0]):
# filename=str(idx_y[j])+'_'+str(idx_x[i])+'.tif'
key = 'HighMag_part' + str(partnb)
for fnm in os.listdir(Folders[key]):
if fnm.startswith("._"):
continue
if fnm.endswith(".tif"):
nbrs = fnm[-11:-4]
nb1 = int(nbrs[0:3])
nb2 = int(nbrs[4:8])
if setup == 1:
pass #the system is built for that kind of numbering
elif setup == 2: #if the numbering is different
nb2 = 23 - nb2
if nb1 == idx_y[j] and nb2 == idx_x[i]:
filename = fnm
pass
# print("I should have the file corresponding to ", str(idx_y[j])+'_'+str(idx_x[i])+'.tif')
# print("I am loading ",Folders[key]+ filename)
if os.path.exists(Folders[key] + filename):
crt_img = tiff.imread(Folders[key] + filename)
#flip_rotate image here
#much easier, as it does not require you to load and save a large tiff image another time before
img_list = []
for channel in [0, 1, 2]:
img = crt_img[channel, :, :]
if setup == 1:
img = img.transpose()
img = cv2.flip(img, 0)
img = cv2.flip(img, 1)
elif setup == 2:
img = cv2.flip(img, 1)
img = img.transpose()
img_list.append(img)
crt_img = np.dstack(img_list)
else:
print("file does not exist")
continue
# print(crt_img.shape)
nb_pixel['y'] = crt_img.shape[0]
nb_pixel['x'] = crt_img.shape[1]
# print(nb_pixel)
full_image[j * nb_pixel['y']:(j + 1) * nb_pixel['y'],
i * nb_pixel['x']:(i + 1) *
nb_pixel['x'], :] = crt_img
#determine the shift for the crop region
if i == 0 and j == 0:
#this condition is to properly determine what area of the region you want to crop
#super important to have it correctly coded, as otherwise you risk extracting the wrong frames
#in this case we add 10-1 because we did the same thing with the frames above
#to be cleaned and improved
if partnb == 2:
x_start_crt = nb_pixel['x'] * (idx_x[i] - 1 + 10 -
1) * pixel_size
else:
x_start_crt = nb_pixel['x'] * (idx_x[i] -
1) * pixel_size
y_start_crt = nb_pixel['y'] * (idx_y[j] -
1) * pixel_size
x_ref = x_start_crt + nb_pixel['x'] * pixel_size
y_ref = y_start_crt + nb_pixel['y'] * pixel_size
x_idx = int(round((x_ref - x_end) / pixel_size))
y_idx = int(round((y_ref - y_end) / pixel_size))
full_image = full_image[y_idx:y_idx + n_pixels_map,
x_idx:x_idx + n_pixels_map, :]
# tiff.imsave(Folders['Virtual']+full_image_name+'.tif',full_image)
for ch in [0, 1, 2]:
cv2.imwrite(
Folders['Virtual'] + full_image_name + '_ch' + str(ch) +
'.png', full_image[:, :, ch] / 65535 * 255)
else:
continue
def main():
# radius=1,neighbors=1,grid_x=8,grid_y=8,threshold=60
recognizer = cv2.face.LBPHFaceRecognizer_create(radius=1,neighbors=1,grid_x=8,grid_y=8,threshold=60)
recognizer.read('trainer/trainer.yml')
cascadePath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath);
font = cv2.FONT_HERSHEY_SIMPLEX
id = 0
path="dataset\\"
# Initialize and start realtime video capture
cam = cv2.VideoCapture(1)
cam.set(3, 640) # set video widht
cam.set(4, 480) # set video height
# Define min window size to be recognized as a face
minW = 0.1*cam.get(3)
minH = 0.1*cam.get(4)
names=[]
name=faceNames(path)
[names.append(x) for x in name if x not in names]
while True:
ret, img =cam.read()
img = cv2.flip(img, 1) # Flip vertically
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor = 1.2,
minNeighbors = 5,
minSize = (int(minW), int(minH)),
)
for(x,y,w,h) in faces:
cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)
id, confidence = recognizer.predict(gray[y:y+h,x:x+w])
print(id,confidence)
# Check if confidence is less them 100 ==> "0" is perfect match
#confidence=100-confidence
if (confidence < 68):
id = names[id]
#confidence = " {0}%".format(round(100 - confidence))
else:
id = "Tanimsiz"
confidence = " {0}%".format(round(100 - confidence))
cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2)
cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1)
cv2.imshow('camera',img)
k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video
if k == 27:
break
# Do a bit of cleanup
print("\n [BILGI] Programdan Çıkılıyor")
cam.release()
cv2.destroyAllWindows()
def game():
global count_score
#----------------open cv------------------#
cap = cv2.VideoCapture(0)
face_detector = cv2.CascadeClassifier(
r'C:\software\haarcascade_frontalface_default.xml')
cap.set(3, 1280)
cap.set(4, 720)
#-----------------------------------------#
sg.theme('Black')
# define the window layout
layout = [[
sg.Text('TIME : ',
size=(10, 1),
font=('Segoe UI', 20),
text_color='White'),
sg.Text('',
size=(10, 1),
font=('Helvetica', 22),
text_color='White',
key='timer'),
sg.Button('Ball', size=(10, 1), font='Helvetica 14'),
sg.Button('Exit', size=(10, 1), font='Helvetica 14')
],
[
sg.Text('SCORE : ',
size=(10, 1),
font=('Segoe UI', 20),
text_color='White'),
sg.Text('',
size=(10, 1),
font=('Helvetica', 22),
text_color='White',
key='score1')
],
[
sg.T(' '),
sg.Graph(canvas_size=(1280, 720),
graph_bottom_left=(0, 0),
graph_top_right=(400, 400),
key="canvas")
]]
# create the window and show it without the plot
window = sg.Window('OneTouch',
layout,
auto_size_buttons=False,
resizable=False).Finalize()
window.maximize()
canvas = window['canvas']
ball = ball_pysim(canvas)
#-------score-------#
count_score = 0
#-----timer--------#
timer_running = True
seconds = 5
start = time()
current = time()
while True:
circle = canvas.DrawCircle((ball.x, ball.y),
ball.r,
fill_color=ball.color,
line_color='black')
button, values = window.read(timeout=60)
if button == 'Exit':
score()
if button == sg.WIN_CLOSED:
break
if button == 'Ball':
canvas.DeleteFigure(circle)
ball = ball_pysim(canvas)
count_score += 1
window['score1'].update(count_score)
if timer_running:
current = time()
timeleft = int(seconds - (current - start))
window['timer'].update(timeleft)
window.refresh()
if timeleft == 0:
sg.popup("TIME UP")
score()
window.Close()
ret, frame = cap.read()
frame = cv2.flip(frame, 1)
imgbytes = cv2.imencode('.png', frame)[1].tobytes()
canvas.DrawImage(data=imgbytes, location=(0, 400))
window.close()
# Reference: https://docs.opencv.org/3.0-beta/doc/py_tutorials/py_gui/py_video_display/py_video_display.html
# The most of part of the code is from the "Capture Video from Camera" demo. I changed the convert color function
# to the flip function
import numpy as np
import cv2
cap = cv2.VideoCapture(0)
while (True):
# Capture frame-by-frame
ret, frame = cap.read()
# Our operations on the frame come here
gray = cv2.flip(frame, 0)
# Display the resulting frame
cv2.imshow('frame', gray)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
def remove_background(frame):
fgmask = bgModel.apply(frame, learningRate=learningRate)
kernel = np.ones((3, 3), np.uint8)
fgmask = cv2.erode(fgmask, kernel, iterations=1)
res = cv2.bitwise_and(frame, frame, mask=fgmask)
return res
# Camera
camera = cv2.VideoCapture(0)
camera.set(10, 200)
while camera.isOpened():
ret, frame = camera.read()
frame = cv2.bilateralFilter(frame, 5, 50, 100) # smoothing filter
frame = cv2.flip(frame, 1) # flip the frame horizontally
cv2.rectangle(frame, (int(cap_region_x_begin * frame.shape[1]), 0),
(frame.shape[1], int(cap_region_y_end * frame.shape[0])),
(255, 0, 0), 2)
cv2.imshow('original', frame)
# Run once background is captured
if isBgCaptured == 1:
img = remove_background(frame)
img = img[0:int(cap_region_y_end * frame.shape[0]),
int(cap_region_x_begin *
frame.shape[1]):frame.shape[1]] # clip the ROI
cv2.imshow('mask', img)
# convert the image into binary image
