def preprocess_image(image_path):
files = os.listdir(image_path)
for f in files:
image = mpimg.imread(image_path + '/' + f)
img_gray = rgb2gray(image)
thresh = threshold_otsu(img_gray)
binary = img_gray > thresh
# Step 1: Proprocess original images into binary images
# otsu thresholding with appropriate nbins number
thresh = threshold_otsu(img_gray, nbins = 60)
binary = img_gray > thresh
binary = resize(binary, (1600, 2000))
# size of blocks
block_shape = (10, 10)
# see astronaut as a matrix of blocks (of shape block_shape)
view = view_as_blocks(binary, block_shape)
# collapse the last two dimensions in one
flatten_view = view.reshape(view.shape[0], view.shape[1], -1)
# resampling the image by taking either the `mean`,
# the `max` or the `median` value of each blocks.
mean_view = np.mean(flatten_view, axis=2)
image = mean_view
seed = np.copy(mean_view)
seed[1:-1, 1:-1] = image.max()
mask = image
# fill holes (i.e. isolated, dark spots) in an image using morphological reconstruction by erosion
# plt.title("Filled dark spots by morphological reconstruction")
filled = reconstruction(seed, mask, method='erosion')
plt.figure()
plt.axis('off')
plt.imshow(filled, cmap=cm.Greys_r)
plt.savefig("./enhanced_image/" + f)
# Step 2: Label Junctions
denoised = denoise_wavelet(filled, multichannel=True)
image = filled
coords1 = corner_peaks(corner_harris(image), min_distance=5)
coords_subpix1 = corner_subpix(image, coords1, window_size=13)
image = denoised
coords2 = corner_peaks(corner_harris(image), min_distance=5)
coords_subpix2 = corner_subpix(image, coords2, window_size=13)
fig, ax = plt.subplots()
ax.imshow(image, interpolation='nearest', cmap=plt.cm.gray)
ax.plot(coords_subpix1[:, 1], coords_subpix1[:, 0], '+r', markersize=15)
ax.plot(coords_subpix2[:, 1], coords_subpix2[:, 0], '+r', markersize=15)
plt.axis('off')
plt.savefig("./preprocessed_image/" + f)
def test_subpix_no_class():
img = np.zeros((50, 50))
subpix = corner_subpix(img, np.array([[25, 25]]))
assert_array_equal(subpix[0], (np.nan, np.nan))
img[25, 25] = 1e-10
corner = peak_local_max(corner_harris(img), num_peaks=1)
subpix = corner_subpix(img, np.array([[25, 25]]))
assert_array_equal(subpix[0], (np.nan, np.nan))
def test_subpix_no_class():
img = np.zeros((50, 50))
subpix = corner_subpix(img, np.array([[25, 25]]))
assert_array_equal(subpix[0], (np.nan, np.nan))
img[25, 25] = 1e-10
corner = peak_local_max(corner_harris(img), num_peaks=1)
subpix = corner_subpix(img, np.array([[25, 25]]))
assert_array_equal(subpix[0], (np.nan, np.nan))
def extract_corner_harris(patch):
""" Extract four corner points using harris corner detection algorithm
"""
# Find corner with harris corner detection
coords = corner_peaks(corner_harris(patch, k=0.1), min_distance=5)
coords_subpix = corner_subpix(patch, coords, window_size=13)
# Find the nearest point for each corner
dim = patch.shape
corners = [(0, 0), (dim[0], 0), (dim[0], dim[1]), (0, dim[1])]
dest_points = [[] for x in range(4)]
for i in xrange(4):
dest_points[i] = search_closest_points(corners[i], coords_subpix)
# Check for error
try:
epsilon = 1e-10
for i in xrange(4):
for j in xrange(i + 1, 4):
if calc_distance(dest_points[i], dest_points[j]) < epsilon:
print 'Error point'
return []
except TypeError:
return []
# Reverse y,x position to x,y
for i in xrange(4):
dest_points[i][1], dest_points[i][0] = dest_points[i][0], dest_points[i][1]
return dest_points
def shi_tomasi_skimage(image, min_distance, num_peaks, **kwargs):
coords_subpix = np.zeros_like(image)
cornerness_matrix = sf.corner_peaks(sf.corner_shi_tomasi(image), min_distance=min_distance, num_peaks=num_peaks)
coords_subpix = sf.corner_subpix(image, cornerness_matrix, window_size = 13, alpha=0.8)
draw_points(image, cornerness_matrix, coords_subpix)
print("detected points: ",cornerness_matrix.shape[0])
return cornerness_matrix, coords_subpix
def test_subpix():
img = np.zeros((50, 50))
img[:25, :25] = 255
img[25:, 25:] = 255
corner = peak_local_max(corner_harris(img), num_peaks=1)
subpix = corner_subpix(img, corner)
assert_array_equal(subpix[0], (24.5, 24.5))
def test_subpix_dot():
img = np.zeros((50, 50))
img[25, 25] = 255
corner = peak_local_max(corner_harris(img),
min_distance=10, threshold_rel=0, num_peaks=1)
subpix = corner_subpix(img, corner)
assert_array_equal(subpix[0], (25, 25))
def harris_skimage(image, min_distance, num_peaks, **kwargs):
coords_subpix = np.zeros_like(image)
cornerness_matrix = sf.corner_peaks(sf.corner_harris(image), min_distance=min_distance, num_peaks=num_peaks) # larger distance -> fewer points
coords_subpix = sf.corner_subpix(image, cornerness_matrix, window_size=13, alpha=0.8) # sub pixel accuracy
draw_points(image, cornerness_matrix, coords_subpix)
print("detected points: ",cornerness_matrix.shape[0])
return cornerness_matrix, coords_subpix
def test_subpix_dot():
img = np.zeros((50, 50))
img[25, 25] = 255
corner = peak_local_max(corner_harris(img),
min_distance=10, threshold_rel=0, num_peaks=1)
subpix = corner_subpix(img, corner)
assert_array_equal(subpix[0], (25, 25))
def test_subpix():
img = np.zeros((50, 50))
img[:25,:25] = 255
img[25:,25:] = 255
corner = peak_local_max(corner_harris(img), num_peaks=1)
subpix = corner_subpix(img, corner)
assert_array_equal(subpix[0], (24.5, 24.5))
def extract_corner_harris(patch):
""" Extract four corner points using harris corner detection algorithm
"""
# Find corner with harris corner detection
coords = corner_peaks(corner_harris(patch, k=0.1), min_distance=5)
coords_subpix = corner_subpix(patch, coords, window_size=13)
# Find the nearest point for each corner
dim = patch.shape
corners = [(0, 0), (dim[0], 0), (dim[0], dim[1]), (0, dim[1])]
dest_points = [[] for x in range(4)]
for i in xrange(4):
dest_points[i] = search_closest_points(corners[i], coords_subpix)
# Check for error
try:
epsilon = 1e-10
for i in xrange(4):
for j in xrange(i + 1, 4):
if calc_distance(dest_points[i], dest_points[j]) < epsilon:
print 'Error point'
return []
except TypeError:
return []
# Reverse y,x position to x,y
for i in xrange(4):
dest_points[i][1], dest_points[i][0] = dest_points[i][0], dest_points[
i][1]
return dest_points
def kitchen_rosenfeld_skimage(image, threshold_abs_kr, min_distance, num_peaks, **kwargs):
coords_subpix = np.zeros_like(image)
cornerness_matrix = sf.corner_peaks(sf.corner_kitchen_rosenfeld(image, mode='constant'),
min_distance=min_distance, num_peaks=num_peaks,
threshold_abs=threshold_abs_kr,
threshold_rel=0.3)
coords_subpix = sf.corner_subpix(image, cornerness_matrix, window_size = 13, alpha=0.8)
print("detected points: ",cornerness_matrix.shape[0])
draw_points(image, cornerness_matrix)
return cornerness_matrix, coords_subpix
def foerstner_skimage(image, min_distance, num_peaks, **kwargs):
w, q = sf.corner_foerstner(image)
q_min = 0.9
w_min = 0.1
foerstner = (q > q_min) * (w > w_min) * w
cornerness_matrix = sf.corner_peaks(foerstner, min_distance=min_distance, num_peaks=num_peaks)
coords_subpix = sf.corner_subpix(image, cornerness_matrix, window_size=13,alpha=0.8)
draw_points(image, cornerness_matrix)
print("detected points: ",cornerness_matrix.shape[0])
return cornerness_matrix, coords_subpix
def detect_corner(img):
coords = corner_peaks(corner_harris(img), min_distance=5)
coords_subpix = corner_subpix(img, coords, window_size=13)
fig, ax = plt.subplots()
ax.imshow(img, interpolation='nearest', cmap=plt.cm.gray)
ax.plot(coords[:, 1], coords[:, 0], '.b', markersize=3)
ax.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15)
# ax.axis((0, 350, 350, 0))
plt.show()
def point_intere(image_name):
image=np.load(image_name)
c_h = corner_harris(image)
coords = corner_peaks(c_h, min_distance=1)
coords_subpix = corner_subpix(image, coords, window_size=10)
return del_dubl(my_round(coords_subpix))
def test_subpix_border():
img = np.zeros((50, 50))
img[1:25, 1:25] = 255
img[25:-1, 25:-1] = 255
corner = corner_peaks(corner_harris(img), threshold_rel=0)
subpix = corner_subpix(img, corner, window_size=11)
ref = np.array([[0.52040816, 0.52040816], [0.52040816, 24.47959184],
[24.47959184, 0.52040816], [24.5, 24.5],
[24.52040816, 48.47959184], [48.47959184, 24.52040816],
[48.47959184, 48.47959184]])
assert_almost_equal(subpix, ref)
def test_subpix_edge(dtype):
img = np.zeros((50, 50), dtype=dtype)
img[:25, :25] = 255
img[25:, 25:] = 255
corner = peak_local_max(corner_harris(img),
min_distance=10,
threshold_rel=0,
num_peaks=1)
subpix = corner_subpix(img, corner)
assert subpix.dtype == _supported_float_type(dtype)
assert_array_equal(subpix[0], (24.5, 24.5))
def corners(provider):
"""
number of corners
"""
gray = provider.as_gray()
# TODO custom parameters would give arise to exceptions of mis-matched shapes
coords = corner_peaks(corner_harris(gray))#, min_distance=5)
coords_subpix = corner_subpix(gray, coords)#, window_size=13)
return len(coords_subpix)
def checkerboard_error(img, mask, min_corners=4):
"""
Compute the "distance" between the given part of the image and a
checkerboard, using a rough estimation based on Harris corners.
In a checkerboard pattern, the immediate neighborhood of every corner
should be invariant to rotation by 180 degrees. So, compute all corners and
their neighborhoods, and build an error from the geometric mean of all
differences produced by these rotations.
"""
if img.ndim == 3:
gray = skimage.color.rgb2gray(img)
else:
gray = np.copy(img)
# Use a harris corner detector to detect the corners in the image.
coords = corner_peaks(corner_harris(gray), min_distance=5)
# Refine corners to subpixel accuracy (and then round) to make sure our
# neighborhoods are centered on the corner as much as possible.
# is needed later in the error computation).
coords = np.round(corner_subpix(gray, coords, window_size=5))
# Remove NaN corners (introduced when the refinement fails).
coords = coords[np.sum(np.isnan(coords), axis=1) == 0]
# Cast back to integer type, to be able to use these as image coordinates.
coords = coords.astype(np.int)
# Clip points that are near the edges of the mask, as these are probably
# false detections.
small_mask = morphology.binary_erosion(mask, iterations=5)
good_coords = small_mask[coords[:, 0], coords[:, 1]]
# Skip patterns that can't detect enough corners. Checkerboard patterns
# should enable easy detection of at least a few corners, and using this
# metric with a few corners lets rise to edge cases.
if np.sum(good_coords) < min_corners:
return np.inf
scores = []
# Take 5x5 neighborhoods around each pixel and subtract these
for c in coords[good_coords]:
patch = img[c[0] - 2:c[0] + 3, c[1] - 2:c[1] + 3]
diff = patch - patch[::-1, ::-1]
if diff.ndim == 3:
diff = np.linalg.norm(diff, axis=-1)
else:
diff = np.abs(diff)
scores.append(np.mean(diff))
# Compute the geometric mean carefully to avoid overflows.
log_scores = np.log(scores)
return np.exp(np.mean(log_scores))
def test_subpix_border():
img = np.zeros((50, 50))
img[1:25,1:25] = 255
img[25:-1,25:-1] = 255
corner = corner_peaks(corner_harris(img), min_distance=1)
subpix = corner_subpix(img, corner, window_size=11)
ref = np.array([[ 0.52040816, 0.52040816],
[ 0.52040816, 24.47959184],
[24.47959184, 0.52040816],
[24.5 , 24.5 ],
[24.52040816, 48.47959184],
[48.47959184, 24.52040816],
[48.47959184, 48.47959184]])
assert_almost_equal(subpix, ref)
def manipulateState(s, coordX,coordY):
if s is not None and len(s) > 0 and s[0] is not None:
if type(s[0]) == dict and 'vision' in s[0]:
vi = s[0]['vision']
mid = vi[75:75+210, 10:10+160, :]
square = mid[75+50:75+50+160, 10:10+160, :]
grey = rgb2gray(square)
coords = corner_peaks(corner_harris(grey), num_peaks=20, min_distance=5)
coords_subpix = corner_subpix(grey, coords)
num_coords = coords.shape[0]
coords_array = np.zeros((1344,2))
coords_array[:num_coords, :]=coords
return tf.reshape(coords_array, shape=[1, -1]).eval()
return np.zeros(shape=[1,84*32])
def main(argv):
image = io.imread(argv[0], True)
smooth = gaussian(image, sigma=4, mode='reflect')
binary = image > threshold_otsu(smooth)
skeleton = skeletonize_3d(invert(binary))
coords = corner_peaks(corner_harris(binary, k=0.2, sigma=4),
min_distance=5)
coords_subpix = corner_subpix(binary, coords, window_size=13)
fig, ax = plt.subplots()
ax.imshow(binary, interpolation='nearest', cmap=plt.cm.gray)
ax.plot(coords[:, 1], coords[:, 0], '+r', markersize=15)
# ax.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15)
ax.axis((0, 600, 600, 0))
plt.show()
def fast_skimage(self, image, **kwargs):
coords_subpix = np.zeros_like(image)
cornerness_matrix = sf.corner_peaks(
sf.corner_fast(image, 16,
0.8), min_distance=1) # no_of_detected_points*2
coords_subpix = sf.corner_subpix(image,
cornerness_matrix,
window_size=13,
alpha=kwargs["alpha"])
display.draw_points(image,
cornerness_matrix,
'_',
self.path[2:-1],
method_name=kwargs['method'],
name=self.name,
sp=coords_subpix)
return cornerness_matrix, coords_subpix
def shi_tomasi_skimage(self, image, **kwargs):
coords_subpix = np.zeros_like(image)
cornerness_matrix = sf.corner_peaks(sf.corner_shi_tomasi(image),
min_distance=1)
coords_subpix = sf.corner_subpix(image,
cornerness_matrix,
window_size=13,
alpha=kwargs["alpha"])
display.draw_points(image,
cornerness_matrix,
'_',
self.path[2:-1],
method_name=kwargs['method'],
name=self.name,
sp=coords_subpix)
print("detected points: ", cornerness_matrix.shape[0])
return cornerness_matrix, coords_subpix
def main(inputfilename, oututfilename):
# Load image
image = imread(inputfilename)
image = rgb2gray(image)
# Apply corner detection algorithm
corners = corner_harris(image)
coords = corner_peaks(corners, min_distance=5)
coords_subpix = corner_subpix(image, coords, window_size=13)
# Diplay the image
fig, ax = plt.subplots()
ax.imshow(image, interpolation='nearest', cmap=plt.cm.gray)
ax.plot(coords[:, 1], coords[:, 0], '.b', markersize=3)
ax.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15)
ax.axis((0, 350, 350, 0))
plt.savefig(oututfilename)
def harris_skimage(self, image, num_peaks, **kwargs):
coords_subpix = np.zeros_like(image)
cornerness_matrix = sf.corner_peaks(
sf.corner_harris(image), min_distance=1,
num_peaks=num_peaks) # larger distance -> fewer points
coords_subpix = sf.corner_subpix(
image, cornerness_matrix, window_size=13,
alpha=kwargs["alpha"]) # sub pixel accuracy
display.draw_points(image,
cornerness_matrix,
'_',
self.path[2:-1],
method_name=kwargs['method'],
name=self.name,
sp=coords_subpix,
counter=kwargs["counter"])
print("detected points: ", cornerness_matrix.shape[0])
return cornerness_matrix, coords_subpix
def forward(ob):
"""
Takes raw (768,1024,3) uint8 screen and returns list of VNC events.
The browser window indents the origin of MiniWob
by 75 pixels from top and
10 pixels from the left.
The first 50 pixels along height are the query.
"""
if ob is None: return []
x = ob['vision']
crop = x[75:75 + 50 + 160, 10:10 + 160, :] # miniwob coordinates crop
square = x[75 + 50:75 + 50 + 160, 10:10 + 160, :]
gray = rgb2gray(square)
print gray
coords = corner_peaks(corner_harris(gray), min_distance=5)
coords_subpix = corner_subpix(gray, coords, window_size=13)
for item in coords_subpix:
pass
#print item[0]+75+50,item[1]+10
newy = coords_subpix[:, 0]
newx = coords_subpix[:, 1]
newy = newy[np.logical_not(np.isnan(newy))]
newx = newx[np.logical_not(np.isnan(newx))]
#if newx == None or newy == None:
#return []
goal_y, goal_x = np.mean(newy) + 125, np.mean(newx) + 10
if math.isnan(goal_y) or math.isnan(goal_x):
return []
print goal_y, goal_x
#xcoord = np.random.randint(0, 160) + 10 # todo: something more clever here
#ycoord = np.random.randint(0, 160) + 75 + 50 # todo: something more clever here
#print ycoord,xcoord
# 1. move to x,y with left button released, and click there (2. and 3.)
action = [
universe.spaces.PointerEvent(goal_x, goal_y, 0),
universe.spaces.PointerEvent(goal_x, goal_y, 1),
universe.spaces.PointerEvent(goal_x, goal_y, 0)
]
return action
def kitchen_rosenfeld_skimage(self, image, threshold_abs_kr, **kwargs):
coords_subpix = np.zeros_like(image)
cornerness_matrix = sf.corner_peaks(sf.corner_kitchen_rosenfeld(
image, mode='constant'),
min_distance=1,
threshold_abs=threshold_abs_kr,
threshold_rel=0.3)
coords_subpix = sf.corner_subpix(image,
cornerness_matrix,
window_size=13,
alpha=kwargs["alpha"])
display.draw_points(image,
cornerness_matrix,
'_',
self.path[2:-1],
method_name=kwargs['method'],
name=self.name,
sp=coords_subpix)
print("detected points: ", cornerness_matrix.shape[0])
return cornerness_matrix, coords_subpix
def show_features(self, gd_file):
r_img = self.cp.resize_img(PIL.Image.open(gd_file),
base_width=g_prisma_image_size,
keep_size=False)
l_img = np.float32(r_img.convert('L'))
ll_img = np.float32(l_img / 255)
coords = corner_peaks(corner_harris(ll_img), min_distance=5)
coords_subpix = corner_subpix(ll_img, coords, window_size=25)
plt.figure(figsize=(8, 8))
plt.imshow(r_img, interpolation='nearest')
plt.plot(coords_subpix[:, 1],
coords_subpix[:, 0],
'+r',
markersize=15,
mew=5)
plt.plot(coords[:, 1], coords[:, 0], '.b', markersize=7)
plt.axis('off')
plt.show()
def centre_button(ob):
if ob is None:
return -1,-1
x = ob['vision']
crop = x[75:75+50+160, 10:10+160, :] # miniwob coordinates crop
square = x[75+50:75+50+160, 10:10+160, :]
gray =rgb2gray(square)
coords = corner_peaks(corner_harris(gray), min_distance=5)
coords_subpix = corner_subpix(gray, coords, window_size=13)
newy = coords_subpix[:,0]
newx = coords_subpix[:,1]
newy = newy[np.logical_not(np.isnan(newy))]
newx = newx[np.logical_not(np.isnan(newx))]
goal_y,goal_x = np.mean(newy)+125,np.mean(newx)+10
if math.isnan(goal_y) or math.isnan(goal_x) or goal_y ==None:
return -1,-1
return goal_y,goal_x
def foerstner_skimage(self, image, num_peaks, **kwargs):
w, q = sf.corner_foerstner(image)
q_min = 0.9
w_min = 0.1
foerstner = (q > q_min) * (w > w_min) * w
cornerness_matrix = sf.corner_peaks(foerstner,
min_distance=1,
num_peaks=num_peaks)
coords_subpix = sf.corner_subpix(image,
cornerness_matrix,
window_size=13,
alpha=kwargs["alpha"])
display.draw_points(image,
cornerness_matrix,
'_',
self.path[2:-1],
method_name=kwargs['method'],
name=self.name,
sp=coords_subpix)
print("detected points: ", cornerness_matrix.shape[0])
return cornerness_matrix, coords_subpix
def rotate_and_crop_image(img_path):
# open the image
img = Image.open(img_path)
date = re.findall(r'(\d\d\d\d-\d\d-\d\d_\d\d-\d\d)', img_path)[0]
imgNr = re.findall(r'(image\d).jpg', img_path)[0]
# rotate
img = img.rotate(272 - 180, resample=Image.BICUBIC,
expand=True) # rotate image
# crop
# box = (815, 1345, 920, 1380)
box = (815 - 100, 1345 - 100, 920 + 100, 1380 + 100)
img = img.crop(box)
# save rotated and cropped
saveDir = "{}/{}/cropped/".format(path_cropped_digits, date)
if not os.path.exists(saveDir):
os.makedirs(saveDir)
save_path_img_rotated = '{}/{}.png'.format(saveDir, imgNr)
img.save(save_path_img_rotated)
# load into skimage
im = io.imread(save_path_img_rotated, as_grey=True)
#canny filtering
# c1 = feature.canny(im, sigma=3)
c2 = feature.canny(im, sigma=5)
# corner detection
coords = corner_peaks(corner_harris(c2), min_distance=25)
coords_subpix = corner_subpix(c2, coords, window_size=13)
fig, ax = plt.subplots()
ax.imshow(c2, interpolation='nearest', cmap=plt.cm.gray)
ax.plot(coords[:, 1], coords[:, 0], '.b', markersize=3)
ax.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15)
# ax.axis((0, 350, 350, 0))
plt.show()
sys.exit()
def find_corners(self, image, min_distance, window_size):
"""
:param image:
:param min_distance:
:param window_size:
:return: Points identified as corners.
"""
# Locate corners, returned values are row/col coordinates (rcs).
corner_rcs = corner_peaks(corner_harris(image), min_distance)
subpix_rcs = corner_subpix(image=image,
corners=corner_rcs,
window_size=window_size)
corners = []
for i, subpix_rc in enumerate(subpix_rcs):
if np.isnan(subpix_rc).any():
corners.append((corner_rcs[i][1], corner_rcs[i][0]))
else:
corners.append((subpix_rc[1], subpix_rc[0]))
return tuple(corners)
def getCenterOfButton(s, prevX, prevY, cursorH, cursorW):
# TODO: check for RGB image
coords = corner_peaks(corner_harris(s), min_distance=2, threshold_rel=0.01)
coords_subpix = corner_subpix(s, coords, window_size=13)
#print 'coords_subpix'
for item in coords_subpix:
#print ' ', item[0],item[1],
if abs(item[0]+125 - prevY) < cursorH and abs(item[1]+10 - prevX) < cursorW:
#print 'CURSOR',
item[0] = np.nan
item[1] = np.nan
#print ''
#print '--'
newX = coords_subpix[:,1]
newY = coords_subpix[:,0]
newX = newX[np.logical_not(np.isnan(newX))]
newY = newY[np.logical_not(np.isnan(newY))]
goalX = np.mean(newX) + 10
goalY = np.mean(newY) + 125
return goalX, goalY, newX, newY
def cv_engine(img, operation):
if operation == 'to_grayscale':
return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
elif operation == 'get_edge_canny':
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
canny_edges = cv2.Canny(gray, 100, 200, 3)
return canny_edges
elif operation == 'get_edge_sobel':
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
x_edges = cv2.Sobel(gray, -1, 1, 0, ksize=5)
y_edges = cv2.Sobel(gray, -1, 0, 1, ksize=5)
edges = cv2.addWeighted(x_edges, 0.5, y_edges, 0.5, 0)
return edges
elif operation == 'get_corners':
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
from skimage.feature import corner_harris, corner_subpix, corner_peaks
from skimage import img_as_float
from skimage.draw import circle
import math
# 해리스코너 계산
image = img_as_float(gray)
corners = corner_harris(image)
# 코너 응답을 가지고 이미지에서 실제 코너 계산
coords = corner_peaks(corners, min_distance=5)
# 코너가 에지 점인지 독립된 코너인지 결정
coords_subpix = corner_subpix(image, coords, window_size=13)
image_corner = np.copy(image)
for corner in coords_subpix:
if math.isnan(corner[0]) or math.isnan(corner[1]):
continue
corner = [int(x) for x in corner]
rr, cc = circle(corner[0], corner[1], 5)
image_corner[rr, cc] = 255 # 이 점을 흰색으로
image = image * 255 + image_corner
return image
else:
return None
def corner_extraction(img_bin, axis_x, axis_y):
## Mask
down_bound = axis_x[0][1]
left_bound = axis_y[0][0]
img = np.zeros_like(img_bin)
pad_size = 2
img[:down_bound - pad_size, left_bound + pad_size:] = img_bin[:down_bound - pad_size, left_bound + pad_size:]
corners = corner_peaks(corner_harris(img, k=0.05), min_distance=20)
corners = corner_process(corners)
coords_subpix = corner_subpix(img, corners, window_size=13)
# fig, ax = plt.subplots(figsize=(10, 6), sharex=True, sharey=True)
# ax.imshow(img, cmap=cm.gray)
# ax.set_title('Corner Detection')
# ax.plot(corners[:, 1], corners[:, 0], '.b', markersize=10)
# ax.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15)
# ax.set_axis_off()
# plt.savefig('corner_plot.png')
# plt.tight_layout()
# plt.show()
return corners
img_orig = rescale_intensity(img_orig)
img_orig_gray = rgb2gray(img_orig)
# warp synthetic image
tform = AffineTransform(scale=(0.9, 0.9), rotation=0.2, translation=(20, -10))
img_warped = warp(img_orig, tform.inverse, output_shape=(200, 200))
img_warped_gray = rgb2gray(img_warped)
# extract corners using Harris' corner measure
coords_orig = corner_peaks(corner_harris(img_orig_gray), threshold_rel=0.001,
min_distance=5)
coords_warped = corner_peaks(corner_harris(img_warped_gray),
threshold_rel=0.001, min_distance=5)
# determine sub-pixel corner position
coords_orig_subpix = corner_subpix(img_orig_gray, coords_orig, window_size=10)
coords_warped_subpix = corner_subpix(img_warped_gray, coords_warped,
window_size=10)
def gaussian_weights(window_ext, sigma=1):
y, x = np.mgrid[-window_ext:window_ext+1, -window_ext:window_ext+1]
g = np.zeros(y.shape, dtype=np.double)
g[:] = np.exp(-0.5 * (x**2 / sigma**2 + y**2 / sigma**2))
g /= 2 * np.pi * sigma * sigma
return g
def match_corner(coord, window_ext=5):
r, c = np.round(coord)
window_orig = img_orig[r-window_ext:r+window_ext+1,
def getMinorMajorRatio(image): image = image.copy() # Create the thresholded image to eliminate some of the background imagethr = np.where(image > np.mean(image),0.,1.0) imagethr2 = np.where(image > np.mean(image) - 2*np.std(image),0.,1.0) #Dilate the image imdilated = morphology.dilation(imagethr, np.ones((4,4))) # Create the label list label_list = measure.label(imdilated) label_list2 = imagethr2*label_list label_list = imagethr*label_list label_list2 = label_list2.astype(int) label_list = label_list.astype(int) region_list = measure.regionprops(label_list, intensity_image=image) region_list2 = measure.regionprops(label_list2, intensity_image=image) maxregion,max2ndregion = getLargestRegions(region_list, label_list, imagethr) maxregion2,max2ndregion2 = getLargestRegions(region_list2, label_list2, imagethr2) # guard against cases where the segmentation fails by providing zeros ratio = 0.0 fillratio = 0.0 largeeigen = 0.0 smalleigen = 0.0 eigenratio = 0.0 solidity = 0.0 perimratio = 0.0 arearatio = 0.0 orientation = 0.0 centroid = (0.0,0.0) cornercenter = 0.0 cornerstd = 0.0 lrdiff = 0.0 tbdiff = 0.0 hu1 = hu2 = hu3 = hu12 = hu13 = hu23 = 0.0 whu1 = whu2 = whu3 = whu12 = whu13 = whu23 = 0.0 extent = 0.0 minintensity = maxintensity = meanintensity = 0.0 intensityratio1 = intensityratio2 = intensityratio3 = 0.0 if ((not maxregion is None) and (maxregion.major_axis_length != 0.0)): corners = corner_peaks(corner_harris(maxregion.image), min_distance=5) corners_subpix = corner_subpix(maxregion.image, corners, window_size=13) cornercentercoords = np.nanmean(corners_subpix, axis=0) cornerstdcoords = np.nanstd(corners_subpix, axis=0) ratio = 0.0 if maxregion is None else maxregion.minor_axis_length*1.0 / maxregion.major_axis_length largeeigen = 0.0 if maxregion is None else maxregion.inertia_tensor_eigvals[0] smalleigen = 0.0 if maxregion is None else maxregion.inertia_tensor_eigvals[1] fillratio = 0.0 if (maxregion2 is None or maxregion2.minor_axis_length == 0.0) else maxregion2.filled_area/(maxregion2.minor_axis_length*maxregion2.major_axis_length) solidity = 0.0 if maxregion2 is None else maxregion2.solidity hu1 = 0.0 if maxregion is None else maxregion.moments_hu[1] hu2 = 0.0 if maxregion is None else maxregion.moments_hu[2] hu3 = 0.0 if maxregion is None else maxregion.moments_hu[3] hu12 = 0.0 if (maxregion is None or hu1==0.0) else hu2/hu1 hu13 = 0.0 if (maxregion is None or hu1==0.0) else hu3/hu1 hu23 = 0.0 if (maxregion is None or hu2==0.0) else hu3/hu2 whu1 = 0.0 if maxregion is None else maxregion.weighted_moments_hu[1] whu2 = 0.0 if maxregion is None else maxregion.weighted_moments_hu[2] whu3 = 0.0 if maxregion is None else maxregion.weighted_moments_hu[3] whu12 = 0.0 if (maxregion is None or whu1==0.0) else whu2/whu1 whu13 = 0.0 if (maxregion is None or whu1==0.0) else whu3/whu1 whu23 = 0.0 if (maxregion is None or whu2==0.0) else whu3/whu2 extent = 0.0 if maxregion is None else maxregion.extent minintensity = 0.0 if maxregion is None else maxregion.min_intensity meanintensity = 0.0 if maxregion is None else maxregion.mean_intensity maxintensity = 0.0 if maxregion is None else maxregion.max_intensity intensityratio1 = 0.0 if (maxregion is None or maxintensity==0.0) else meanintensity/maxintensity intensityratio2 = 0.0 if (maxregion is None or maxintensity==0.0) else minintensity/maxintensity intensityratio3 = 0.0 if (maxregion is None or meanintensity==0.0) else minintensity/meanintensity perimratio = 0.0 if (maxregion is None or maxregion.minor_axis_length==0.0) else maxregion.perimeter/(maxregion.minor_axis_length*4.0+maxregion.major_axis_length*4.0) eigenratio = 0.0 if largeeigen == 0.0 else smalleigen/largeeigen orientation = 0.0 if maxregion is None else maxregion.orientation centroid = (0.0,0.0) if maxregion is None else maxregion.centroid cornercentercoords = np.absolute(cornercentercoords - centroid) if maxregion.major_axis_length==0.0 else np.absolute(cornercentercoords - centroid)/maxregion.major_axis_length cornercenter = np.linalg.norm(cornercentercoords) if maxregion.major_axis_length!=0.0: cornerstdcoords = np.absolute(cornerstdcoords)/maxregion.major_axis_length cornerstd = np.linalg.norm(cornerstdcoords) left = np.sum(maxregion.image[:,maxregion.image.shape[1]/2:]) if maxregion.image.shape[1] % 2 == 0: right = np.sum(maxregion.image[:,:maxregion.image.shape[1]/2]) else: right = np.sum(maxregion.image[:,:maxregion.image.shape[1]/2+1]) lrdiff = np.abs((right-left)/(right+left)) top = np.sum(maxregion.image[maxregion.image.shape[0]/2:,:]) if maxregion.image.shape[0] % 2 == 0: bottom = np.sum(maxregion.image[:maxregion.image.shape[0]/2,:]) else: bottom = np.sum(maxregion.image[:maxregion.image.shape[0]/2+1,:]) tbdiff = np.abs((top-bottom)/(top+bottom)) else: cornercentercoords = (0.0,0.0) cornerstdcoords = (0.0,0.0) if ((not maxregion is None) and (not max2ndregion is None)): arearatio = max2ndregion.area/maxregion.area #print perimratio if np.isnan(cornercenter): cornercenter = 0.0 if sum(np.isnan(cornercentercoords)) > 0.0: cornercentercoords = np.array([0.0,0.0]) if math.isnan(cornerstd): cornerstd = 0.0 if sum(np.isnan(cornerstdcoords)) > 0.0: cornerstdcoords = np.array([0.0,0.0]) return minintensity,meanintensity,maxintensity,intensityratio1,intensityratio2,intensityratio3,extent,lrdiff,tbdiff,cornercenter,cornercentercoords,cornerstd,cornerstdcoords,ratio,fillratio,eigenratio,solidity,hu1,hu2,hu3,hu12,hu13,hu23,whu1,whu2,whu3,whu12,whu13,whu23,perimratio,arearatio,orientation,centroid
from skimage.feature import corner_harris, corner_subpix, corner_peaks from matplotlib import pyplot as plt tmp = np.copy(arr_thresh[:, :, 0]) coords = corner_peaks(corner_harris(tmp), min_distance = 10) coords_subpix = corner_subpix(tmp, coords, window_size = 13) fig, ax = plt.subplots() ax.imshow(tmp, interpolation='nearest', cmap=plt.cm.gray) ax.plot(coords[:, 1], coords[:, 0], '.b', markersize=3) ax.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15) plt.show()
def getMinorMajorRatio(image):
features = {
"axisratio": 0.0,
"fillratio": 0.0,
"eigenvals": np.array([0.0, 0.0]),
"eigenratio": 0.0,
"solidity": 0.0,
"perimratio": 0.0,
"arearatio": 0.0,
"orientation": 0.0,
"centroid": np.array([0.0, 0.0]),
"wcentroiddiff": np.array([0.0, 0.0]),
"cornerctr": 0.0,
"cornerstd": 0.0,
"cornerctrcoords": np.array([0.0, 0.0]),
"cornerstdcoords": np.array([0.0, 0.0]),
"lrdiff": 0.0,
"tbdiff": 0.0,
"hu": np.zeros(7, float),
"huratios": np.zeros(3, float),
"whu": np.zeros(7, float),
"whuratios": np.zeros(3, float),
"extent": 0.0,
"minintensity": 0.0,
"meanintensity": 0.0,
"maxintensity": 0.0,
"intensityratios": np.zeros(3, float),
"vsobel": 0.0,
"hsobel": 0.0,
"felzen": 0.0,
"peaklocalmax": 0.0,
"hormean": 0.0,
"horstd": 0.0,
"vertmean": 0.0,
"vertstd": 0.0,
"horcount": 0.0,
"vertcount": 0.0,
"corners": 0.0,
"area": 0.0,
"bbox": np.zeros(4, float),
"convex_area": 0.0,
"eccentricity": 0.0,
"equivalent_diameter": 0.0,
"euler_number": 0.0,
"filled_area": 0.0,
"major_axis": 0.0,
"minor_axis": 0.0,
"moments": np.zeros(16, float),
"moments_central": np.zeros(16, float),
"moments_normalized": np.zeros(16, float),
"perimeter": 0.0,
"wcentroid": np.array([0.0, 0.0]),
"weighted_moments": np.zeros(16, float),
"weighted_moments_central": np.zeros(16, float),
"weighted_moments_normalized": np.zeros(13, float),
"original_size": 0,
}
image = image.copy()
# Create the thresholded image to eliminate some of the background
imagethr = np.where(image > np.mean(image), 0.0, 1.0)
imagethr2 = np.where(image > np.mean(image) - 2 * np.std(image), 0.0, 1.0)
# Dilate the image
imdilated = morphology.dilation(imagethr, np.ones((4, 4)))
# Create the label list
label_list = measure.label(imdilated)
label_list2 = imagethr2 * label_list
label_list = imagethr * label_list
label_list2 = label_list2.astype(int)
label_list = label_list.astype(int)
region_list = measure.regionprops(label_list, intensity_image=image)
region_list2 = measure.regionprops(label_list2, intensity_image=image)
maxregion, max2ndregion = getLargestRegions(region_list, label_list, imagethr)
maxregion2, max2ndregion2 = getLargestRegions(region_list2, label_list2, imagethr2)
# guard against cases where the segmentation fails by providing zeros
if not maxregion is None:
features["area"] = maxregion.area
features["bbox"] = maxregion.bbox
features["convex_area"] = maxregion.convex_area
features["eccentricity"] = maxregion.eccentricity
features["equivalent_diameter"] = maxregion.equivalent_diameter
features["euler_number"] = maxregion.euler_number
features["filled_area"] = maxregion.filled_area
features["major_axis"] = maxregion.major_axis_length
features["minor_axis"] = maxregion.minor_axis_length
features["moments"] = maxregion.moments.flatten()
features["moments_central"] = maxregion.moments_central.flatten()
features["moments_normalized"] = maxregion.moments_normalized.flatten()[
np.array([2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
]
features["perimeter"] = maxregion.perimeter
features["wcentroid"] = maxregion.weighted_centroid
features["weighted_moments"] = maxregion.weighted_moments.flatten()
features["weighted_moments_central"] = maxregion.weighted_moments_central.flatten()
features["weighted_moments_normalized"] = maxregion.weighted_moments_normalized.flatten()[
np.array([2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
]
corners = corner_peaks(corner_harris(maxregion.image), min_distance=5)
corners_subpix = corner_subpix(maxregion.image, corners, window_size=13)
features["cornerctrcoords"] = np.nanmean(corners_subpix, axis=0)
features["cornerstdcoords"] = np.nanstd(corners_subpix, axis=0)
features["eigenvals"] = maxregion.inertia_tensor_eigvals
features["hu"] = maxregion.moments_hu
if not features["hu"][0] == 0.0:
features["huratios"][0] = features["hu"][1] / features["hu"][0]
features["huratios"][1] = features["hu"][2] / features["hu"][0]
if not features["hu"][1] == 0.0:
features["huratios"][2] = features["hu"][2] / features["hu"][1]
features["whu"] = maxregion.weighted_moments_hu
if not features["whu"][0] == 0.0:
features["whuratios"][0] = features["whu"][1] / features["whu"][0]
features["whuratios"][1] = features["whu"][2] / features["whu"][0]
if not features["whu"][1] == 0.0:
features["whuratios"][2] = features["whu"][2] / features["whu"][1]
features["extent"] = maxregion.extent
features["minintensity"] = maxregion.min_intensity
features["meanintensity"] = maxregion.mean_intensity
features["maxintensity"] = maxregion.max_intensity
if not features["maxintensity"] == 0.0:
features["intensityratios"][0] = features["meanintensity"] / features["maxintensity"]
features["intensityratios"][1] = features["minintensity"] / features["maxintensity"]
if not features["meanintensity"] == 0.0:
features["intensityratios"][2] = features["minintensity"] / features["meanintensity"]
if not maxregion.minor_axis_length == 0.0:
features["perimratio"] = maxregion.perimeter / (
maxregion.minor_axis_length * 4.0 + maxregion.major_axis_length * 4.0
)
if not features["eigenvals"][0] == 0.0:
features["eigenratio"] = features["eigenvals"][1] / features["eigenvals"][0]
# print features['eigenratio']
features["orientation"] = maxregion.orientation
features["centroid"] = maxregion.centroid
features["wcentroiddiff"] = (
np.absolute(features["centroid"] - np.asarray(maxregion.weighted_centroid)) / maxregion.major_axis_length
)
features["cornerctrcoords"] = (
np.absolute(features["cornerctrcoords"] - features["centroid"])
if maxregion.major_axis_length == 0.0
else np.absolute(features["cornerctrcoords"] - features["centroid"]) / maxregion.major_axis_length
)
features["cornerctr"] = np.linalg.norm(features["cornerctrcoords"])
if not maxregion.major_axis_length == 0.0:
features["axisratio"] = maxregion.minor_axis_length / maxregion.major_axis_length
features["cornerstdcoords"] = np.absolute(features["cornerstdcoords"]) / maxregion.major_axis_length
features["cornerstd"] = np.linalg.norm(features["cornerstdcoords"])
left = np.sum(maxregion.image[:, maxregion.image.shape[1] / 2 :])
if maxregion.image.shape[1] % 2 == 0:
right = np.sum(maxregion.image[:, : maxregion.image.shape[1] / 2])
else:
right = np.sum(maxregion.image[:, : maxregion.image.shape[1] / 2 + 1])
features["lrdiff"] = np.abs((right - left) / (right + left))
top = np.sum(maxregion.image[maxregion.image.shape[0] / 2 :, :])
if maxregion.image.shape[0] % 2 == 0:
bottom = np.sum(maxregion.image[: maxregion.image.shape[0] / 2, :])
else:
bottom = np.sum(maxregion.image[: maxregion.image.shape[0] / 2 + 1, :])
features["tbdiff"] = np.abs((top - bottom) / (top + bottom))
if not max2ndregion is None:
features["arearatio"] = max2ndregion.area / maxregion.area
if not maxregion2 is None:
if not maxregion2.minor_axis_length == 0.0:
features["fillratio"] = maxregion2.filled_area / (
maxregion2.minor_axis_length * maxregion2.major_axis_length
)
features["solidity"] = maxregion2.solidity
if np.isnan(features["cornerctr"]):
features["cornerctr"] = 0.0
if sum(np.isnan(features["cornerctrcoords"])) > 0.0:
features["cornerctrcoords"] = np.array([0.0, 0.0])
if math.isnan(features["cornerstd"]):
features["cornerstd"] = 0.0
if sum(np.isnan(features["cornerstdcoords"])) > 0.0:
features["cornerstdcoords"] = np.array([0.0, 0.0])
return features
# HARRIS CORNER DETECTION
# corner detection is based upon the change of the position vector with respect
# to arc length.
# approximates the autocorrelation function in the direction (u, v). A measure of
# curvature is given by the minimum value obtained by considering the shifts (u, v)
# in the four main directions. That is, by (1,0), (0,−1), (0,1) and (−1,0). The minimum is chosen
# because it agrees with the following two observations. First, if the pixel is in an edge defining a
# straight line, is small for a shift along the edge and large for a shift perpendicular to
# the edge. In this case, we should choose the small value since the curvature of the edge is small.
# Secondly, if the edge defines a corner, then all the shifts produce a large value. Thus, if we also
# chose the minimum, this value indicates high curvature.
from skimage import data
import matplotlib.pyplot as plt
from skimage.feature import corner_harris, corner_subpix, corner_peaks
from skimage.transform import warp, AffineTransform
tform = AffineTransform(scale=(1.3, 1.1), rotation=0, shear=0,translation=(0,0))#
image = warp(data.coins(), tform.inverse, output_shape=(500, 500))
coords = corner_peaks(corner_harris(image), min_distance=5)
coords_subpix = corner_subpix(image, coords, window_size=13)
plt.gray()
plt.imshow(image, interpolation='nearest')
plt.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15, mew=5)
plt.plot(coords[:, 1], coords[:, 0], '.b', markersize=7)
plt.axis('off')
plt.show()
image[230 + i:280 + i, 60 + i:110 + i] = 1
t = time.time()
if int(arg1) > 1:
generate_squares()
else:
generate_squares_niave()
print "took", time.time() - t
print "finding corners"
t = time.time()
coords = corner_peaks(corner_harris(image), min_distance=5)
print "took", time.time() - t
print "getting subpix"
t = time.time()
coords_subpix = corner_subpix(image, coords, 13, 0.99)
print "took", time.time() - t
print "plotting"
plt.gray()
plt.imshow(image, interpolation='nearest')
plt.plot(coords[:, 1], coords[:, 0], '.b', markersize=3)
plt.plot(coords_subpix[:, 1], coords_subpix[:, 0], '+r', markersize=15)
plt.axis((0, 500, 500, 0))
plt.show()
def getMinorMajorRatio(image, features = features): features = features.copy() image = image.copy() # Create the thresholded image to eliminate some of the background imagethr = np.where(image > np.mean(image),0.,1.0) imagethr2 = np.where(image > np.mean(image) - 2*np.std(image),0.,1.0) #Dilate the image imdilated = morphology.dilation(imagethr, np.ones((4,4))) # Create the label list label_list = measure.label(imdilated) label_list2 = imagethr2*label_list label_list = imagethr*label_list label_list2 = label_list2.astype(int) label_list = label_list.astype(int) region_list = measure.regionprops(label_list, intensity_image=image) region_list2 = measure.regionprops(label_list2, intensity_image=image) maxregion,max2ndregion = getLargestRegions(region_list, label_list, imagethr) maxregion2,max2ndregion2 = getLargestRegions(region_list2, label_list2, imagethr2) # guard against cases where the segmentation fails by providing zeros if not maxregion is None: features['area'] = maxregion.area features['bbox'] = maxregion.bbox features['convex_area'] = maxregion.convex_area features['eccentricity'] = maxregion.eccentricity features['equivalent_diameter'] = maxregion.equivalent_diameter features['euler_number'] = maxregion.euler_number features['filled_area'] = maxregion.filled_area features['major_axis'] = maxregion.major_axis_length features['minor_axis'] = maxregion.minor_axis_length features['moments'] = maxregion.moments.flatten() features['moments_central'] = maxregion.moments_central.flatten() features['moments_normalized'] = maxregion.moments_normalized.flatten()[np.array([2,3,5,6,7,8,9,10,11,12,13,14,15])] features['perimeter'] = maxregion.perimeter features['wcentroid'] = maxregion.weighted_centroid features['weighted_moments'] = maxregion.weighted_moments.flatten() features['weighted_moments_central'] = maxregion.weighted_moments_central.flatten() features['weighted_moments_normalized'] = maxregion.weighted_moments_normalized.flatten()[np.array([2,3,5,6,7,8,9,10,11,12,13,14,15])] corners = corner_peaks(corner_harris(maxregion.image), min_distance=5) corners_subpix = corner_subpix(maxregion.image, corners, window_size=13) features['cornerctrcoords'] = np.nanmean(corners_subpix, axis=0) features['cornerstdcoords'] = np.nanstd(corners_subpix, axis=0) features['eigenvals'] = maxregion.inertia_tensor_eigvals features['hu'] = maxregion.moments_hu if not features['hu'][0] == 0.0: features['huratios'][0] = features['hu'][1]/features['hu'][0] features['huratios'][1] = features['hu'][2]/features['hu'][0] if not features['hu'][1] == 0.0: features['huratios'][2] = features['hu'][2]/features['hu'][1] features['whu'] = maxregion.weighted_moments_hu if not features['whu'][0] == 0.0: features['whuratios'][0] = features['whu'][1]/features['whu'][0] features['whuratios'][1] = features['whu'][2]/features['whu'][0] if not features['whu'][1] == 0.0: features['whuratios'][2] = features['whu'][2]/features['whu'][1] features['extent'] = maxregion.extent features['minintensity'] = maxregion.min_intensity features['meanintensity'] = maxregion.mean_intensity features['maxintensity'] = maxregion.max_intensity if not features['maxintensity'] == 0.0: features['intensityratios'][0] = features['meanintensity']/features['maxintensity'] features['intensityratios'][1] = features['minintensity']/features['maxintensity'] if not features['meanintensity'] == 0.0: features['intensityratios'][2] = features['minintensity']/features['meanintensity'] if not maxregion.minor_axis_length == 0.0: features['perimratio'] = maxregion.perimeter/(maxregion.minor_axis_length*4.0+maxregion.major_axis_length*4.0) if not features['eigenvals'][0] == 0.0: features['eigenratio'] = features['eigenvals'][1]/features['eigenvals'][0] features['orientation'] = maxregion.orientation features['centroid'] = maxregion.centroid features['wcentroiddiff'] = np.absolute(features['centroid']-np.asarray(maxregion.weighted_centroid))/maxregion.major_axis_length features['cornerctrcoords'] = np.absolute(features['cornerctrcoords'] - features['centroid']) if maxregion.major_axis_length==0.0 else np.absolute(features['cornerctrcoords'] - features['centroid'])/maxregion.major_axis_length features['cornerctr'] = np.linalg.norm(features['cornerctrcoords']) if not maxregion.major_axis_length == 0.0: features['axisratio'] = maxregion.minor_axis_length / maxregion.major_axis_length features['cornerstdcoords'] = np.absolute(features['cornerstdcoords'])/maxregion.major_axis_length features['cornerstd'] = np.linalg.norm(features['cornerstdcoords']) left = np.sum(maxregion.image[:,maxregion.image.shape[1]/2:]) if maxregion.image.shape[1] % 2 == 0: right = np.sum(maxregion.image[:,:maxregion.image.shape[1]/2]) else: right = np.sum(maxregion.image[:,:maxregion.image.shape[1]/2+1]) features['lrdiff'] = np.abs((right-left)/(right+left)) top = np.sum(maxregion.image[maxregion.image.shape[0]/2:,:]) if maxregion.image.shape[0] % 2 == 0: bottom = np.sum(maxregion.image[:maxregion.image.shape[0]/2,:]) else: bottom = np.sum(maxregion.image[:maxregion.image.shape[0]/2+1,:]) features['tbdiff'] = np.abs((top-bottom)/(top+bottom)) if not max2ndregion is None: features['arearatio'] = max2ndregion.area/maxregion.area if not maxregion2 is None: if not maxregion2.minor_axis_length == 0.0: features['fillratio'] = maxregion2.filled_area/(maxregion2.minor_axis_length*maxregion2.major_axis_length) features['solidity'] = maxregion2.solidity if np.isnan(features['cornerctr']): features['cornerctr'] = 0.0 if sum(np.isnan(features['cornerctrcoords'])) > 0.0: features['cornerctrcoords'] = np.array([0.0,0.0]) if math.isnan(features['cornerstd']): features['cornerstd'] = 0.0 if sum(np.isnan(features['cornerstdcoords'])) > 0.0: features['cornerstdcoords'] = np.array([0.0,0.0]) return features
