def find_closest_auto(demofile, new_xyz):
if args.parallel:
from joblib import Parallel, delayed
demo_clouds = [asarray(seg["cloud_xyz"]) for seg in demofile.values()]
keys = demofile.keys()
if args.parallel:
costs = Parallel(n_jobs=3,verbose=100)(delayed(registration_cost)(demo_cloud, new_xyz) for demo_cloud in demo_clouds)
else:
costs = []
for (i,ds_cloud) in enumerate(demo_clouds):
costs.append(registration_cost(ds_cloud, new_xyz))
print "completed %i/%i"%(i+1, len(demo_clouds))
print "costs\n",costs
if args.show_neighbors:
nshow = min(5, len(keys))
import cv2, rapprentice.cv_plot_utils as cpu
sortinds = np.argsort(costs)[:nshow]
near_rgbs = [asarray(demofile[keys[i]]["rgb"]) for i in sortinds]
bigimg = cpu.tile_images(near_rgbs, 1, nshow)
cv2.imshow("neighbors", bigimg)
print "press any key to continue"
cv2.waitKey()
ibest = np.argmin(costs)
return keys[ibest]
def image_core(self):
#time1 = time.time()
val,im = self.vid.read()
#cv2.imshow("image2",im)
posX,posY=0,0
if val:
im2=self.image_filter(im)
#r,im1=cv2.threshold(im2,90,255,1)
contours,hierarchy = cv2.findContours(im2,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
print contours
for h,cnt in enumerate(contours):
area = cv2.contourArea(cnt)#error in opencv think of changing version to 2.4.2 (dang) suggest using linux
if area > 1000:
posX = int((cv2.moments(cnt)['m10']) / (cv2.moments(cnt)['m00']))
posY = int((cv2.moments(cnt)['m01']) / (cv2.moments(cnt)['m00']))
'''moments = cv2.moments(cnt)
moment00 = moments['m00']
moment10=moments['m10']
moment01=moments['m01']
posX = int(moment10/moment00)
posY = int(moment01/moment00)'''
cv2.circle(im,(int((posX)),int((posY))),40,(0,0,255),2,1)
cv2.circle(im,(int((posX+5)),int((posY+5))),40,(0,0,255),2,1)
cv2.circle(im,(int((posX-5)),int((posY-5))),40,(0,0,255),2,1)
cv2.circle(im,(int((posX+5)),int((posY-5))),40,(0,0,255),2,1)
cv2.circle(im,(int((posX-5)),int((posY+5))),40,(0,0,255),2,1)
else:
posX,posY=0,0
im1=cv.fromarray(im)
#cv2.imshow("image1",im)
cv2.waitKey(10)
#time2 = time.time()
#print ((time2-time1)*1000.0)
return im1,posX,posY
def captureImage(self):
position = [0, 0]
velocity = [0, 0]
frame = self.cap.read()[1]
if frame != None:
frame = cv2.flip(frame, 1)
self.frame_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
threshold_mask = self.createMultipleThresholds(self.frame_hsv)
contour = self.getLargestContour(threshold_mask)
if type(contour) != int:
cv2.drawContours(frame, contour, -1, (0, 255, 255), 2)
position = self.getContourMoment(contour)
cv2.circle(frame, (position[0], position[1]), 5, (0,0,255), -1)
# calculate velocity
velocity = [position[0] - self.oldPosition[0], position[1] - self.oldPosition[1]]
# print velocity
cv2.imshow("Frame", frame)
cv2.waitKey(10)
self.oldPosition = position
return [position, velocity]
def find_hottest_points(cv_image):
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(3,3))
#gray = clahe.apply(img)
gray = clahe.apply(cv_image)
gray = cv2.GaussianBlur (gray, (21,21), 0)
min_thresh = cv2.threshold(gray, min_th, 255, cv2.THRESH_BINARY)[1]
max_thresh = cv2.threshold(gray, max_th, 255, cv2.THRESH_BINARY_INV)[1]
thresh = cv2.bitwise_and(min_thresh, max_thresh)
thresh = cv2.dilate(thresh, None, iterations = 2)
(cnts, _) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
for c in cnts:
if cv2.contourArea(c) > min_area and cv2.contourArea(c) < max_area:
(x,y,w,h) = cv2.boundingRect(c)
# cv2.rectangle(cv_image, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.rectangle(cv_image, (x, y), (x+w, y+h), 0, 2)
continue
cv2.imshow("region_detector", cv_image)
cv2.moveWindow("region_detector",900,0)
cv2.imshow("band_threshold_image", thresh)
cv2.moveWindow("band_threshold_image",900,400)
cv2.waitKey(1)
def main():
for fname in glob("left/*/*/ein/sceneModel/model.yml"):
print fname
f = open(fname)
lines = []
# ignore the %YAML:1.0, because the python parser doesn't handle 1.0.
f.readline()
for line in f:
# for some reason the python parser doesn't like this line either.
if "background_pose" in line:
continue
lines.append(line)
data = "\n".join(lines)
ymlobject = yaml.load(data)
#print ymlobject
scene = ymlobject["Scene"]
observed_map = GaussianMap.fromYaml(scene["observed_map"])
image = observed_map.toImage()
cv2.imwrite("observed.png", image)
cv2.imshow("observed map", image)
print "observed map: ", observed_map.width, "x", observed_map.height
dimage = readMatFromYaml(scene["discrepancy_magnitude"])
cv2.imshow("discrepancy magnitude", dimage)
cv2.waitKey(0)
cv2.destroyAllWindows()
def main(argv):
args = str(sys.argv[1])
hogParams = {'hitThreshold': -.5, 'scale': 1.05}
hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
video = cv2.VideoCapture(args)
ret, frame = video.read()
while(ret):
cimg = np.copy(frame)
people, w = hog.detectMultiScale(frame, **hogParams)
filetered = []
for ri, r in enumerate(people):
for qi, q in enumerate(people):
if ri != qi and inside(r, q):
print "break"
break
else:
filetered.append(r)
# draw_detections(frame, people)
draw_detections(cimg, filetered, 1)
cv2.imshow('detected people', cimg)
cv2.waitKey(2)
ret, frame = video.read()
cv2.destroyAllWindows()
video.release()
def edge_detect(img):
BLUR_SIZE = 51
TRUNC_RATIO = 0.75
CLOSING_SIZE = 5
# denoised = cv2.fastNlMeansDenoisingColored(img,None,10,10,7,21)
# img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
# too_bright=np.logical_and(img[:,:,1]<50, img[:,:,2]>200)
# np.set_printoptions(threshold=np.nan)
# np.savetxt('conconcon',img[:,:,1],'%i')
# img[:,:,1]=np.where(too_bright, np.sqrt(img[:,:,1])+70, img[:,:,1])
# img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blur = cv2.blur(gray, (BLUR_SIZE, BLUR_SIZE))
edge = np.floor(0.5 * gray + 0.5 * (255 - blur)).astype('uint8')
hist,bins = np.histogram(edge.flatten(), 256, [0, 256])
cdf = hist.cumsum()
cdf_normalized = cdf * hist.max() / cdf.max()
cdf_m = np.ma.masked_equal(cdf, 0)
cdf_m = (cdf_m - cdf_m.min()) * 255 / (cdf_m.max() - cdf_m.min())
cdf = np.ma.filled(cdf_m, 0).astype('uint8')
equ = cdf[edge]
hist,bins = np.histogram(equ.flatten(),256,[0,256])
max_idx = np.argmax(hist);
hist_clean = np.where(equ > TRUNC_RATIO * max_idx, 255, equ)
kernel = np.ones((CLOSING_SIZE, CLOSING_SIZE), np.uint8)
closing = cv2.morphologyEx(hist_clean, cv2.MORPH_CLOSE, kernel)
plt.imshow(closing, cmap='Greys_r')
plt.show()
cv2.waitKey(100)
def draw_motion(self, im=None, draw_outliers=False):
show_image = False
if im is None:
im = self.result_image
show_image = True
if draw_outliers:
print("points shape: " + str(self.prev_points.shape[0]) + " outliers " +
str(self.outliers.shape))
for i in range(0, self.prev_points.shape[0]):
prev_pt = self.prev_points[i]
next_pt = self.next_points[i]
color = np.array([0, 255, 0])
if draw_outliers:
id = 2*i
if (self.outliers[id] or self.outliers[id+1]) and draw_outliers:
color = np.array([0, 0, 255])
else:
color = np.array([0, 255, 0])
cv2.circle(im, (prev_pt[0], prev_pt[1]), 2, color, -1)
cv2.line(im, (prev_pt[0], prev_pt[1]), (next_pt[0], next_pt[1]), np.array([255, 0, 0]), 1)
if show_image:
cv2.imshow("", im)
cv2.waitKey(0)
return im
def main():
# version 3.0.0
# version 2.4.11
print cv2.__version__
imgPlate = cv2.imread('plate_judge.jpg',cv2.IMREAD_COLOR)
PlateLocater.m_debug = False
Result = PlateLocater.fuzzyLocate(imgPlate)
print type(Result)
print '候选车牌数量：',len(Result)
print Result[0].shape
platesJudge(Result)
# imgGray = cv2.cvtColor(imgPlate,cv2.COLOR_BGR2GRAY)
# cv2.imshow('src',imgGray)
# imgEqulhist = cv2.equalizeHist(imgGray)
# cv2.imshow('equal',imgEqulhist)
cv2.waitKey(0)
cv2.destroyAllWindows()
# box = cv2.boxPoints(mr) # if you are use opencv 3.0.0
# box = cv2.cv.boxPoints(mr) # if your are using opencv 2.4.11
# svm 参考
# http://answers.opencv.org/question/5713/save-svm-in-python/
#
# 遇到的问题
# http://answers.opencv.org/question/55152/unable-to-find-knearest-and-svm-functions-in-cv2/
return None
def erode(imageName,iter):
"""Takes image name of image and erodes it"""
image = cv2.imread(imageName)
dilated = cv2.erode(image,None, iterations=iter)
cv2.imshow("OUTPUT", dilated)
cv2.imshow("INPUT", image)
cv2.waitKey(0)
def verb_showfilters(argv):
"""Dump source code of session"""
f = KITNNFile(argv[2])
s = f.getSession(argv[3]).d["snap/1"]
fine = s["data/2" ][...]
medium = s["data/8" ][...]
coarse = s["data/14"][...]
w = 3+(16*7+15*3)+3
h = 3+( 9*7+ 8*3)+3
img= np.zeros((h,w,3), dtype="uint8")
for i in xrange(9):
for j in xrange(16):
n = i*16+j
if i in [0,1,2]:
card = fine [n- 0]
elif i in [3,4,5]:
card = medium[n-48]
elif i in [6,7,8]:
card = coarse[n-96]
card -= np.min(card)
card /= np.max(card)
card = card.transpose(1,2,0)
img[3+i*10:3+i*10+7, 3+j*10:3+j*10+7] = 255*card
img = cv2.resize(img, (0,0), None, 8, 8, cv2.INTER_NEAREST)
cv2.imshow("Filters", img)
cv2.imwrite("Filters.png", img)
cv2.waitKey()
def get_images_and_labels(path):
# Append all the absolute image paths in a list image_paths
# We will not read the image with the .sad (the sad face) extension in the training set
# Rather, we will use them to test our accuracy of the training
image_paths = [os.path.join(path, f) for f in os.listdir(path)]
# images will contains face images
images = []
# labels will contains the label that is assigned to the image
labels = []
for image_path in image_paths:
# Read the image and convert to grayscale
image_pil = Image.open(image_path).convert('L')
# Convert the image format into numpy array
image = np.array(image_pil, 'uint8')
# Get the label of the image
nbr = int(os.path.split(image_path)[1].split(".")[0].replace("subject",""))
# Detect the face in the image
faces = faceCascade.detectMultiScale(frame,
scaleFactor=1.5,
minNeighbors=6,
minSize=(30, 30),
flags = cv2.cv.CV_HAAR_SCALE_IMAGE)
# If face is detected, append the face to images and the label to labels
for (x, y, w, h) in faces:
images.append(image[y: y + h, x: x + w])
labels.append(nbr)
cv2.imshow("Adding faces to traning set...", image[y: y + h, x: x + w])
cv2.waitKey(50)
# return the images list and labels list
return images, labels
def coolBlack():
IMAGE_WEIGHT = 0.5
image = cv2.imread("G:/Filters/wasim.jpg",0)
black = cv2.imread("G:/Filters/black5.jpg",0)
black = cv2.resize(black, image.shape[::-1])
res1 = cv2.addWeighted(image, IMAGE_WEIGHT, black, 1 - IMAGE_WEIGHT, 1)
#NORMALIZE IMAGES
image = np.float32(image)
black = np.float32(black)
image /= 255
black /= 200
res = image*black
cv2.imshow("RES", res)
cv2.waitKey(0)
fname = "G:/Filtes/temp.jpg"
cv2.imwrite(fname, res)
res = cv2.imread(fname, 0)
cv2.imshow("BLACK", res)
cv2.waitKey(0)
def object_detection(self, depth_array):
"""
Function to detect objects from the depth image given
:return:
"""
self.detect_arm()
# Perform thresholding on the image to remove all objects behind a plain
ret, bin_img = cv2.threshold(depth_array, 0.3, 1, cv2.THRESH_BINARY_INV)
# Erode the image a few times in order to separate close objects
element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
err_img = cv2.erode(bin_img, element, iterations=20)
# Create a new array of type uint8 for the findContours function
con_img = np.array(err_img, dtype=np.uint8)
# Find the contours of the image and then draw them on
contours, hierarchy = cv2.findContours(con_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(con_img, contours, -1, (128, 255, 0), 3)
for x in range(0, len(contours)):
x, y, w, h = cv2.boundingRect(contours[x])
cv2.rectangle(con_img, (x, y), ((x+w), (y+h)), (255, 0, 127), thickness=5, lineType=8, shift=0)
# Show the colour images of the objects
# self.show_colour(contours)
# Show the Depth image and objects images
cv2.imshow('Contours', con_img)
cv2.imshow("Depth", bin_img)
cv2.waitKey(3)
def show_colour(self, cnt):
"""
Use the objects found to show them in colour
:return:
"""
# Go through each rectangle and display the rgb
length = len(cnt)
# Create an array of size the amount of rectangles
crop_rgb = []
for i in range(0, length):
crop_rgb.append(1)
for x in range(0, length):
x, y, w, h = cv2.boundingRect(cnt[x])
# Try to crop the rgb image for each box
try:
crop_rgb[x] = self.rgb_img[y:y+h, x:x+w]
except:
pass
for x in range(0, length):
name = "Cropped " + str(x)
cv2.imshow(name, crop_rgb[x])
cv2.waitKey(3)
def CLQFilterDemo(self, img):
# Constrained least square filter
img = np.int16(img)
noise = self.noiseGenerator.GuassNoise(img, 0, 10, np.int32(img.size))
nImg = img + noise
H = self.GenerateHDemo(img.shape)
fImg = np.fft.fftshift(np.fft.fft2(img))
gImg = np.fft.ifft2(np.fft.ifftshift(fImg * H))
gImg += noise
fgImg = np.fft.fftshift(np.fft.fft2(gImg))
gamma = 0.3
l = np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]])
p = np.zeros(img.shape)
p[0:3, 0:3] = l
P = np.fft.fftshift(np.fft.fft2(p))
N = 512 * 512 * (np.std(noise) ** 2.0 - np.mean(noise) ** 2.0)
a = 0.1
ggImg = self.CLSFilterOptimal(fgImg, gamma, H, P, N, a)
#ggImg = self.CLSFilter(fgImg, gamma, H, P)
cv2.namedWindow("orig")
cv2.imshow("orig", np.uint8(img))
cv2.namedWindow("g")
cv2.imshow("g", np.uint8(gImg))
cv2.namedWindow("CLQ filter restore")
cv2.imshow("CLQ filter restore", np.uint8(ggImg))
cv2.waitKey(0)
def dewarp(imagedir):
# Loading from json file
C = CameraParams.fromfile(os.path.join(imagedir, "params.json"))
K = C.K
D = C.D
print("Loaded camera parameters from " + os.path.join(imagedir, "params.json"))
for f in file_list(imagedir, ['jpg', 'jpeg', 'png']):
print(f)
colour = cv2.imread(f)
grey = cv2.cvtColor(colour, cv2.COLOR_BGR2GRAY)
h, w = grey.shape[:2]
newcameramtx, roi=cv2.getOptimalNewCameraMatrix(K, D, (w,h), 1, (w,h))
mapx, mapy = cv2.initUndistortRectifyMap(K, D, None, newcameramtx, (w,h), 5)
dewarped = cv2.remap(grey, mapx, mapy, cv2.INTER_LINEAR)
x, y, w, h = roi
dewarped = dewarped[y:y+h, x:x+w]
grey = cv2.resize(grey, (0,0), fx=0.5, fy=0.5)
dewarped = cv2.resize(dewarped, (0,0), fx=0.5, fy=0.5)
cv2.imshow("Original", grey )
cv2.imshow("Dewarped", dewarped)
cv2.waitKey(-1)
def realisticTexturemap(H_G_M, scale):
map_img = cv2.imread('Images/ITUMap.bmp')
point = getMousePointsForImageWithParameter(map_img, 1)[0]
texture = cv2.imread('Images/ITULogo.jpg')
#texture = cv2.cvtColor(texture,cv2.COLOR_BGR2GRAY)
H_T_M = np.zeros(9).reshape(3,3)
H_T_M[0][0] = scale
H_T_M[1][1] = scale
H_T_M[0][2] = point[0]
H_T_M[1][2] = point[1]
H_T_M[2][2] = 1
H_M_G = np.linalg.inv(H_G_M)
H_T_G = np.dot(H_M_G, H_T_M)
fn = "GroundFloorData/sunclipds.avi"
cap = cv2.VideoCapture(fn)
#load Tracking data
running, frame = cap.read()
while running:
running, frame = cap.read()
h,w,d = frame.shape
warped_texture = cv2.warpPerspective(texture, H_T_G,(w, h))
result = cv2.addWeighted(frame, .6, warped_texture, .4, 50)
cv2.imshow("Result", result)
cv2.waitKey(0)
def textureMapGroundFloor():
#create H_T_G from first frame of sequence
texture = cv2.imread('Images/ITULogo.jpg')
fn = "GroundFloorData/sunclipds.avi"
sequence = cv2.VideoCapture(fn)
running, frame = sequence.read()
h_t_g, calibration_points = SIGBTools.getHomographyFromMouse(texture, frame, -4)
print h_t_g
#fig = figure()
while running:
running, frame = sequence.read()
if not running:
return
#texture map
h,w,d = frame.shape
warped_texture = cv2.warpPerspective(texture, h_t_g,(w, h))
result = cv2.addWeighted(frame, .7, warped_texture, .3, 50)
#display
cv2.imshow("Texture Mapping", result)
cv2.waitKey(1)
def locate_thumbnail(thumbnail_filename, source_filename, display=False, save_visualization=False,
save_reconstruction=False, reconstruction_format="jpg"):
thumbnail_basename, thumbnail_image = open_image(thumbnail_filename)
source_basename, source_image = open_image(source_filename)
logging.info("Attempting to locate %s within %s", thumbnail_filename, source_filename)
kp_pairs = match_images(thumbnail_image, source_image)
if len(kp_pairs) >= 4:
title = "Found %d matches" % len(kp_pairs)
logging.info(title)
H, mask = find_homography(kp_pairs)
new_thumbnail, corners, rotation = reconstruct_thumbnail(thumbnail_image, source_image, kp_pairs, H)
print(json.dumps({
"master": {
"source": source_filename,
"dimensions": {
"height": source_image.shape[0],
"width": source_image.shape[1],
}
},
"thumbnail": {
"source": thumbnail_filename,
"dimensions": {
"height": thumbnail_image.shape[0],
"width": thumbnail_image.shape[1],
}
},
"bounding_box": {
"height": corners[0][1] - corners[0][0],
"width": corners[1][1] - corners[1][0],
"x": corners[1][0],
"y": corners[0][0],
},
"rotation_degrees": rotation
}))
if save_reconstruction:
new_filename = "%s.reconstructed.%s" % (thumbnail_basename, reconstruction_format)
cv2.imwrite(new_filename, new_thumbnail)
logging.info("Saved reconstructed thumbnail %s", new_filename)
else:
logging.warning("Found only %d matches; skipping reconstruction", len(kp_pairs))
new_thumbnail = corners = H = mask = None
if display or save_visualization:
vis_image = visualize_matches(source_image, thumbnail_image, new_thumbnail, corners, kp_pairs, mask)
if save_visualization:
vis_filename = "%s.visualized%s" % os.path.splitext(thumbnail_filename)
cv2.imwrite(vis_filename, vis_image)
logging.info("Saved match visualization %s", vis_filename)
if display:
cv2.imshow(title, vis_image)
cv2.waitKey()
cv2.destroyAllWindows()
def calibrateSharpening():
frame = cv2.imread("failed_frame_224.png")
new_frame = sharpen(frame)
found, _ = cv2.findChessboardCorners(new_frame, (9,6))
print found
cv2.imshow("sharpened", new_frame)
cv2.waitKey(0)
def _generate_training_set(img, image_file):
save_location = "images/training/"
_, img = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV)
_, regions = cv2.connectedComponents(img, img)
if not os.path.exists("../images/cc"):
os.makedirs("../images/cc")
cv2.imwrite("../images/cc/cc.png", regions)
cc = cv2.imread("../images/cc/cc.png", 0)
_, cc_vis = cv2.threshold(cc, 1, 255, cv2.THRESH_BINARY)
_, contours, hierarchy = cv2.findContours(cc_vis, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
idx = 0
for cnt in contours:
area = cv2.contourArea(cnt)
if area < 50 or area > 1000:
continue
if len(cnt) < 5:
continue
idx += 1
x, y, w, h = cv2.boundingRect(cnt)
roi = img[y: y + h, x: x + w]
name = image_file.split('.')[0]
inverted = (255 - roi)
cv2.imwrite(save_location + name + str(idx) + '.jpg', inverted)
cv2.waitKey(0)
def camactivate ():
with picamera.PiCamera() as camera:
camera.resolution = (512,512)
time.sleep(2)
camera.capture('im1.jpg')
time.sleep(2)
camera.capture('im2.jpg')
time.sleep(2)
camera.capture('im3.jpg')
time.sleep(2)
camera.capture('im4.jpg')
im1=cv2.imread('im1.jpg',1)
im2=cv2.imread('im2.jpg',1)
im3=cv2.imread('im3.jpg',1)
im4=cv2.imread('im4.jpg',1)
cv2.putText(im1,'Cam1',(10,20),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)
cv2.putText(im2,'Cam2',(10,20),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)
cv2.putText(im3,'Cam3',(10,20),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)
cv2.putText(im4,'Cam4',(10,20),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)
cv2.namedWindow('Catenated Images',cv2.WINDOW_NORMAL)
concat=np.zeros((1024,1024,3),np.uint8)
concat[0:512,0:512,:]=im1
concat[0:512,512:1024,:]=im2
concat[512:1024,0:512,:]=im3
concat[512:1024,512:1024,:]=im4
cv2.imshow('Catenated Images',concat)
cv2.imwrite('concat.jpg',concat)
cv2.waitKey(0)
def detect_face(MaybeImage):
if MaybeImage.success:
image = MaybeImage.result
else:
return MaybeImage
# Make image grayscale for processing
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Detect faces in the image
# faces will be an iterable object
faces = faceCascade.detectMultiScale(
image=gray_image,
scaleFactor=1.1,
minNeighbors=5,
minSize=(40, 40),
flags = cv2.cv.CV_HAAR_SCALE_IMAGE
)
if len(faces) == 1:
face = faces[0]
return Maybe(True, face)
else:
# If we're run as main we can show a box around the faces.
# Otherwise it's nicer if we just spit out an error message.
if __name__ == '__main__':
# Draw a box around the faces
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.imshow("{:d} Faces found. Remove other faces. Press any key to quit.".format(len(faces)) ,image)
cv2.waitKey(0)
return Maybe(False, "Expected 1 face, found {:d} faces. Please make sure your face is in frame, and remove any other things detected as a face from the frame.".format(len(faces)))
def display( self ):
'''显示图片(须先analyze)'''
if (self.test_image == None):
raise Exception('The image is not tested')
cv2.namedWindow("Image")
cv2.imshow("Image", self.test_image)
cv2.waitKey (0)
def draw_walls(self):
left_wall_points = np.array([self.transform(point) for point in self.left_wall_points])
right_wall_points = np.array([self.transform(point) for point in self.right_wall_points])
rect = cv2.minAreaRect(left_wall_points[:,:2].astype(np.float32))
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)
cv2.drawContours(self.grid, [box], 0, 128, -1)
rect = cv2.minAreaRect(right_wall_points[:,:2].astype(np.float32))
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)
cv2.drawContours(self.grid, [box], 0, 128, -1)
# So I dont have to comment abunch of stuff out for debugging
dont_display = True
if dont_display:
return
# Bob Ross it up (just for display)
left_f, right_f = self.transform(self.left_f), self.transform(self.right_f)
left_b, right_b = self.transform(self.left_b), self.transform(self.right_b)
boat = self.transform(self.boat_pos)
target = self.transform(self.target)
cv2.circle(self.grid, tuple(boat[:2].astype(np.int32)), 8, 255)
cv2.circle(self.grid, tuple(target[:2].astype(np.int32)), 15, 255)
cv2.circle(self.grid, tuple(self.transform(self.mid_point)[:2].astype(np.int32)), 5, 255)
cv2.circle(self.grid, tuple(left_f[:2].astype(np.int32)), 10, 255)
cv2.circle(self.grid, tuple(right_f[:2].astype(np.int32)), 10, 255)
cv2.circle(self.grid, tuple(left_b[:2].astype(np.int32)), 3, 125)
cv2.circle(self.grid, tuple(right_b[:2].astype(np.int32)), 3, 128)
cv2.imshow("test", self.grid)
cv2.waitKey(0)
def listener():
global fnobj
rospy.init_node('reconocimiento', anonymous=True)
rospy.Subscriber("chatter", coordenadas, callback)
rate = rospy.Rate(50) #hz
cap = cv2.VideoCapture(0)
fnobj = 'logo.png'
opts, args = getopt.getopt(sys.argv[1:], '', ['feature='])
opts = dict(opts)
feature_name = opts.get('--feature', 'sift')
while not rospy.is_shutdown():
ret, frame = cap.read()
crop_img = frame[y:h,x:w]
cv2.imwrite("full.png",crop_img)
img1 = cv2.imread('full.png',0)
img2 = cv2.imread(fnobj, 0)
detector, matcher = init_feature(feature_name)
if detector != None:
print 'usando', feature_name
else:
print 'unknown feature:', feature_name
sys.exit(1)
kp1, desc1 = detector.detectAndCompute(img1, None)
kp2, desc2 = detector.detectAndCompute(img2, None)
print 'img1 - %d features, img2 - %d features' % (len(kp1), len(kp2))
match_and_draw('analisis', matcher,desc1,desc2,kp1,kp2,img1,img2)
cv2.waitKey(1)
def show_results(self, image, results, imshow=True, deteted_boxes_file=None,
detected_image_file=None):
"""Show the detection boxes"""
img_cp = image.copy()
if deteted_boxes_file:
f = open(deteted_boxes_file, "w")
# draw boxes
for i in range(len(results)):
x = int(results[i][1])
y = int(results[i][2])
w = int(results[i][3]) // 2
h = int(results[i][4]) // 2
if self.verbose:
print(" class: %s, [x, y, w, h]=[%d, %d, %d, %d], confidence=%f" % (results[i][0],
x, y, w, h, results[i][-1]))
cv2.rectangle(img_cp, (x - w, y - h), (x + w, y + h), (0, 255, 0), 2)
cv2.rectangle(img_cp, (x - w, y - h - 20), (x + w, y - h), (125, 125, 125), -1)
cv2.putText(img_cp, results[i][0] + ' : %.2f' % results[i][5], (x - w + 5, y - h - 7),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)
if deteted_boxes_file:
f.write(results[i][0] + ',' + str(x) + ',' + str(y) + ',' +
str(w) + ',' + str(h)+',' + str(results[i][5]) + '\n')
if imshow:
cv2.imshow('YOLO_small detection', img_cp)
cv2.waitKey(1)
if detected_image_file:
cv2.imwrite(detected_image_file, img_cp)
if deteted_boxes_file:
f.close()
def test_color_block_finder_01():
'''
色块识别测试样例1 从图片中读取并且识别
'''
# 图片路径
img_path = "demo-pic.png"
# 颜色阈值下界(HSV) lower boudnary
lowerb = (96, 210, 85)
# 颜色阈值上界(HSV) upper boundary
upperb = (114, 255, 231)
# 读入素材图片 BGR
img = cv2.imread(img_path, cv2.IMREAD_COLOR)
# 检查图片是否读取成功
if img is None:
print("Error: 请检查图片文件路径")
exit(1)
# 识别色块 获取矩形区域数组
rects = color_block_finder(img, lowerb, upperb)
# 绘制色块的矩形区域
canvas = draw_color_block_rect(img, rects)
# 在HighGUI窗口 展示最终结果
cv2.namedWindow('result', flags=cv2.WINDOW_NORMAL | cv2.WINDOW_FREERATIO)
cv2.imshow('result', canvas)
# 等待任意按键按下
cv2.waitKey(0)
# 关闭其他窗口
cv2.destroyAllWindows()
def main():
imgOriginal = cv2.imread(r'C:\Users\dbsnail\ImageFolder\images.jpg') # open image
if imgOriginal is None: # if image was not read successfully
print "error: image not read from file \n\n" # print error message to std out
os.system("pause") # pause so user can see error message
return # and exit function (which exits program)
imgGrayscale = cv2.cvtColor(imgOriginal, cv2.COLOR_BGR2GRAY) # convert to grayscale
imgBlurred = cv2.GaussianBlur(imgGrayscale, (5, 5), 0) # blur
imgCanny = cv2.Canny(imgBlurred, 100, 200) # get Canny edges
cv2.namedWindow("imgOriginal", cv2.WINDOW_AUTOSIZE) # create windows, use WINDOW_AUTOSIZE for a fixed window size
cv2.namedWindow("imgCanny", cv2.WINDOW_AUTOSIZE) # or use WINDOW_NORMAL to allow window resizing
cv2.imshow("imgOriginal", imgOriginal) # show windows
cv2.imshow("imgCanny", imgCanny)
cv2.waitKey() # hold windows open until user presses a key
cv2.destroyAllWindows() # remove windows from memory
return
coords[i] = (x, y)
i + 1
# for index in range(len(coords2[e]):
# print(e,":",coords2, sep = "\n")
#nose
coords3 = np.zeros((68, 2), dtype="float")
print(coords3)
for f in range(27, 35):
x = float(landmarks.part(f).x / width)
y = float(landmarks.part(f).y / height)
coords3[f] = (x, y)
#for index in range(len(coords3[f]):
# print(f,":",coords3, sep = "\n")
#mouth
coords4 = np.zeros((68, 2), dtype="float")
for g in range(48, 59):
x = float(landmarks.part(g).x / width)
y = float(landmarks.part(g).y / height)
coords4[f] = (x, y)
#for index in range(len(coords4[f]):
# print(g,":",coords4, sep = "\n")
elif nrFace <= 0:
print("no faces found")
if cv2.waitKey(0):
cv2.destroyAllWindows()
import cv2
import time
fire_cascade = cv2.CascadeClassifier('fire_detection.xml')
#fire_detection.xml file & this code should be in the same folder while running the code
cap = cv2.VideoCapture(0)
while 1:
#ser1.write('0')
ret, img = cap.read()
#cv2.imshow('imgorignal',img)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
fire = fire_cascade.detectMultiScale(img, 1.2, 5)
for (x, y, w, h) in fire:
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 2)
roi_gray = gray[y:y + h, x:x + w]
roi_color = img[y:y + h, x:x + w]
print('Fire is detected..!')
time.sleep(0.2)
cv2.imshow('img', img)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
print("Predicting images...")
# load test images
test_img1 = cv2.imread("test-data/test1.JPG")
test_img2 = cv2.imread("test-data/test2.jpg")
test_img3 = cv2.imread("test-data/test3.JPG")
# perform a prediction
predicted_img1 = predict(test_img1)
predicted_img2 = predict(test_img2)
predicted_img3 = predict(test_img3)
print("Prediction complete")
# display both images
# cv2.imshow(subjects[1], predicted_img1)
# cv2.imshow(subjects[2], predicted_img2)
titles = [subjects[1], subjects[2], subjects[3]]
images = [predicted_img1, predicted_img2, predicted_img3]
for i in range(3):
plt.subplot(3, 3, i + 1), plt.imshow(images[i], 'gray')
plt.title(titles[i])
plt.xticks([]), plt.yticks([])
plt.show()
cv2.waitKey(0)
cv2.destroyAllWindows()
def superm2(image):
mimage = np.fliplr(image)
kp1, des1 = sift.detectAndCompute(image, None)
kp2, des2 = sift.detectAndCompute(mimage, None)
for p, mp in zip(kp1, kp2):
p.angle = np.deg2rad(p.angle)
mp.angle = np.deg2rad(mp.angle)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
houghr = np.zeros(len(matches))
houghth = np.zeros(len(matches))
weights = np.zeros(len(matches))
i = 0
good = []
for match, match2 in matches:
point = kp1[match.queryIdx]
mirpoint = kp2[match.trainIdx]
mirpoint2 = kp2[match2.trainIdx]
mirpoint2.angle = np.pi - mirpoint2.angle
mirpoint.angle = np.pi - mirpoint.angle
if mirpoint.angle < 0.0:
mirpoint.angle += 2 * np.pi
if mirpoint2.angle < 0.0:
mirpoint2.angle += 2 * np.pi
mirpoint.pt = (mimage.shape[1] - mirpoint.pt[0], mirpoint.pt[1])
if very_close(point.pt, mirpoint.pt):
mirpoint = mirpoint2
good.append(match2)
else:
good.append(match)
theta = angle_with_x_axis(point.pt, mirpoint.pt)
xc, yc = midpoint(point.pt, mirpoint.pt)
r = xc * np.cos(theta) + yc * np.sin(theta)
Mij = reisfeld(point.angle, mirpoint.angle, theta) * S(
point.size, mirpoint.size
)
houghr[i] = r
houghth[i] = theta
weights[i] = Mij
i += 1
# matches = sorted(matches, key = lambda x:x.distance)
good = sorted(good, key=lambda x: x.distance)
def draw(r, theta):
if np.pi / 4 < theta < 3 * (np.pi / 4):
for x in range(len(image.T)):
y = int((r - x * np.cos(theta)) / np.sin(theta))
if 0 <= y < len(image.T[x]):
image[y][x] = 255
else:
for y in range(len(image)):
x = int((r - y * np.sin(theta)) / np.cos(theta))
if 0 <= x < len(image[y]):
image[y][x] = 255
print(houghr)
print(houghth)
img3 = cv2.drawMatches(image, kp1, mimage, kp2, good[:15], None, flags=2)
def hex():
polys = plt.hexbin(houghr, houghth, bins=200, gridsize=image.shape[1])
# plt.colorbar()
# plt.show()
hvals = polys.get_array()
hcoords = polys.get_offsets()
return hcoords[hvals.argmax()]
best_coords = hex()
print(best_coords)
# draw(2.8, 2.4)
draw(*best_coords)
cv2.imshow('a', image); cv2.waitKey(0);
if len(contours)>0:
centroid=max(contours,key=cv2.contourArea) #Kontuar alanı belirleniyor.
M=cv2.moments(centroid)
area=cv2.contourArea(centroid)
if area>3000:
cx=int(M['m10']/M['m00']) #x koordinatını ve y koordinatını buluyoruz.
cy=int(M['m01']/M['m00'])
cv2.line(image,(cx,0),(cx,720),(255,0,0),1) #bulunan bu koordinatlara göre görüntüde line çiziliyor.
cv2.line(image,(0,cy),(1280,cy),(255,0,0),1)
cv2.line(image,(320,0),(320,640),(255,0,0),1)
cv2.circle(image,(cx,cy),3,(0,0,255),-1)
cv2.drawContours(image,contours,-1,(0,255,0),2) #Kontuar alanı çiziliyor
if cx<500:
print("sag yap") #Referans değeri(x koordinatı) 500 den küçük ise sağa dön
if cx>520:
print("SOL YAP") #Referans değeri(y koordinatı) 520 den büyük ise sola dön
if 500<cx<520:
print("Duz gıt") #Referans değeri(x-y koordinatı) 500 ile 520 arasında ise düz git
cv2.imshow('İşlenmiş Görüntü',image) #işleme yaptığımız görüntülerin framelerini yansıtıyoruz
cv2.imshow('th1',th1)
cv2.imshow('th2',th2)
cv2.imshow("input", res)
key = cv2.waitKey(10) #'ESC' ye basıldıysa bütün frameleri kapat
if key == 27:
break
cv2.destroyAllWindows() #Bütün ekranları öldür.
cv2.VideoCapture(0).release() # video yakalamyı kapat
thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
#Inflate the image to find the location of the difference
thresh = cv2.dilate(thresh, None, iterations=2)
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if imutils.is_cv2() else cnts[1]
for c in cnts:
if cv2.contourArea(c) < args["min_area"]:
continue
(x, y, w, h) = cv2.boundingRect(c)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
text = "Occupied"
#
cv2.putText(frame, "Room Status: {}".format(text), (10, 20),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
cv2.putText(frame, datetime.datetime.now().strftime("%A %d %B %Y %I:%M:%S%p"),
(10, frame.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 0, 255), 1)
cv2.imshow("Security Feed", frame)
cv2.imshow("Thresh", thresh)
cv2.imshow("Frame Delta", frameDelta)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
vs.stop() if args.get("video", None) is None else vs.release()
cv2.destroyAllWindows()
inHeight = 400
inWidth = int(((aspect_ratio*inHeight)*8)//8)
vid_writer = cv2.VideoWriter('output.avi',cv2.VideoWriter_fourcc('M','J','P','G'), 15, (frame.shape[1],frame.shape[0]))
net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)
k = 0
while 1:
background = cv2.imread('back.jpg')
background = cv2.resize(background, (inWidth, inHeight))
k+=1
t = time.time()
hasFrame, frame = cap.read()
frameCopy = np.copy(frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
cap.release()
break
inpBlob = cv2.dnn.blobFromImage(frame, 1.0 / 255, (inWidth, inHeight),
(0, 0, 0), swapRB=False, crop=False)
net.setInput(inpBlob)
output = net.forward()
print("forward = {}".format(time.time() - t))
# Empty list to store the detected keypoints
points = []
drawPred(classIds[i], confidences[i], left, top, left + width,
top + height)
if (args.video):
outputFile = "output/yolo_output.avi"
cap = cv2.VideoCapture(args.video)
else:
cap = cv2.VideoCapture(0)
vid_writer = cv2.VideoWriter(outputFile,
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30,
(round(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
round(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))))
while cv2.waitKey(1) < 0:
hasFrame, frame = cap.read()
if not hasFrame:
print('DOne!!')
print("Output file is stored as ", outputFile)
cv2.waitKey(3000)
break
blob = cv2.dnn.blobFromImage(frame,
1 / 255, (INP_WIDTH, INP_HEIGHT), [0, 0, 0],
1,
crop=False)
#SETS THE INPUTS FOR THE DARKNET NETWORK
net.setInput(blob)
import cv2
import numpy as np
kamera=cv2.VideoCapture(0)
while True:
ret,kare=kamera.read() #kameranın çalışıp çalışmadığını kontrol eder.
bolge=kare[0:200,0:200]
cv2.imshow("Video",kare)
cv2.imshow("Bolge",bolge)
if cv2.waitKey(25) & 0xFF ==('q'):
break
kamera.release()
cv2.destroyAllWindows()
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 5 09:17:31 2021
@author: Aditya Manwar
"""
import cv2
from pyzbar import pyzbar
import numpy as np
cap = cv2.VideoCapture(0)
font = cv2.FONT_HERSHEY_PLAIN
while True:
_, frame = cap.read()
decodedObj = pyzbar.decode(frame)
for obj in decodedObj:
print("Data", obj.data)
cv2.putText(frame, str(obj.data), (50,50), font, 3, (255,0,0),3)
cv2.imshow('Frame',frame)
key = cv2.waitKey(1)
if key == 27:
break
raise ("IO Error")
#cv2.namedWindow("Capture", cv2.WINDOW_AUTOSIZE)
sensor = Sensor('EdgeSensor')
feature1 = Feature('F1', sensor, [[0, 0, 1], [0, 1, 0], [1, 0, 0]])
feature2 = Feature('F2', sensor, [[0, 0, 0], [1, 1, 1], [0, 0, 0]])
#feature3 = Feature('F3',sensor,[[0,1,0],[1,1,1],[0,1,0]])
feature4 = Feature('F4', sensor, [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
feature5 = Feature('F5', sensor, [[0, 1, 0], [0, 1, 0], [0, 1, 0]])
sensor.addFeature(feature1)
sensor.addFeature(feature2)
#sensor.addFeature(feature3)
sensor.addFeature(feature4)
sensor.addFeature(feature5)
x = 200
cv2.namedWindow("Sensor")
cv2.moveWindow("Sensor", 40, 530)
while True:
ret, image = capture.read()
if ret == False:
continue
height, width, channels = image.shape
sensor.read(image)
cv2.imshow("World", sensor.world)
sensor.run()
cv2.imshow("Sensor", sensor.output)
if cv2.waitKey(33) >= 0:
break
cv2.destroyAllWindows()
xmax = int(min(imW,(boxes[i][3] * imW)))
cv2.rectangle(frame, (xmin,ymin), (xmax,ymax), (10, 255, 0), 2)
# Draw label
object_name = labels[int(classes[i])] # Look up object name from "labels" array using class index
label = '%s: %d%%' % (object_name, int(scores[i]*100)) # Example: 'person: 72%'
labelSize, baseLine = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2) # Get font size
label_ymin = max(ymin, labelSize[1] + 10) # Make sure not to draw label too close to top of window
cv2.rectangle(frame, (xmin, label_ymin-labelSize[1]-10), (xmin+labelSize[0], label_ymin+baseLine-10), (255, 255, 255), cv2.FILLED) # Draw white box to put label text in
cv2.putText(frame, label, (xmin, label_ymin-7), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2) # Draw label text
# Draw framerate in corner of frame
cv2.putText(frame,'FPS: {0:.2f}'.format(frame_rate_calc),(30,50),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,0),2,cv2.LINE_AA)
# All the results have been drawn on the frame, so it's time to display it.
cv2.imshow('Object detector', frame)
# Calculate framerate
t2 = cv2.getTickCount()
time1 = (t2-t1)/freq
frame_rate_calc= 1/time1
# Press 'q' to quit
if cv2.waitKey(1) == ord('q'):
break
# Clean up
cv2.destroyAllWindows()
videostream.stop()
nearDistance = distance
lightSource = image[y:y + h, x:x + w]
if (nearX>0 or nearY>0) and nearDistance>10:
cv2.rectangle(image,(nearX,nearY),(nearX+nearW,nearY+nearH),(0,255,0),2)
cv2.line(image,(nearX+nearW/2,nearY+nearH),(refPtX,refPtY),(0,255,0))
moveMotor(getAngle((nearX+nearW/2),(nearY+nearH/2),refPtX,refPtY))
# frame = cv2.bitwise_and(frame, mask)
cv2.imshow("Canny", canny)
cv2.imshow("Frame", image)
cv2.imshow("Gray", gray)
cv2.imshow("Thresh", thresh)
# if the 'q' key is pressed, stop the loop
if cv2.waitKey(1) & 0xFF == ord("q"):
break
except KeyboardInterrupt:
# code you want to run before the program
# exits when you press CTRL+C
print "\n\n Keyboard interrupt detected"
# except:
# catches ALL other exceptions including errors.
# won't get any error messages for debugging
# so only use it once your code is working
# print "Other error or exception occurred!"
finally:
print "\n Cleanup GPIO"
def run(self):
args, video_src = getopt.getopt(sys.argv[1:], '', ['cascade=', 'nested-cascade='])
try:
video_src = video_src[0]
except:
video_src = 0
args = dict(args)
cascade_fn = args.get('--cascade', "data/haarcascades/haarcascade_frontalface_alt.xml")
cascade = cv.CascadeClassifier(cv.samples.findFile(cascade_fn))
rectang = np.array([0, 0, 0, 0])
time = 0.0
while True:
t = clock()
dt = 0.0
# ret, img = self.cam.read()
_ret, self.frame = self.cam.read()
gray = cv.cvtColor(self.frame, cv.COLOR_BGR2GRAY) #translate image to grey, get it ready for detection
gray = cv.equalizeHist(gray)
vis = self.frame.copy()
rects = detect(gray, cascade)
# if len(rects):
## self.selection = (xmin, ymin, xmax, ymax)
# self.selection = (rects[0][0], rects[0][1], rects[0][2], rects[0][3])
## self.track_window = (xmin, ymin, xmax - xmin, ymax - ymin)
# self.track_window = (rects[0][0], rects[0][1], rects[0][2] - rects[0][0], rects[0][3] - rects[0][1])
# else:
# self.selection = None
# self.track_window = None
if rectang.all() == 0 or time > 3: #for first time we lauch the detection or we've lost the track of face
rects = detect(gray, cascade) #detect the face in the whole image
if len(rects) != 0 : #if detects a face
rectang = np.array([rects[0][0] + 1, rects[0][1] + 1, rects[0][2] - 1, rects[0][3] - 1]) #restrict and restore the detecting region
dt = clock() - t
time = 0.0 #reset the chronoscope when detecting the face
else:
rectang = np.array([0, 0, 0, 0]) #if we lose the track of face, initialize the detecting-rectangle to null
else: #restrict the detecting-region when we have detected the face
gray = gray[rectang[1]:rectang[3], rectang[0]:rectang[2]]
vis = vis[rectang[1]:rectang[3], rectang[0]:rectang[2]]
rects = detect(gray.copy(), cascade) #detect the face in marked rectangle
if len(rects) != 0 : #if detects a face
rectang = np.array([rects[0][0] + 1, rects[0][1] + 1, rects[0][2] - 1, rects[0][3] - 1]) #restrict and restore the detecting region
dt = clock() - t
time = 0.0 #reset the chronoscope when detecting the face
else:
rectang = np.array([0, 0, 0, 0])
if rectang.all() != 0:
dt = (clock() - t) * 1000 #translate the unit of chronoscope to ms
time = time + dt
self.selection = (rectang[0],rectang[1],rectang[2],rectang[3])
self.track_window = (rectang[0],rectang[1],rectang[2]-rectang[0],rectang[3]-rectang[1])
hsv = cv.cvtColor(self.frame, cv.COLOR_BGR2HSV)
mask = cv.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
if self.selection:
x0, y0, x1, y1 = self.selection
hsv_roi = hsv[y0:y1, x0:x1]
mask_roi = mask[y0:y1, x0:x1]
hist = cv.calcHist( [hsv_roi], [0], mask_roi, [16], [0, 180] )
cv.normalize(hist, hist, 0, 255, cv.NORM_MINMAX)
self.hist = hist.reshape(-1)
self.show_hist()
vis_roi = vis[y0:y1, x0:x1]
cv.bitwise_not(vis_roi, vis_roi)
vis[mask == 0] = 0
if self.track_window and self.track_window[2] > 0 and self.track_window[3] > 0:
self.selection = None
prob = cv.calcBackProject([hsv], [0], self.hist, [0, 180], 1)
prob &= mask
prob[rects[0][1]:rects[0][3],rects[0][0]:rects[0][2]] = 0
term_crit = ( cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1 )
track_box, self.track_window = cv.CamShift(prob, self.track_window, term_crit)
if self.show_backproj:
vis[:] = prob[...,np.newaxis]
try:
cv.ellipse(vis, track_box, (0, 0, 255), 2)
# V=vis
# print(self.track_window)
# break
except:
print(track_box)
cv.imshow('camshift', vis)
ch = cv.waitKey(5)
if ch == 27:
break
if ch == ord('b'):
self.show_backproj = not self.show_backproj
cv.destroyAllWindows()
# Capture frame-by-frame
ret, frame = cap.read()
# Our operations on the frame come here
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
ret, corners = cv2.findChessboardCorners(gray, (cbcol, cbrow),None)
if ret == True:
objpoints.append(objp)
corners2 = cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)
imgpoints.append(corners2)
# Draw and display the corners
img = cv2.drawChessboardCorners(frame, (cbcol, cbrow), corners2,ret)
cv2.imshow('frame',img)
cv2.waitKey(250)
else :
cv2.imshow('frame',frame)
cv2.waitKey(250)
if len(imgpoints) >= 150:
print "calibrating camera now"
cv2.destroyAllWindows()
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1],None,None)
np.savez("../calibration_files/MBP", ret=ret, mtx=mtx, dist=dist, rvecs=rvecs, tvecs=tvecs)
break
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
import cv2 as cv
cap = cv.VideoCapture(0)
while True:
ret,frame = cap.read()
gray = cv.cvtColor(frame,cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray,100,200)
cv.imshow('edges',edges)
if cv.waitKey(10) == ord('q'):
break
cv.destroyAllWindows()
def main():
img1_car =None
img1_person = None
img2_car = None
img2_person = None
img2_bicycle = None
img3_car = None
img1 = cv2.imread('../data/test/left/004945.jpg')
img2 = cv2.imread('../data/test/left/004964.jpg')
img3 = cv2.imread('../data/test/left/005002.jpg')
detector_matrix = []
depth_matrix = []
detector_matrix_list = read_all_csv(detector_csv_path, detector_matrix)
depth_matrix_list = read_all_csv(depth_csv_path, depth_matrix)
for detector_matrix in detector_matrix_list:
if detector_matrix.shape[0] == 6:
img1_car = detector_matrix
if detector_matrix.shape[0] == 2:
img1_person = detector_matrix
if detector_matrix.shape[0] == 1 and detector_matrix[0][0]>1000:
img2_bicycle = detector_matrix
if detector_matrix.shape[0] == 4:
img2_car = detector_matrix
if detector_matrix.shape[0] == 1 and detector_matrix[0][0]<1000:
img2_person = detector_matrix
if detector_matrix.shape[0] == 3:
img3_car = detector_matrix
img1_depth = depth_matrix_list[2]
img2_depth = depth_matrix_list[1]
img3_depth = depth_matrix_list[0]
print("finish reading!")
car_count = img1_rows_lists[0]
person_count = img1_rows_lists[1]
bicycle_count = img1_rows_lists[2]
img1, img1_car_center, car_dis_list = calculate_mass_center(img1_car, img1_depth, img1, "car")
np.savetxt("../data/test/results/004945_car_mass_center.csv", img1_car_center, delimiter=",")
print("image 1 car's mass center is: ")
print(img1_car_center)
print()
img_1, img1_person_center, person_dis_list = calculate_mass_center(img1_person, img1_depth, img1, "person")
np.savetxt("../data/test/results/004945_person_mass_center.csv", img1_person_center, delimiter=",")
print("image 1 person's mass center is: ")
print((img1_person_center))
print()
total_list = car_dis_list + person_dis_list
closest_index = np.argsort(total_list)
str = ""
if closest_index[0] < len(car_dis_list):
mass_center = img1_car_center[closest_index[0]]
str = "the closest object is car, position for you is {}.".format(mass_center)
if len(car_dis_list)<= closest_index[0] < len(person_dis_list+car_dis_list):
mass_center = img1_person_center[closest_index[0] - car_count]
str = "the closest object is person, position for you is {}.".format(mass_center)
# if len(person_dis_list+car_dis_list)<= closest_index < len(bicycle_dis_list+person_dis_list+car_dis_list):
# str = "the closest object is bicycle."
cv2.putText(img1, "Car number is: {}, Person number is: {} and Bicycle number is: {}"
.format(car_count, person_count, bicycle_count), (30, 20), font, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
cv2.putText(img1, str, (30, 40), font, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
cv2.imshow("img", img1)
cv2.waitKey(0)
cv2.destroyAllWindows()
car_count = img2_rows_lists[0]
person_count = img2_rows_lists[1]
bicycle_count = img2_rows_lists[2]
img2, img2_car_center, car_dis_list = calculate_mass_center(img2_car, img2_depth, img2, "car")
np.savetxt("../data/test/results/004964_car_mass_center.csv", img2_car_center, delimiter=",")
print("image 2 car's mass center is: ")
print(img2_car_center)
print()
img2, img2_person_center, person_dis_list = calculate_mass_center(img2_person, img2_depth, img2, "person")
np.savetxt("../data/test/results/004964_person_mass_center.csv", img2_person_center, delimiter=",")
print("image 2 person's mass center is: ")
print(img2_person_center)
print()
img2, img2_bicycle_center, bicycle_dis_list = calculate_mass_center(img2_bicycle, img2_depth, img2, "bicycle")
np.savetxt("../data/test/results/004964_bicycle_mass_center.csv", img2_bicycle_center, delimiter=",")
print("image 2 bicycle's mass center is: ")
print(img2_bicycle_center)
print()
total_list = car_dis_list + person_dis_list
closest_index = np.argsort(total_list)
str = ""
if closest_index[0] < len(car_dis_list):
mass_center = img2_car_center[closest_index[0]]
str = "the closest object is car, position for you is {}.".format(mass_center)
if len(car_dis_list)<= closest_index[0] < len(person_dis_list+car_dis_list):
mass_center = img2_person_center[closest_index[0]-car_count]
str = "the closest object is person, position for you is {}.".format(mass_center)
if len(person_dis_list+car_dis_list)<= closest_index[0] < len(bicycle_dis_list+person_dis_list+car_dis_list):
mass_center = img2_bicycle_center[closest_index[0]-car_count-person_count]
str = "the closest object is bicycle, position for you is {}.".format(mass_center)
cv2.putText(img2, "Car number is: {}, Person number is: {} and Bicycle number is: {}"
.format(car_count, person_count, bicycle_count), (30, 20), font, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
cv2.putText(img2, str, (30, 40), font, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
cv2.imshow("img", img2)
cv2.waitKey(0)
cv2.destroyAllWindows()
car_count = img3_rows_lists[0]
person_count = img3_rows_lists[1]
bicycle_count = img3_rows_lists[2]
img3, img3_car_center, car_dis_list = calculate_mass_center(img3_car, img3_depth, img3, "car")
np.savetxt("../data/test/results/005002_car_mass_center.csv", img3_car_center, delimiter=",")
print("image 3 car's mass center is: ")
print(img3_car_center)
print()
total_list = car_dis_list + person_dis_list
closest_index = np.argsort(total_list)
str = ""
if closest_index[0] < len(car_dis_list):
mass_center = img3_car_center[closest_index[0]]
str = "the closest object is car, position for you is {}.".format(mass_center)
# if len(car_dis_list)<= closest_index < len(person_dis_list+car_dis_list):
# str = "the closest object is person."
# if len(person_dis_list+car_dis_list)<= closest_index < len(bicycle_dis_list+person_dis_list+car_dis_list):
# str = "the closest object is bicycle."
cv2.putText(img3, "Car number is: {}, Person number is: {} and Bicycle number is: {}"
.format(car_count, person_count, bicycle_count), (30, 20), font, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
cv2.putText(img3, str, (30, 40), font, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
cv2.imshow("img", img3)
cv2.waitKey(0)
cv2.destroyAllWindows()
def displayImage(img, label='Img', debug=False):
cv2.imshow(label, img)
if not debug:
cv2.waitKey(0)
def detectAndTrackMultipleFaces():
#Open the first webcame device
capture = cv2.VideoCapture(0)
#Create two opencv named windows
#cv2.namedWindow("base-image", cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("result-image", cv2.WINDOW_AUTOSIZE)
#Position the windows next to eachother
#cv2.moveWindow("base-image",0,100)
cv2.moveWindow("result-image",400,100)
#Start the window thread for the two windows we are using
cv2.startWindowThread()
#The color of the rectangle we draw around the face
rectangleColor = (0,165,255)
#variables holding the current frame number and the current faceid
frameCounter = 0
currentFaceID = 0
#Variables holding the correlation trackers and the name per faceid
faceTrackers = {}
faceNames = {}
try:
while True:
#Retrieve the latest image from the webcam
rc,baseImage = capture.read()
#Resize the image to 320x240
#baseImage = cv2.resize( fullSizeBaseImage, ( 320, 240))
#Check if a key was pressed and if it was Q, then break
#from the infinite loop
pressedKey = cv2.waitKey(2)
if pressedKey == ord('Q'):
break
#Result image is the image we will show the user, which is a
#combination of the original image from the webcam and the
#overlayed rectangle for the largest face
resultImage = baseImage.copy()
#STEPS:
# * Update all trackers and remove the ones that are not
# relevant anymore
# * Every 10 frames:
# + Use face detection on the current frame and look
# for faces.
# + For each found face, check if centerpoint is within
# existing tracked box. If so, nothing to do
# + If centerpoint is NOT in existing tracked box, then
# we add a new tracker with a new face-id
#Increase the framecounter
frameCounter += 1
#Update all the trackers and remove the ones for which the update
#indicated the quality was not good enough
fidsToDelete = []
for fid in faceTrackers.keys():
trackingQuality = faceTrackers[ fid ].update( baseImage )
#If the tracking quality is good enough, we must delete
#this tracker
if trackingQuality < 7:
fidsToDelete.append( fid )
for fid in fidsToDelete:
print("Removing fid " + str(fid) + " from list of trackers")
faceTrackers.pop( fid , None )
#Every 10 frames, we will have to determine which faces
#are present in the frame
if (frameCounter % 10) == 0:
#For the face detection, we need to make use of a gray
#colored image so we will convert the baseImage to a
#gray-based image
gray = cv2.cvtColor(baseImage, cv2.COLOR_BGR2GRAY)
#Now use the haar cascade detector to find all faces
#in the image
#faces = faceCascade.detectMultiScale(gray, 1.3, 5)
# detect faces in the image
faces = detector.detect_faces(baseImage)
#print("Faces: ", faces)
#Loop over all faces and check if the area for this
#face is the largest so far
#We need to convert it to int here because of the
#requirement of the dlib tracker. If we omit the cast to
#int here, you will get cast errors since the detector
#returns numpy.int32 and the tracker requires an int
for person in faces:
bounding_box = person['box']
(startX, startY, endX, endY) = (bounding_box[0], bounding_box[1],
bounding_box[2],bounding_box[3])
x = int(startX)
y = int(startY)
w = int(endX)
h = int(endY)
#calculate the centerpoint
x_bar = x + 0.5 * w
y_bar = y + 0.5 * h
#Variable holding information which faceid we
#matched with
matchedFid = None
#Now loop over all the trackers and check if the
#centerpoint of the face is within the box of a
#tracker
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
#calculate the centerpoint
t_x_bar = t_x + 0.5 * t_w
t_y_bar = t_y + 0.5 * t_h
#check if the centerpoint of the face is within the
#rectangleof a tracker region. Also, the centerpoint
#of the tracker region must be within the region
#detected as a face. If both of these conditions hold
#we have a match
if ( ( t_x <= x_bar <= (t_x + t_w)) and
( t_y <= y_bar <= (t_y + t_h)) and
( x <= t_x_bar <= (x + w )) and
( y <= t_y_bar <= (y + h ))):
matchedFid = fid
#If no matched fid, then we have to create a new tracker
if matchedFid is None:
print("Creating new tracker " + str(currentFaceID))
#Create and store the tracker
tracker = dlib.correlation_tracker()
tracker.start_track(baseImage,
dlib.rectangle( x,
y,
x+w,
y+h))
faceTrackers[ currentFaceID ] = tracker
#Start a new thread that is used to simulate
#face recognition. This is not yet implemented in this
#version :)
t = threading.Thread( target = doRecognizePerson ,
args=(faceNames, currentFaceID, baseImage, person))
t.start()
#doRecognizePerson(faceNames, currentFaceID, baseImage, person)
#Increase the currentFaceID counter
currentFaceID += 1
#Now loop over all the trackers we have and draw the rectangle
#around the detected faces. If we 'know' the name for this person
#(i.e. the recognition thread is finished), we print the name
#of the person, otherwise the message indicating we are detecting
#the name of the person
for fid in faceTrackers.keys():
tracked_position = faceTrackers[fid].get_position()
t_x = int(tracked_position.left())
t_y = int(tracked_position.top())
t_w = int(tracked_position.width())
t_h = int(tracked_position.height())
cv2.rectangle(resultImage, (t_x, t_y),
(t_x + t_w , t_y + t_h),
rectangleColor ,2)
if fid in faceNames.keys():
cv2.putText(resultImage, faceNames[fid] ,
(int(t_x + t_w/2), int(t_y)),
cv2.FONT_HERSHEY_SIMPLEX,
0.5, (255, 255, 255), 2)
else:
cv2.putText(resultImage, "Detecting..." ,
(int(t_x + t_w/2), int(t_y)),
cv2.FONT_HERSHEY_SIMPLEX,
0.5, (255, 255, 255), 2)
#Since we want to show something larger on the screen than the
#original 320x240, we resize the image again
#
#Note that it would also be possible to keep the large version
#of the baseimage and make the result image a copy of this large
#base image and use the scaling factor to draw the rectangle
#at the right coordinates.
largeResult = cv2.resize(resultImage,
(OUTPUT_SIZE_WIDTH,OUTPUT_SIZE_HEIGHT))
#Finally, we want to show the images on the screen
#cv2.imshow("base-image", baseImage)
cv2.imshow("result-image", largeResult)
if cv2.waitKey(20) & 0xFF == ord("q"):
break
#To ensure we can also deal with the user pressing Ctrl-C in the console
#we have to check for the KeyboardInterrupt exception and break out of
#the main loop
except KeyboardInterrupt as e:
pass
#Destroy any OpenCV windows and exit the application
cv2.destroyAllWindows()
exit(0)
if areaRatio<27:
cv2.putText(frame,'3',(0,50), font, 2, (0,0,255), 3, cv2.LINE_AA)
else:
cv2.putText(frame,'ok',(0,50), font, 2, (0,0,255), 3, cv2.LINE_AA)
elif l==4:
cv2.putText(frame,'4',(0,50), font, 2, (0,0,255), 3, cv2.LINE_AA)
elif l==5:
cv2.putText(frame,'5',(0,50), font, 2, (0,0,255), 3, cv2.LINE_AA)
elif l==6:
cv2.putText(frame,'reposition',(0,50), font, 2, (0,0,255), 3, cv2.LINE_AA)
else :
cv2.putText(frame,'reposition',(10,50), font, 2, (0,0,255), 3, cv2.LINE_AA)
cv2.imshow('mask',mask)
cv2.imshow('frame',frame)
except:
pass
k = cv2.waitKey(5) & 0xFF
if k == 27:
break
cv2.destroyAllWindows()
vid.release()
#Fix the format of the input picture
img = cv.cvtColor(img_org, cv.COLOR_BGR2GRAY)
fromCenter = False
Boundaries = []
# Select ROI that the our object is present, choose only one object for this trial or system only process one object
ROI_bounding = cv.selectROI("Image", img, fromCenter)
# To Finish the selection process.
ROI = img[int(ROI_bounding[1]):int(ROI_bounding[1] + ROI_bounding[3]),
int(ROI_bounding[0]):int(ROI_bounding[0] + ROI_bounding[2])]
cv.imshow("ROI" + str(ROI_bounding), ROI)
cv.imwrite("ROI" + str(ROI_bounding) + ".jpg", ROI)
#To give enough time to show the above images
cv.waitKey(10)
# At this point we have the object
# Apply a few filters to remove noises, we suggest to add closing and opening methods as well.
img = cv.medianBlur(ROI, 5)
blur1 = cv.GaussianBlur(img, (5, 5), 10)
blur1 = cv.GaussianBlur(blur1, (5, 5), 10)
# Showing the result and saving it.
cv.imshow("blur", blur1)
cv.imwrite("Blur" + str(ROI_bounding) + ".jpg", blur1)
# Change the domain to BW, now we are able to apply more morphological filters.
b, thresh_OTSU = cv.threshold(blur1, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
# At this poit we should add some morphological methods such as opening and closing to get a better object.
# Create a VideoCapture object and read from input file
cap = cv2.VideoCapture('Output.avi')
# Check if camera opened successfully
if (cap.isOpened() == False):
print("Error opening video file")
# Read until video is completed
while (cap.isOpened()):
# Capture frame-by-frame
ret, frame = cap.read()
if ret == True:
# Display the resulting frame
cv2.imshow('Frame', frame)
# Press q on keyboard to exit
# Change the number of waitKey according to the speed you want for the video
# Lower numbers are faster
if cv2.waitKey(60) & 0xFF == ord('q'):
break
# Break the loop
else:
break
# When everything done, release
# the video capture object
cap.release()
# Closes all the frames
cv2.destroyAllWindows()
# Displaying the video at original speed
# If you wanna use this
# Comment the lines related to Deleting the video
#import subprocess, sys # standard library
#opener = "open" if sys.platform == "darwin" else "xdg-open"
input_image = cv2.imread(args.input_image, 1).astype(np.float32)
input_image = cv2.resize(input_image, (input_shape[3], input_shape[2]))
input_image = input_image.transpose((2, 0, 1))
input_image = np.asarray([input_image])
out = net.forward_all(**{net.inputs[0]: input_image})
prediction = net.blobs['deconv6_0_0'].data[0].argmax(axis=0)
prediction = np.squeeze(prediction)
prediction = np.resize(prediction, (3, input_shape[2], input_shape[3]))
prediction = prediction.transpose(1, 2, 0).astype(np.uint8)
prediction_rgb = np.zeros(prediction.shape, dtype=np.uint8)
label_colours_bgr = label_colours[..., ::-1]
cv2.LUT(prediction, label_colours_bgr, prediction_rgb)
# cv2.imshow("ENet", prediction_rgb)
key = cv2.waitKey(0)
if args.out_dir is not None:
input_path_ext = args.input_image.split(".")[-1]
input_image_name = args.input_image.split("/")[-1:][0].replace(
'.' + input_path_ext, '')
out_path_im = args.out_dir + input_image_name + '_enet' + '.' + input_path_ext
out_path_gt = args.out_dir + input_image_name + '_enet_gt' + '.' + input_path_ext
cv2.imwrite(out_path_im, prediction_rgb)
# cv2.imwrite(out_path_gt, prediction) # label images, where each pixel has an ID that represents the class
def FaceDetect(self):
import cv2
import numpy as np
cv2.namedWindow('frame')
cv2.namedWindow('dist')
# the classifier that will be used in the cascade
faceCascade = cv2.CascadeClassifier('haarcascade_frontalface_alt.xml')
# capture video stream from camera source. 0 refers to first camera, 1 referes to 2nd and so on.
cap = cv2.VideoCapture(1)
triggered = False
sdThresh = 10
font = cv2.FONT_HERSHEY_SIMPLEX
_, frame1 = cap.read()
_, frame2 = cap.read()
facecount = 0
while (True):
_, frame3 = cap.read()
rows, cols, _ = np.shape(frame3)
cv2.imshow('dist', frame3)
dist = distMap(frame1, frame3)
frame1 = frame2
frame2 = frame3
# apply Gaussian smoothing
mod = cv2.GaussianBlur(dist, (9, 9), 0)
# apply thresholding
_, thresh = cv2.threshold(mod, 100, 255, 0)
# calculate st dev test
_, stDev = cv2.meanStdDev(mod)
cv2.imshow('dist', mod)
cv2.putText(
frame2, "Standard Deviation - {}".format(round(stDev[0][0],
0)), (70, 70),
font, 1, (255, 0, 255), 1, cv2.LINE_AA)
if stDev > sdThresh:
# the cascade is implemented in grayscale mode
gray = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
# begin face cascade
faces = faceCascade.detectMultiScale(gray,
scaleFactor=2,
minSize=(20, 20))
facecount = 0
# draw a rectangle over detected faces
for (x, y, w, h) in faces:
print(x, y)
self.actionFollower(x, y)
facecount = facecount + 1
cv2.rectangle(frame2, (x, y), (x + w, y + h), (0, 255, 0),
1)
cv2.putText(frame2, "No of faces {}".format(facecount),
(50, 50), font, 1, (0, 0, 255), 1, cv2.LINE_AA)
else:
if facecount > 0:
#print("Face count:")
#print(facecount)
facecount = 0
cv2.imshow('frame', frame2)
if cv2.waitKey(1) & 0xFF == 27:
break
cap.release()
cv2.destroyAllWindows()
import cv2
original_img = cv2.imread('supremacy.jpg', 0)
template = cv2.imread('template_from_original.png', 0)
w, h = template.shape[::-1]
method = cv2.TM_CCOEFF
result = cv2.matchTemplate(
original_img, template, method
)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
top_left = min_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
cv2.imshow('Original', original_img)
cv2.rectangle(original_img, top_left, bottom_right, 255, 2)
cv2.imshow('Supremacy Detection', original_img)
if cv2.waitKey(0) & 0xff == 27:
cv2.destroyAllWindows()
tiempo = time.time()
with picamera.PiCamera(resolution=(2592, 1944),
framerate=2,
sensor_mode=0,
clock_mode='reset') as camera:
camera.exposure_mode = 'sports'
#with picamera.array.PiRGBArray(camera) as output:
with PiRGBAArray(camera) as output:
while contador < 1000:
#if contador == 1:
# print(camera.sensor_mode)
#lrs = piCameraStream.__next__()
#imageArray = lrs.array
#lowResCap.truncate(0)
GPIO.output(pinInput, GPIO.HIGH)
tiempoCapture1 = time.time()
camera.capture(output, format='rgba', use_video_port=True)
print('Capture only: ', time.time() - tiempoCapture1)
GPIO.output(pinInput, GPIO.LOW)
#print('Captured %dx%d image' % (output.array.shape[1], output.array.shape[0]))
output.truncate(0)
#print(type(output.array))
cv2.imshow('Imagen', cv2.resize(output.array, (320, 240)))
#cv2.imwrite(rutaDeGuardado+'imagen_{}.jpg'.format(contador), imageArray)
print('Full time: ', time.time() - tiempo)
tiempo = time.time()
contador += 1
ch = 0xFF & cv2.waitKey(1)
if ch == ord('q'):
break
canny_output = cv.Canny(image, t, t * 2)
cv.imshow("canny_output", canny_output)
cv.imwrite("../result/canny_output.png", canny_output)
return canny_output
src = cv.imread("../images/4.jpeg")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
binary = canny_demo(src)
k = np.ones((3, 3), dtype=np.uint8)
binary = cv.morphologyEx(binary, cv.MORPH_DILATE, k)
# 轮廓发现
contours, hierarchy = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
for c in range(len(contours)):
# x, y, w, h = cv.boundingRect(contours[c]);
# cv.drawContours(src, contours, c, (0, 0, 255), 2, 8)
# cv.rectangle(src, (x, y), (x+w, y+h), (0, 0, 255), 1, 8, 0);
rect = cv.minAreaRect(contours[c])
cx, cy = rect[0]
box = cv.boxPoints(rect)
box = np.int0(box)
cv.drawContours(src,[box],0,(0,0,255),2)
cv.circle(src, (np.int32(cx), np.int32(cy)), 2, (255, 0, 0), 2, 8, 0)
# 显示
cv.imshow("contours_analysis", src)
cv.imwrite("../result/contours_analysis.png", src)
cv.waitKey(0)
cv.destroyAllWindows()
def display_image(img_file):
img = cv2.imread(img_file)
cv2.imshow(img_file, img)
cv2.waitKey(100)
centroid = (bbox[0] + (bbox[2] / 2), bbox[1] + (bbox[3] / 2))
d2 = math.sqrt(((centroid[0] - relpos[1]) *
(centroid[0] - relpos[1])) +
((centroid[1] - relpos[0]) *
(centroid[1] - relpos[0])))
speed = (d1 - d2) / (time.time() - t1)
t1 = time.time()
d1 = d2
sp = speed
else:
# Tracking failure
cv2.putText(frame, "Tracking failure detected", (100, 110),
cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2)
# Display tracker type on frame
cv2.putText(frame, "Speed: " + str(sp), (100, 80),
cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2)
cv2.putText(frame, tracker_type + " Tracker", (100, 20),
cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2)
# Display FPS on frame
cv2.putText(frame, "FPS : " + str(int(fps)), (100, 50),
cv2.FONT_HERSHEY_SIMPLEX, 0.75, (50, 170, 50), 2)
# Display result
cv2.imshow("Tracking", frame)
loop = loop + 1
# Exit if ESC pressed
k = cv2.waitKey(1) & 0xff
if k == 27: break
def buildConfigFiles(self):
# open the classes output file
f = open(config.CLASSE_FILE, "w")
# path_file_classes = os.path.dirname(config.CLASSE_FILE)
# file_classes_yolo = open(path_file_classes + "/obj.names", "w")
config_yolo.OBJ_NAMES_YOLO = os.path.join(config_yolo.RECORDS_YOLO,
'obj.names')
file_classes_yolo = open(config_yolo.OBJ_NAMES_YOLO, "w")
# loop over the classes
count_classes = 0
for (k, v) in config.CLASSES.items():
# construct the class information and write to file
item = ("item {\n"
"\tid: " + str(v) + "\n"
"\tname: '" + k + "'\n"
"}\n")
f.write(item)
file_classes_yolo.write(k + '\n')
# close the output classes file
count_classes = count_classes + 1
f.close()
file_classes_yolo.close()
# initialize a data dictionary used to map each image filename
# to all bounding boxes associated with the image, then load
# the contents of the annotations file
D = {}
rows = open(config.ANNOT_PATH).read().strip().split("\n")
for row in rows[1:]:
# break the row into components
row = row.split(",")[0].split(";")
try:
(imagePath, label, startX, startY, endX, endY) = row
except:
(imagePath, label, startX, startY, endX, endY, *_) = row
(startX, startY) = (float(startX), float(startY))
(endX, endY) = (float(endX), float(endY))
# if we are not interested in the label, ignore it
if label not in config.CLASSES:
continue
# build the path to the input image, then grab any other
# bounding boxes + labels associated with the image
# path, labels, and bounding box lists, respectively
p = os.path.sep.join([config.BASE_PATH, imagePath])
b = D.get(p, [])
# build a tuple consisting of the label and bounding box,
# then update the list and store it in the dictionary
b.append((label, (startX, startY, endX, endY)))
D[p] = b
# create training and testing splits from our data dictionary
(trainKeys, testKeys) = train_test_split(
list(D.keys()),
test_size=float(self.ids.text_input_TestProportion.text),
random_state=42)
# initialize the data split files
datasets = [("train", trainKeys, config.TRAIN_RECORD),
("test", testKeys, config.TEST_RECORD)]
# loop over the datasets
for (dType, keys, outputPath) in datasets:
# inicialize the TensorFlow wirter and initialize the total
# number of examples written to file
# create train and test txt files for yolo
config_yolo.TRAIN_TEST_YOLO = os.path.dirname(outputPath)
f = open(config_yolo.TRAIN_TEST_YOLO + "/train.txt", "w")
f.writelines("%s\n" % item for item in trainKeys)
f.close()
f = open(config_yolo.TRAIN_TEST_YOLO + "/test.txt", "w")
f.writelines("%s\n" % item for item in testKeys)
f.close()
print("[INFO] processing '{}'...".format(dType))
writer = tf.python_io.TFRecordWriter(outputPath)
total = 0
# loop over all thhe keys in the current set
for k in keys:
# load the input image from disk as a TensorFlow object
# print(k)
# input("Press Enter to continue...")
encoded = tf.gfile.GFile(os.path.join(config.BASE_PATH, k),
"rb").read()
encoded = bytes(encoded)
# load the image from disk again, this time as a PIL
# object
pilImage = Image.open(k)
(w, h) = pilImage.size[:2]
# parse the filename and encoding from input path
filename = k.split(os.path.sep)[-1]
encoding = filename[filename.rfind(".") + 1:]
# initialize the annotation object used to store
# information regarding the bounuding box + labels
tfAnnot = tfannotation.TFAnnotation()
tfAnnot.image = encoded
tfAnnot.encoding = encoding
tfAnnot.filename = filename
tfAnnot.width = w
tfAnnot.height = h
# loop over the bounding boxes + labels associated with
# the image
#create .txt for each image
image_path_yolo = k
filename_yolo, file_extension_yolo = os.path.splitext(
image_path_yolo)
file_path_yolo = image_path_yolo.replace(
file_extension_yolo, ".txt")
# Get list of classes yolo - it will be used to get the idx
file_classes_yolo = open(config_yolo.OBJ_NAMES_YOLO, "r")
labels_yolo = file_classes_yolo.readlines()
file_classes_yolo.close()
file = open(file_path_yolo, 'w')
for (label, (startX, startY, endX, endY)) in D[k]:
# TensorFlow assumes all bounding boxes are in the
# range [0,1] so we need to scale them
xMin = startX / w
xMax = endX / w
yMin = startY / h
yMax = endY / h
#YOLO format
width = endX - startX
height = endY - startY
Yolo_x = (startX + (width / 2)) / w
Yolo_y = (startY + (height / 2)) / h
Yolo_width = abs(width / w)
Yolo_height = abs(height / h)
# print(k)
# print(D[k])
# print('{} {:6f} {:6f} {:6f} {:6f}\n'.format(label, Yolo_x, Yolo_y, Yolo_width, Yolo_height))
# input("Press Enter to continue...")
label_yolo_idx = labels_yolo.index(label + '\n')
file.write('{} {:6f} {:6f} {:6f} {:6f}\n'.format(
label_yolo_idx, Yolo_x, Yolo_y, Yolo_width,
Yolo_height))
if self.countVerifyImages < 5:
image = cv2.imread(k)
startX = int(xMin * w)
startY = int(yMin * h)
endX = int(xMax * w)
endY = int(yMax * h)
cv2.rectangle(image, (startX, startY), (endX, endY),
(0, 255, 0), 2)
root = tk.Tk()
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
image = cv2.resize(image,
(screen_width, screen_height),
interpolation=cv2.INTER_AREA)
cv2.imshow("Image", image)
cv2.moveWindow("Image", 20, 20)
cv2.waitKey(0)
cv2.destroyAllWindows()
self.countVerifyImages += 1
# update the bounding boxes + labels lists
tfAnnot.xMins.append(xMin)
tfAnnot.xMaxs.append(xMax)
tfAnnot.yMins.append(yMin)
tfAnnot.yMaxs.append(yMax)
tfAnnot.textLabels.append(label.encode("utf8"))
tfAnnot.classes.append(config.CLASSES[label])
tfAnnot.difficult.append(0)
total += 1
# encode the data point attributes using the TensorFlor
# helper functions
features = tf.train.Features(feature=tfAnnot.build())
example = tf.train.Example(features=features)
# add the example to the writer
writer.write(example.SerializeToString())
# close the writer and print diagnostic informationn to the
# user
writer.close()
print("[INFO] {} examples saved for '{}'".format(total, dType))
# create obj.data for yolo
config_yolo.OBJ_DATA_YOLO = os.path.join(config_yolo.RECORDS_YOLO,
'obj.data')
f = open(config_yolo.OBJ_DATA_YOLO, "w")
print(f)
f.writelines("classes = " + str(count_classes) + "\n")
f.writelines("train = " + config_yolo.RECORDS_YOLO + "/train.txt\n")
f.writelines("valid = " + config_yolo.RECORDS_YOLO + "/test.txt\n")
f.writelines("names = " + config_yolo.RECORDS_YOLO + "/obj.names\n")
f.close()
config_yolo.NUM_CLASSES = count_classes
self.manager.get_screen(
'FineTuningScreenPipelineName').buildSelectModel()
self.manager.current = 'FineTuningScreenPipelineName'
