def image_callback(self, ros_img):
# Convert received image message to OpenCv image
cv_image = bridge.imgmsg_to_cv2(ros_img,
desired_encoding="passthrough")
output = cv_image.copy()
gray_img = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
hsv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV)
# red range here doesn't work well, needs to wrap around 255 0 or something like that, fix is to combine mask
# lower = np.array([0, 100, 100])
# upper = np.array([20, 255, 255])
# red range here works better,but not using fix proposed from online forums
# lower = np.array([0, 50, 20])
# upper = np.array([5, 255, 255])
circles = cv2.HoughCircles(gray_img, cv2.HOUGH_GRADIENT, 1.7, 5)
if circles is not None:
# convert the (x, y) coordinates and radius of the circles to integers
circles = np.round(circles[0, :]).astype("int")
# loop over the (x, y) coordinates and radius of the circles
for (x, y, r) in circles:
# draw the circle in the output image, then draw a rectangle
# corresponding to the center of the circle
cv2.circle(output, (x, y), r, (255, 0, 255), 4)
# yellow
lower = np.array([22, 93, 0], dtype="uint8")
upper = np.array([45, 255, 255], dtype="uint8")
mask = cv2.inRange(hsv_image, lower, upper)
cnts = cv2.findContours(mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnt = cnts[0]
# find centroid location
M = cv2.moments(cnt)
if M['m00'] > 0:
xbar = int(M['m10'] / M['m00'])
ybar = int(M['m01'] / M['m00'])
global xbar, ybar
# temp=self.convert_image_pixel_to_cm()
cnts = cnts[0] if len(cnts) == 2 else cnts[1]
# print len(cnts), " contours"
for c in cnts:
x, y, w, h = cv2.boundingRect(c)
cv2.rectangle(cv_image, (x, y), (x + w, y + h), (12, 255, 12), 2)
cv2.rectangle(cv_image, (318, 198), (322, 202), (0, 0, 255), 1)
reticle = [320, 200] # reticle centered location
# prevents robot from crawling
if xbar > reticle[0]:
adjust_high_X = True
adjust_low_X = False
if xbar < reticle[0]:
adjust_high_X = False
adjust_low_X = True
# positve y is in conventional negative direction
if ybar > reticle[1]:
adjust_high_Y = True
adjust_low_Y = False
if ybar < reticle[1]:
adjust_high_Y = False
adjust_low_Y = True
global adjust_high_X, adjust_low_X, adjust_high_Y, adjust_low_Y
cv2.imshow("output", cv_image)
# cv2.imshow('Image', cv_image) # display image
cv2.waitKey(1)
#kernel = np.ones((2.6,2.7),np.uint8)
#gray = cv2.erode(gray,kernel,iterations = 1)
# gray = erosion
#gray = cv2.dilate(gray,kernel,iterations = 1)
# gray = dilation
# get the size of the final image
# img_size = gray.shape
# print img_size
# detect circles in the image
circles = cv2.HoughCircles(gray,
cv2.HOUGH_GRADIENT,
1,
260,
param1=30,
param2=65,
minRadius=0,
maxRadius=0)
# print circles
# ensure at least some circles were found
if circles is not None:
# convert the (x, y) coordinates and radius of the circles to integers
circles = np.round(circles[0, :]).astype("int")
# loop over the (x, y) coordinates and radius of the circles
for (x, y, r) in circles:
# draw the circle in the output image, then draw a rectangle in the image
# corresponding to the center of the circle
cv2.circle(output, (x, y), r, (0, 255, 0), 4)
img_raw = img_raw[:, :, :3]
img_h, img_w = img_raw.shape[:2]
if img_h > img_w:
ratiox = DIM1 / img_w
ratioy = DIM2 / img_h
img_raw = cv2.resize(img_raw, (DIM1, DIM2))
else:
ratiox = DIM2 / img_w
ratioy = DIM1 / img_h
img_raw = cv2.resize(img_raw, (DIM2, DIM1))
gray = cv2.cvtColor(img_raw, cv2.COLOR_BGR2GRAY)
circles = cv2.HoughCircles(gray,
cv2.HOUGH_GRADIENT,
1,
100,
param1=hough_upper_threshold,
param2=hough_lower_threshold,
minRadius=hough_min_radius,
maxRadius=hough_max_radius)
if circles is not None:
# convert the (x, y) coordinates and radius of the circles to integers
circles = np.round(circles[0, :]).astype("int")
# copy the image, for painting we will use another
drawn_image = img_raw.copy()
# loop over the found circles
for i in range(len(circles)):
# get one
(x, y, r) = circles[i]
# draw the circle in the output image, then draw a rectangle corresponding to the center of the circle
cv2.rectangle(drawn_image, (x - r, y - r), (x + r, y + r),
border_size = 2
center_color = (0, 128, 255)
image = cv2.imread("image/ball.jpg")
output = image.copy()
im_color = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
# cv2.inRange()
cv2.imshow("output", np.hstack([image, im_color]))
gray = cv2.cvtColor(output, cv2.COLOR_BGR2GRAY)
cv2.imwrite("image/grayBall.jpg", gray)
edged = cv2.Canny(
gray, first_threshold, second_threshold
) # find borders use canny-algoritm на вход подаются 2 пороговых значения
cv2.imwrite("image/borders.jpg", edged)
circles = cv2.HoughCircles(
gray, cv2.HOUGH_GRADIENT, acc, 2, 100
) # save resolution, 100 - Minimum distance between the centers of the detected circles Hough transform1-same resolution
if circles is not None:
circles = np.round(circles[0, :]).astype(
"int"
) # convert the (x, y) coordinates and radius of the circles to integers
for (
x, y, r
) in circles: # loop over the (x, y) coordinates and radius of the circles
# draw the circle in the output image, then draw a rectangle
# corresponding to the center of the circle
cv2.circle(output, (x, y), r, (0, 255, 0), border_size)
cv2.rectangle(output, (x - 5, y - 5), (x + 5, y + 5), center_color, -1)
#cv2.imshow("output", np.hstack([image, output]))
cv2.waitKey(0)
#Filtro Gaussiano
imgGaussian = cv2.GaussianBlur(imgGray, (11, 11), 1)
#Filtro de Sobel
imgSobelEixoX = cv2.Sobel(imgGaussian, cv2.CV_8U, 1, 0, ksize=5)
imgSobelEixoY = cv2.Sobel(imgGaussian, cv2.CV_8U, 0, 1, ksize=5)
imgSobel = imgSobelEixoX + imgSobelEixoY
#Filtro de Canny
imgCanny = cv2.Canny(img, 100, 200)
#Detecção de Círculos
circles = cv2.HoughCircles(imgGray,
cv2.HOUGH_GRADIENT,
1,
20,
param1=65,
param2=50,
minRadius=0,
maxRadius=0)
detected_circles = np.uint16(np.around(circles))
#Desenhando os cículos encontrados na cópia da imagem
for (x, y, r) in detected_circles[0, :]:
cv2.circle(imgCopy, (x, y), r, (0, 255, 255), 2)
cv2.circle(imgCopy, (x, y), 2, (0, 0, 255), 2)
cv2.imshow("Imagem Original / Círculos encontrados", np.hstack([img, imgCopy]))
cv2.waitKey(0)
cv2.destroyAllWindows()
import cv2 as cv
import numpy as np
src = cv.imread("./pictures/circles.jpg")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
gray = cv.GaussianBlur(gray, (9, 9), 2, 2)
dp = 1
param1 = 100
param2 = 50
circles = cv.HoughCircles(gray, cv.HOUGH_GRADIENT, dp, 10, None, param1,
param2, 20, 100)
print("circles type: ", type(circles))
for c in circles[0, :]:
print(c)
cx, cy, r = c
cv.circle(src, (cx, cy), 2, (0, 255, 0), 2, 8, 0)
cv.circle(src, (cx, cy), r, (0, 0, 255), 2, 8, 0)
# show
cv.imshow("hough line demo", src)
cv.imwrite("contours_analysis.png", src)
cv.waitKey(0)
cv.destroyAllWindows()
import cv2
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True, help="Path to the image")
args = vars(ap.parse_args())
# load the image, clone it for output, and then convert it to grayscale
image = cv2.imread(args["image"])
output = image.copy()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
gray = cv2.threshold(gray, 100, 255, cv2.THRESH_BINARY_INV)[1]
cv2.imshow("image", gray)
cv2.waitKey(0)
# detect circles in the image
circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, 1.2, 3000)
# ensure at least some circles were found
if circles is not None:
# convert the (x, y) coordinates and radius of the circles to integers
circles = np.round(circles[0, :]).astype("int")
# loop over the (x, y) coordinates and radius of the circles
for (x, y, r) in circles:
# draw the circle in the output image, then draw a rectangle
# corresponding to the center of the circle
cv2.circle(output, (x, y), r, (0, 255, 0), 4)
cv2.rectangle(output, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255),
-1)
# show the output image
cv2.imshow("output", np.hstack([image, output]))
cv2.waitKey(0)
cv2.line(drawing, (x1, y1), (x2, y2), (0, 0, 255))
cv2.imshow('hough lines', np.hstack((img, drawing)))
cv2.waitKey(0)
# 统计概率霍夫线变换
drawing = np.zeros(img.shape[:], dtype=np.uint8)
lines = cv2.HoughLinesP(edges, 0.8, np.pi / 180, 90, minLineLength=50, maxLineGap=10)
# 将检测的线画出来
for line in lines:
x1, y1, x2, y2 = line[0]
cv2.line(drawing, (x1, y1), (x2, y2), (0, 255, 0), 1, lineType=cv2.LINE_AA)
cv2.imshow('probabilistic hough lines', np.hstack((img, drawing)))
cv2.waitKey(0)
# 3. 霍夫圆变换
drawing = np.zeros(img.shape[:], dtype=np.uint8)
circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 20, param2=30)
circles = np.int0(np.around(circles))
# 将检测的圆画出来
for i in circles[0, :]:
cv2.circle(drawing, (i[0], i[1]), i[2], (0, 255, 0), 2) # 画出外圆
cv2.circle(drawing, (i[0], i[1]), 2, (0, 0, 255), 3) # 画出圆心
cv2.imshow('circle', np.hstack((img, drawing)))
cv2.waitKey(0)
import cv2
import numpy as np
count = 0
img = cv2.imread('./3.jpg', 0)
cimg = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
blur = cv2.blur(img, (5, 5))
circles = cv2.HoughCircles(blur,
cv2.HOUGH_GRADIENT,
param1=50,
param2=50,
dp=1.94,
minDist=20,
minRadius=12,
maxRadius=25)
circles = np.uint16(np.around(circles))
color_img = cv2.imread("./3.jpg")
red = (0, 0, 255)
for x, y, r in circles[0]:
cv2.circle(color_img, (x, y), r, red, 2)
count += 1
cv2.imshow(f'Holes in tree: {count}', color_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
if exp_type == brightloom:
subframe1 = stim_end_frame + 3
subframe2 = stim_end_frame + 47
video.set(cv2.CAP_PROP_POS_FRAMES, subframe1)
ok, frame = video.read()
first_frame = frame.copy()
video.set(cv2.CAP_PROP_POS_FRAMES, subframe2)
ok, frame = video.read()
last_frame = frame.copy()
img_output = np.zeros((last_frame.shape[0], last_frame.shape[1], 3), np.uint8)
# set scale
scale = frame.copy()
petri_dish = 560
gray_scale = cv2.cvtColor(scale, cv2.COLOR_BGR2GRAY)
circles = cv2.HoughCircles(gray_scale, cv2.HOUGH_GRADIENT, 1.2, 800, param1=50,param2=30,minRadius=80,maxRadius=pdmaxrad)
# determine scale using detected petri dish size
if circles is not None:
# grab circle properties
circles = np.round(circles[0, :]).astype("int")
largest_r = 0
# loop over the circles
for (x, y, r) in circles:
# draw the circle in the output image
cv2.circle(scale, (x, y), r, (0, 255, 0), 4)
cv2.rectangle(scale, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255), -1)
if largest_r < r:
largest_r = r
petri_dish = r * 2
# show the output image
def camera(self, argv):
distance = 0
_, frame = self.src.read() #reads the frames from the camera
#gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
blur_frame = cv.GaussianBlur(frame, (3, 3), 0)
hsv = cv.cvtColor(
blur_frame,
cv.COLOR_BGR2HSV) #converts the colorspace from BGR to HSV
lower_blue = np.array([98, 75, 121])
upper_blue = np.array([108, 141, 255])
# Threshold the HSV image to get only blue colors
mask = cv.inRange(
hsv, lower_blue, upper_blue
) #filters out all colors that are out of the blue color range,
# Bitwise-AND mask and original image
#res = cv.bitwise_and(frame, frame, mask=mask) #puts the
#cv.imshow('frame', frame)
#cv.imshow('mask', mask)
#cv.imshow('res', res)
rows = hsv.shape[0] #tar ut alla rader fran bilden(640x480)
blur = cv.GaussianBlur(mask, (3, 3), 0)
circles = cv.HoughCircles(blur,
cv.HOUGH_GRADIENT,
1,
rows / 1,
param1=150,
param2=15,
minRadius=0,
maxRadius=0)
if circles is not None:
circles = np.uint16(np.around(circles))
for i in circles[0, :]:
center = (i[0], i[1])
# circle center
cv.circle(blur, center, 1, (0, 100, 100), 3)
# circle outline
radius = i[2]
cv.circle(blur, center, radius, (255, 0, 255), 3)
distance = (center[0] - 80)
# gopreturn distance
# print(radius)
cv.line(blur, (80, 0), (80, 120), (255, 0, 0), 5)
print(distance)
cv.imshow("detected circles", blur)
X = distance * 1.25
# Todo fix Y
Y = 0
##print('hej')
k = cv.waitKey(5) & 0xFF
if k == 27:
#break
cv.destroyAllWindows()
#p.stop()
GPIO.cleanup()
robot.motorStop()
return X ##, Y
# if int(mnt['m00']) != 0:
# cx = int(mnt['m10'] / mnt['m00'])
# cy = int(mnt['m01'] / mnt['m00'])
# cv.circle(thresh1, (cx, cy), 2, (255, 0, 0), -1)
# by_김주희_기울기 및 거리 구하기위해 중심 값 배열로 만듦 _200819
# center_point.append([cx,cy])
# center_y.append(cy)
# rect_center = rect_center + [cx, cy]
cr = closing_2
cr = closing_2[:, :, 0]
# # cr[:, :, 1] = closing
# # cr[:, :, 2] = closing
# circles = cv.HoughCircles(cr,cv.HOUGH_GRADIENT,1,5,param1=50,param2=35,minRadius=1,maxRadius=0)
# circles = cv.HoughCircles(cr,cv.HOUGH_GRADIENT,1, 5)
circles = cv.HoughCircles(cr,cv.HOUGH_GRADIENT,1,100,param1=10,param2=35)
print(circles)
for c in circles[0, :]:
center = (c[0], c[1])
radius = c[2]
# 바깥원
cv.circle(closing_2, center, radius, (0, 255, 0), 2)
# 중심원
cv.circle(closing_2, center, 2, (0, 0, 255), 3)
plt.subplot(221)
plt.imshow(img, cmap='gray')
def get_lens_edge(filename, crib, pixels_per_mm):
# lens details preparation
radius = crib * pixels_per_mm / 2
# image preprocessing
unprocessed_image = cv2.imread(filename, 0)
height, width = unprocessed_image.shape
mask = np.zeros((height, width), np.uint8)
preprocessed_image = prep_circle_find(unprocessed_image, 2)
edges = cv2.Canny(preprocessed_image, 150, 200)
# find circles and process image
try:
radii = []
found_circles = cv2.HoughCircles(edges,
cv2.HOUGH_GRADIENT,
1,
500,
param1=50,
param2=30,
minRadius=int(.98 * radius),
maxRadius=int(1.05 * radius))
for each_circle in found_circles[0, :]:
radii.append((each_circle[2] - radius) / radius)
##define outer and inner radius
outer_radius = int(each_circle[2] - 10 - (.25 * (radius - 520)))
inner_radius = int(outer_radius * (.95))
cv2.circle(mask, (each_circle[0], each_circle[1]),
outer_radius, (255, 255, 255),
thickness=-1)
cv2.circle(mask, (each_circle[0], each_circle[1]),
inner_radius, (0, 0, 0),
thickness=-1)
#debug print statements for edge shape analysis values
# print('predicted circle radius = ' + str(radius))
# print('found circle radius = ' + str(each_circle[2]))
#print('Adjusted outer radius: ' + str(outer_radius))
#print('Adjusted inner radius: ' + str(inner_radius))
##-----------------------------
masked_data = cv2.bitwise_and(unprocessed_image,
unprocessed_image,
mask=mask)
masked_preprocessed_data = cv2.bitwise_and(preprocessed_image,
preprocessed_image,
mask=mask)
contours = cv2.findContours(masked_preprocessed_data,
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
x, y, w, h = cv2.boundingRect(contours[0])
crop = masked_data[y:y + h, x:x + w]
blur_crop = cv2.blur(crop, (4, 4))
erode_crop = cv2.erode(blur_crop, (3, 3), iterations=1)
ret_crop, thresh_crop = cv2.threshold(erode_crop, 190, 255,
cv2.THRESH_BINARY)
pi = np.pi
edge_area = pi / 4 * ((outer_radius)**2 - inner_radius**2)
return edge_area, radii, thresh_crop, crop, preprocessed_image
except TypeError:
cv2.imwrite(
'cropped_results\\' +
re.sub(r'.png', '', os.path.basename(filename)) +
'_failed_no_circle_found.png', unprocessed_image)
pass
def find_in_circle(self, frame: np.ndarray, erode=False):
g_frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
ys, ye, xs, xe = self.get_roi(frame)
g_frame = self.__eliminate_non_roi(g_frame, ys, ye, xs, xe)
_filter = self._filter
if _filter == 'threshold':
blur = cv.GaussianBlur(g_frame, tuple(self.blur), 0)
_, mask = cv.threshold(blur, self.threshold, 255,
cv.THRESH_BINARY_INV)
elif _filter == 'adaptative':
mask = cv.adaptiveThreshold(g_frame, 255,
cv.ADAPTIVE_THRESH_MEAN_C,
cv.THRESH_BINARY, 5, 2)
else:
cut_frame = frame.copy()
cut_frame = self.__eliminate_non_roi(cut_frame, ys, ye, xs, xe)
if _filter == 'hsv':
cvt_frame = cv.cvtColor(cut_frame, cv.COLOR_BGR2HSV)
lower = np.array((self.table_hsv[0][0], self.table_hsv[0][1],
self.table_hsv[0][2]), np.uint8)
higher = np.array((self.table_hsv[1][0], self.table_hsv[1][1],
self.table_hsv[1][2]), np.uint8)
else:
cvt_frame = cv.cvtColor(cut_frame, cv.COLOR_RGB2LAB)
lower = np.array((self.table_hsv[0][0], self.table_hsv[0][1],
self.table_hsv[0][2]), np.uint8)
higher = np.array((self.table_hsv[1][0], self.table_hsv[1][1],
self.table_hsv[1][2]), np.uint8)
mask = cv.inRange(cvt_frame, lower, higher)
if erode:
mask = cv.erode(mask, None, iterations=2)
mask = cv.dilate(mask, None, iterations=2)
if self.debug_tank:
cv.imshow('debug_tank', mask)
self.circles = cv.HoughCircles(mask,
cv.HOUGH_GRADIENT,
param1=self.params[0],
param2=self.params[1],
minDist=self.min_dist,
dp=self.radius[0],
minRadius=self.radius[1],
maxRadius=self.radius[2])
self.found = False
self.x, self.y, self.w, self.h = 0, 0, 0, 0
if self.circles is not None:
circles = np.uint16(np.around(self.circles))
for x, y, r in circles[0, :]:
calc_x = int(x -
r) if (x - r) > 0 and x < frame.shape[1] else 0
calc_y = int(y -
r) if (y - r) > 0 and y < frame.shape[0] else 0
if (calc_x > 0 and calc_x < frame.shape[1]) and (
calc_y > 0 and calc_y < frame.shape[0]):
self.w, self.h = 2 * abs(r), 2 * abs(r)
self.x, self.y = calc_x, calc_y
self.found = True
self.image = frame[self.y:self.y + self.h,
self.x:self.x + self.w]
from resizeimage import resizeimage
img = cv2.imread('office3.jpg', 0)
#img=cv2.resize(zx, (960,540))
#img=resizeimage.resize_cover(zx,[200,100])
img = cv2.medianBlur(img, 5)
cimg = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
cond = True
param = 10
while (cond):
circles = cv2.HoughCircles(img,
cv2.HOUGH_GRADIENT,
1,
40,
param1=100,
param2=param,
minRadius=0,
maxRadius=0)
circles = np.uint16(np.around(circles))
if (circles[0].size / 3 > 0 and circles[0].size / 3 < 3):
cond = False
elif (circles[0].size / 3 == 0):
parm -= 10
else:
param += 10
print param
for i in circles[0, :]:
# draw the outer circle
print(i[0], i[1])
import sys
if __name__ == '__main__':
print(__doc__)
try:
fn = sys.argv[1]
except IndexError:
fn = "../data/board.jpg"
src = cv.imread(fn, 1)
img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
img = cv.medianBlur(img, 5)
cimg = src.copy() # numpy function
circles = cv.HoughCircles(img, cv.HOUGH_GRADIENT, 1, 10, np.array([]), 100,
30, 1, 30)
if circles is not None: # Check if circles have been found and only then iterate over these and add them to the image
a, b, c = circles.shape
for i in range(b):
cv.circle(cimg, (circles[0][i][0], circles[0][i][1]),
circles[0][i][2], (0, 0, 255), 3, cv.LINE_AA)
cv.circle(cimg, (circles[0][i][0], circles[0][i][1]), 2,
(0, 255, 0), 3, cv.LINE_AA) # draw center of circle
cv.imshow("detected circles", cimg)
cv.imshow("source", src)
cv.waitKey(0)
def main():
"""
Example entry point; please see Enumeration example for more in-depth
comments on preparing and cleaning up the system.
:return: True if successful, False otherwise.
:rtype: bool
"""
# Retrieve singleton reference to system object
system = PySpin.System.GetInstance()
# Retrieve list of cameras from the system
cam_list = system.GetCameras()
num_cameras = cam_list.GetSize()
print 'Number of cameras detected: %d' % num_cameras
# Finish if there are no cameras
if num_cameras == 0:
# Clear camera list before releasing system
cam_list.Clear()
# Release system instance
system.ReleaseInstance()
print 'Not enough cameras!'
raw_input('Done! Press Enter to exit...')
return False
# Run address of each camera
cam = cam_list.GetByIndex(0)
# Retrieve TL device nodemap and print device information
nodemap_tldevice = cam.GetTLDeviceNodeMap()
# Initialize camera
cam.Init()
# Retrieve GenICam nodemap
nodemap = cam.GetNodeMap()
# Acquire images
# In order to access the node entries, they have to be casted to a pointer type (CEnumerationPtr here)
node_acquisition_mode = PySpin.CEnumerationPtr(
nodemap.GetNode('AcquisitionMode'))
if not PySpin.IsAvailable(node_acquisition_mode) or not PySpin.IsWritable(
node_acquisition_mode):
print 'Unable to set acquisition mode to continuous (enum retrieval). Aborting...'
return False
# Retrieve entry node from enumeration node
node_acquisition_mode_continuous = node_acquisition_mode.GetEntryByName(
'Continuous')
if not PySpin.IsAvailable(
node_acquisition_mode_continuous) or not PySpin.IsReadable(
node_acquisition_mode_continuous):
print 'Unable to set acquisition mode to continuous (entry retrieval). Aborting...'
return False
# Retrieve integer value from entry node
acquisition_mode_continuous = node_acquisition_mode_continuous.GetValue()
# Set integer value from entry node as new value of enumeration node
node_acquisition_mode.SetIntValue(acquisition_mode_continuous)
cam.TLStream.StreamBufferHandlingMode.SetValue(
PySpin.StreamBufferHandlingMode_NewestFirst)
print 'Acquisition mode set to continuous...'
# Begin acquiring images
#
# *** NOTES ***
# What happens when the camera begins acquiring images depends on the
# acquisition mode. Single frame captures only a single image, multi
# frame catures a set number of images, and continuous captures a
# continuous stream of images. Because the example calls for the
# retrieval of 10 images, continuous mode has been set.
#
# *** LATER ***
# Image acquisition must be ended when no more images are needed.
cam.BeginAcquisition()
print 'Acquiring images...'
# Retrieve device serial number for filename
#
# *** NOTES ***
# The device serial number is retrieved in order to keep cameras from
# overwriting one another. Grabbing image IDs could also accomplish
# this.
device_serial_number = ''
node_device_serial_number = PySpin.CStringPtr(
nodemap_tldevice.GetNode('DeviceSerialNumber'))
if PySpin.IsAvailable(node_device_serial_number) and PySpin.IsReadable(
node_device_serial_number):
device_serial_number = node_device_serial_number.GetValue()
print 'Device serial number retrieved as %s...' % device_serial_number
cv2.namedWindow('PyCapImg', cv2.WINDOW_GUI_NORMAL)
cv2.resizeWindow('PyCapImg', 500, 550)
while cv2.waitKey(1) & 0xFF != 27:
try:
image_result = cam.GetNextImage()
if image_result.IsIncomplete():
print 'Image incomplete with image status %d ...' % image_result.GetImageStatus(
)
else:
# Convert image to mono 8
#
# *** NOTES ***
# Images can be converted between pixel formats by using
# the appropriate enumeration value. Unlike the original
# image, the converted one does not need to be released as
# it does not affect the camera buffer.
#
# When converting images, color processing algorithm is an
# optional parameter.
image_converted = image_result
filename = 'Acquisition.bmp'
# Save image
#
# *** NOTES ***
# The standard practice of the examples is to use device
# serial numbers to keep images of one device from
# overwriting those of another.
image_converted.Save(filename)
print 'Image saved at %s' % filename
# Release image
#
# *** NOTES ***
# Images retrieved directly from the camera (i.e. non-converted
# images) need to be released in order to keep from filling the
# buffer.
image_result.Release()
print ''
im = cv2.imread(filename, 3)
"Convert BGR to HSV"
hsv = cv2.cvtColor(im, cv2.COLOR_BGR2HSV)
#define range of blue color in HSV
lower_red = np.array([86, 80, 80])
upper_red = np.array([120, 255, 255])
lower_green = np.array([40, 70, 70])
upper_green = np.array([90, 255, 255])
lower_blue = np.array([110, 50, 50])
upper_blue = np.array([130, 255, 255])
"opencv filters"
mask = cv2.inRange(
hsv, lower_green, upper_green
) # Threshold the HSV image to get only blue colors
mask = cv2.morphologyEx(
mask, cv2.MORPH_OPEN,
np.ones(OPEN_KERNEL_SHAPE,
dtype=np.uint8)) # Close operation for denoise
# Bitwise-AND mask and original image
#res = cv2.bitwise_and(im,im, mask= mask)
"Blur the corrected result for denoising and debanding"
mask = cv2.GaussianBlur(mask, (5, 5), 0)
edges = cv2.Canny(mask, 250, 300)
"detect circles"
circles = cv2.HoughCircles(edges,
cv2.HOUGH_GRADIENT,
dp=2,
minDist=MINDIST,
param1=25,
param2=30,
minRadius=MINR,
maxRadius=MAXR)
print circles
"put circles on the image"
if circles is not None and len(circles) > 0:
circles = circles[0]
for (x, y, r) in circles:
x, y, r = int(x), int(y), int(r)
cv2.circle(im, (x, y), r, (255, 0, 0), 10)
cv2.imshow('PyCapImg', im)
except PySpin.SpinnakerException as ex:
print 'Error: %s' % ex
return False
# Release reference to camera
# NOTE: Unlike the C++ examples, we cannot rely on pointer objects being automatically
# cleaned up when going out of scope.
# The usage of del is preferred to assigning the variable to None.
del cam
# Clear camera list before releasing system
cam_list.Clear()
# Release system instance
system.ReleaseInstance()
def emphasize_lines(img, distances, estimatedRadius):
'''
Emphasize all of the straight lines in the image and get rid of unnecessary noise.
Parameters:
{Numpy.array} img - The image to edit
{list} distances - [
{List} [
{Number} x coordinate of the point,
{Number} y coordinate of the point,
{Number} The distance of the point from the bull'seye point
]
...
]
{Number} estimatedRadius - A rough estimation of the target's radius,
that will be used if for some reason it cannot be calculated on the fly.
Returns:
{Number} The target's current radius [px].
{Numpy.array} An image with the lines emphasized.
'''
# find the target's outer ring
circles = cv2.HoughCircles(img,
cv2.HOUGH_GRADIENT,
1,
20,
param1=50,
param2=30,
minRadius=0,
maxRadius=int(estimatedRadius * 1.05))
# use largest detected circle
if type(circles) != type(None):
outerCircle = sorted(circles[0], key=lambda x: x[2])[::-1][0]
radius = outerCircle[2]
# use a rough estimation of the target's radius as a fallback
else:
radius = estimatedRadius
# zero out all pixels outside of the outer ring
img[distances[1] > radius] = 0
# apply thresh and morphology
_, img = cv2.threshold(img, 20, 0xff, cv2.THRESH_BINARY)
img = cv2.morphologyEx(img, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))
# find the straight segments in the image
lines = cv2.HoughLinesP(img,
2,
np.pi / 180,
120,
minLineLength=20,
maxLineGap=0)
img_copy = np.zeros(img.shape, dtype=img.dtype)
if type(lines) != type(None):
for line in lines:
for x1, y1, x2, y2 in line:
cv2.line(img_copy, (x1, y1), (x2, y2), (0xff, 0xff, 0xff), 5)
return radius, img_copy
import cv2
import numpy as np
import os.path
"""
Circle Detection - Hough Circles
cv2.HoughCircles(image, method, dp, MinDist, param1, param2, minRadius, MaxRadius)
Method - currently only cv2.HOUGH_GRADIENT available
dp - Inverse ratio of accumulator resolution
MinDist - the minimum distance between the center of detected circles
param1 - Gradient value used in the edge detection
param2 - Accumulator threshold for the HOUGH_GRADIENT method (lower allows more circles
to be detected (false positives))
minRadius - limits the smallest circle to this size (via radius)
MaxRadius - similarly sets the limit for the largest circles
"""
image = cv2.imread(os.path.dirname(__file__) + '/../images/bottlecaps.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.medianBlur(gray, 5)
circles = cv2.HoughCircles(blur, cv2.cv.CV_HOUGH_GRADIENT, 1.5, 10)
#circles = cv2.HoughCircles(gray, cv.CV_HOUGH_GRADIENT, 1, 10)
circles = np.uint16(np.around(
circles)) # np.around 'Evenly round to the given number of decimals'
for i in circles[0, :]:
# draw the outer circle
cv2.circle(image, (i[0], i[1]), i[2], (255, 0, 0), 2)
from matplotlib import pyplot as plt
import math
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required = True, help = "Path to the image")
args = vars(ap.parse_args())
# load the image, clone it for output, and then convert it to grayscale
img = cv2.imread(args["image"])
output = img.copy()
output2 = img.copy()
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# detect circles in the image
circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, 1.2, 100, param1=50,param2=60,minRadius=150,maxRadius=170)
radius = circles[0][0][2]
circles = np.uint16(np.around(circles))
for i in circles[0,:]:
# draw the outer circle
circle = cv2.circle(gray,(i[0],i[1]),i[2],(0, 255, 0),5)
# draw the center of the circle
cv2.circle(gray,(i[0],i[1]),2,(0, 255, 0),10)
#plt.imshow(gray)
cv2.line(gray,(i[0],i[1]),(math.ceil(i[0]+radius),i[1]),(0,255,0),5)
#plt.imshow(gray)
mask = np.zeros(img.shape[:2],np.uint8)
def detect2(img_read, pt1, pt2, w):
try:
t1 = time.time()
crop_img = img_read[pt1[1]:pt2[1], pt1[0]:pt2[0]]
distance = conf["distance"]
#skp, tkp = cvlib.findKeyPoints(crop_img , target, distance)
crop_img = cv2.medianBlur(crop_img, conf["blur_level"])
gray = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)
circles = cv2.HoughCircles(gray, cv2.cv.CV_HOUGH_GRADIENT,
conf["dp"],#29, ## dp
conf["minDist"],#100, ## minDist
conf["param1"],#param1=70,
conf["param2"],#param2=80, ##
conf["minRadius"],#minRadius=20,
conf["maxRadius"]) #maxRadius=0)
j = 0
if DEBUG == "true":
cv2.rectangle(img_read, pt1, pt2, (0,255,0))
"""
if DEBUG == "false":
if circles == None:
#print "None."
save(0,0,0)
return 0
else:
circles = np.uint16(np.around(circles))
save(circles)
return 1
"""
#print circles
#print type(circles)
if circles == None:
#print "none"
if DEBUG == "true":
cv2.imshow("camera", img_read)
save(0,0,0)
else:
circles = np.uint16(np.around(circles))
#x = circles[0][0][0]
#y = circles[0][0][1]
#r = circles[0][0][2]
#print "else"
for i in circles[0,:]:
if supress(i, w):
j = j + 1
save(1,1,1)
#print i[2], i
if DEBUG == "true":
cv2.circle(img_read,(pt1[0]+i[0],pt1[1]+i[1]),i[2],(0,255,0),2)
cv2.circle(img_read,(pt1[0]+i[0],pt1[1]+i[1]),2,(0,0,255),3)
#cp = [ i[0], i[1] ]
#print cp
if DEBUG == "true":
cv2.imshow("camera", img_read)
except Exception as ex:
#print(ex)
#print(traceback.format_exc())
logger.debug(ex)
import cv2
import numpy as np
img = cv2.imread('images/circle.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray_blurred = cv2.blur(gray, (3, 3))
#Circle Detection
detected_circle = cv2.HoughCircles(gray_blurred,
cv2.HOUGH_GRADIENT,
1,
20,
param1=50,
param2=30,
minRadius=1,
maxRadius=40)
if detected_circle is not None:
detected_circle = np.uint16(np.around(detected_circle))
for pt in detected_circle[0, :]:
a, b, r = pt[0], pt[1], pt[2]
cv2.circle(img, (a, b), r, (0, 255, 0), 3)
#For Center of circle
cv2.circle(img, (a, b), 1, (255, 0, 1), 3)
cv2.imshow('show', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.2, 2)
for (x, y, w, h) in faces:
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]
eyes = eye_cascade.detectMultiScale(roi_gray)
gray = cv2.medianBlur(gray, 5)
rows = gray.shape[0]
circles = cv2.HoughCircles(gray,
cv2.HOUGH_GRADIENT,
1,
rows / 8,
param1=100,
param2=30,
minRadius=1,
maxRadius=30)
font = cv2.FONT_HERSHEY_SIMPLEX
if circles is not None:
circles = np.uint16(np.around(circles))
for i in circles[0, :]:
center = (i[0], i[1])
# circle center
cv2.circle(img, center, 1, (0, 100, 100), 3)
# circle outline
radius = i[2]
cv2.circle(img, center, radius, (255, 0, 255), 3)
# resize the frame, blur it, and convert it to the HSV
# color space
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# construct a mask for the color "green", then perform
# a series of dilations and erosions to remove any small
# blobs left in the mask
termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
mask = cv2.inRange(hsv, Orange1Lower, Orange1Upper)
thresh = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(thresh, (9, 9), 0)
mask = cv2.erode(mask, None, iterations=2)
mask = cv2.dilate(mask, None, iterations=2)
circles = cv2.HoughCircles(blurred, cv2.HOUGH_GRADIENT, 1, 2000, 25, 250,
10, 10) # ret=[[Xpos,Ypos,Radius],...]
if (circles is not None):
##mask = cv2.inRange(hsv, OrangeLower, OrangeUpper)
##mask = cv2.erode(mask, None, iterations=2)
##mask = cv2.dilate(mask, None, iterations=2)
circles = np.uint16(np.around(circles))
for i in circles[0, :]:
# draw the outer circle
cv2.circle(thresh, (i[0], i[1]), i[2], (0, 255, 0), 2)
# draw the center of the circle
cv2.circle(thresh, (i[0], i[1]), 2, (0, 0, 255), 3)
# find contours in the mask and initialize the current
# (x, y) center of the ball
import cv2
import numpy as np
import matplotlib as plt
image = cv2.imread("fifth.jpg")
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
circles = cv2.HoughCircles(image,
cv2.cv.CV_HOUGH_GRADIENT,
2,
32,
param1=200,
param2=100)
if circles is not None:
circles = np.round(circles[0, :]).astype("int")
for (x, y, r) in circles:
cv2.circle(circles, (x, y), r, (0, 255, 0), 4)
img = np.hstack([image])
cv2.imshow("circles", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
# * Detects Circles in Images *
# * *
# *********************************
img = cv2.imread("./images/double4.jpg", cv2.IMREAD_COLOR)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
output = img.copy()
# Blur using 3 * 3 kernel.
gray_blurred = cv2.blur(gray, (3, 3))
# Apply Hough transform on the blurred image.
detected_circles = cv2.HoughCircles(gray_blurred,
cv2.HOUGH_GRADIENT,
1,
40,
param1=50,
param2=30,
minRadius=295,
maxRadius=300)
# Draw circles that are detected.
if detected_circles is not None:
# Convert the circle parameters a, b and r to integers.
detected_circles = np.uint16(np.around(detected_circles))
if detected_circles[0][0][0] < 1000:
xl, yl, rl = detected_circles[0][0][0], detected_circles[0][0][
1], detected_circles[0][0][2]
xr, yr, rr = detected_circles[0][1][0], detected_circles[0][1][
1], detected_circles[0][1][2]
else:
def return_circles_values(img):
img = cv2.medianBlur(img,5)
circles = cv2.HoughCircles(img,cv2.HOUGH_GRADIENT,2,200, param1=35,param2=20,minRadius=5,maxRadius=50)
return circles
while True:
ret, frame = cap.read()
assert ret # TODO REMOVE THIS AAAAA
blurred = cv2.GaussianBlur(frame, (7, 7), 0)
hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, yellow[0], yellow[1])
morph = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((5, 5), np.uint8))
edges = cv2.Canny(morph, 10, 200, 3)
bedges = cv2.GaussianBlur(edges, (7, 7), 0)
circles = cv2.HoughCircles(bedges,
cv2.HOUGH_GRADIENT,
2,
100,
maxRadius=100)
display = frame.copy()
if (isinstance(circles, np.ndarray) and len(circles)) or circles != None:
circles = np.uint16(np.around(circles))[0]
drawCircles(display, circles)
cv2.imshow('frame', display)
cv2.imshow('Edges', morph)
key = cv2.waitKey(1 if running else 0)
if key & 0xff == ord('q'):
break
elif key > 0:
for file in directory:
print(file)
file_name = input("Filename with extension: ")
path = os.getcwd() + '/001/L/%s' % (file_name)
image_read = cv2.imread(path)
output = image_read.copy()
image_test = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
image_test = cv2.GaussianBlur(image_test, (7, 7), 1)
cv2.imshow("imagetest", image_test)
image_test = cv2.Canny(image_test, 80, 100, apertureSize=3)
cv2.imshow("image_test", image_test)
circles = cv2.HoughCircles(image_test,
cv2.HOUGH_GRADIENT,
1,
50,
param1=50,
param2=50,
minRadius=0,
maxRadius=0)
circles = np.round(circles[0, :]).astype("int")
for (x, y, r) in circles:
# draw the circle in the output image, then draw a rectangle
# corresponding to the center of the circle
cv2.circle(output, (x, y), r, (0, 255, 0), 2)
cv2.rectangle(output, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255), -1)
cv2.imshow('detected circles', output)
cv2.waitKey(0)
import cv2
import numpy as np
cap = cv2.VideoCapture(0)
while (1):
_, frame = cap.read()
#frame = cv2.blur(fr,(5,5))
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#gray = cv2.medianBlur(gray,5)
cimg = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
circles = cv2.HoughCircles(gray,
cv2.cv.CV_HOUGH_GRADIENT,
1,
25,
param1=60,
param2=28,
minRadius=10,
maxRadius=30)
if circles is None:
continue
circles = np.uint16(np.around(circles))
for i in circles:
print len(i)
for j in i:
cv2.circle(cimg, (j[0], j[1]), j[2], (0, 255, 0), 2)
cv2.circle(cimg, (j[0], j[1]), 2, (0, 0, 255), 3)
