def _extract_lines(img, edges=None, mask=None, min_line_length=20, max_line_gap=3):
global __i__
__i__ += 1
if edges is None:
edges = canny(rgb2grey(img))
if mask is not None:
edges = edges & mask
# figure()
# subplot(131)
# imshow(img)
# subplot(132)
#vimshow(edges)
# subplot(133)
# if mask is not None:
# imshow(mask, cmap=cm.gray)
# savefig('/home/shared/Projects/Facades/src/data/for-labelme/debug/foo/{:06}.jpg'.format(__i__))
lines = np.array(probabilistic_hough_line(edges, line_length=min_line_length, line_gap=max_line_gap))
return lines
python类rgb2grey()的实例源码
def phash64(img):
"""Compute a perceptual hash of an image.
:param img: a rgb image to be hashed
:type img: numpy.ndarray
:return: a perceptrual hash of img coded on 64 bits
:rtype: int
"""
resized = rgb2grey(resize(img, (8, 8)))
mean = resized.mean()
boolean_matrix = resized > mean
hash_lst = boolean_matrix.reshape((1, 64))[0]
hash_lst = list(map(int, hash_lst))
im_hash = 0
for v in hash_lst:
im_hash = (im_hash << 1) | v
return im_hash
def dhash(img):
"""Compute a perceptual has of an image.
Algo explained here :
https://blog.bearstech.com/2014/07/numpy-par-lexemple-une-implementation-de-dhash.html
:param img: an image
:type img: numpy.ndarray
:return: a perceptual hash of img coded on 64 bits
:rtype: int
"""
TWOS = np.array([2 ** n for n in range(7, -1, -1)])
BIGS = np.array([256 ** n for n in range(7, -1, -1)], dtype=np.uint64)
img = rgb2grey(resize(img, (9, 8)))
h = np.array([0] * 8, dtype=np.uint8)
for i in range(8):
h[i] = TWOS[img[i] > img[i + 1]].sum()
return (BIGS * h).sum()
def get_joly_scenes_sementation(imgs, nb_std_above_mean_th=5.):
"""This function return the a list of potential scene chament segmentation without perceptual hash function.
:param imgs: the list of frames (in grayscale) of the video to segment
:param nb_std_above_mean_th: number of std above the mean of differences between frame to set a segmentation threshold
:type imgs: list(np.array)
:type nb_std_above_mean_th: float
:return: the list of indexes of begining / ending sequences...
:rtype: list(tupple)
"""
#compute diff between images
diffs = [0]
im1 = rgb2grey(resize(imgs[0], (8, 8)))
im1 = (im1 - im1.min()) / (im1.max() - im1.min()) * 255 #dynamic expension
for i in range(len(imgs) - 1):
im2 = rgb2grey(resize(imgs[i + 1], (8, 8)))
im2 = (im2 - im2.min()) / (im2.max() - im2.min()) * 255
diffs.append(abs(im1 - im2).sum())
im1 = im2
diffs = np.array(diffs)
scene_change_threshold = diffs.mean() + diffs.std() * nb_std_above_mean_th
#make the scene segmentation
scenes = []
changes = diffs > scene_change_threshold #list(bollinger(diffs, lag=5, th=nb_std_above_mean_th))
sequence_begining = 0
for i in range(len(changes)):
if changes[i]:
scenes.append((sequence_begining, i))
sequence_begining = i
return scenes
def to_grey(picture):
return color.rgb2grey(picture)
def extract_and_describe(img,kmeans):
features = daisy(rgb2grey(img), step = 4).reshape((-1,200))
assignments = kmeans.predict(features)
histogram, _= np.histogram(assignments,bins=500,range=(0,499))
return histogram
def _scharr(img):
# Invert the image to ease edge detection.
img = 1. - img
grey = skc.rgb2grey(img)
return skf.scharr(grey)
def detect_edges(filename):
"""Return a normalized gray scale image."""
LOGGER.debug(filename)
image = rgb2grey(imread(filename)) # rgb2gray can be a noop
image = image / image.max()
return canny(image, sigma=CANNY_SIGMA)
def _calc_gradient_matrix(self):
# TODO: find a better method to calc the gradient
height, width = self.working_image.shape[:2]
grey_image = rgb2grey(self.working_image)
grey_image[self.working_mask == 1] = None
gradient = np.nan_to_num(np.array(np.gradient(grey_image)))
gradient_val = np.sqrt(gradient[0]**2 + gradient[1]**2)
max_gradient = np.zeros([height, width, 2])
front_positions = np.argwhere(self.front == 1)
for point in front_positions:
patch = self._get_patch(point)
patch_y_gradient = self._patch_data(gradient[0], patch)
patch_x_gradient = self._patch_data(gradient[1], patch)
patch_gradient_val = self._patch_data(gradient_val, patch)
patch_max_pos = np.unravel_index(
patch_gradient_val.argmax(),
patch_gradient_val.shape
)
max_gradient[point[0], point[1], 0] = \
patch_y_gradient[patch_max_pos]
max_gradient[point[0], point[1], 1] = \
patch_x_gradient[patch_max_pos]
return max_gradient
def analyze_image(args):
"""Analyze all wells from all trays in one image."""
filename, config = args
LOGGER.debug(filename)
rows = config["rows"]
columns = config["columns"]
well_names = config["well_names"]
name = splitext(basename(filename))[0]
if config["parse_dates"]:
try:
index = convert_to_datetime(fix_date(name))
except ValueError as err:
return {"error": str(err), "filename": filename}
else:
index = name
try:
image = rgb2grey(imread(filename))
except OSError as err:
return {"error": str(err), "filename": filename}
plate_images = cut_image(image)
data = dict()
for i, (plate_name, plate_image) in enumerate(
zip(config["plate_names"], plate_images)):
plate = data[plate_name] = dict()
plate[config["index_name"]] = index
if i // 3 == 0:
calibration_plate = config["left_image"]
positions = config["left_positions"]
else:
calibration_plate = config["right_image"]
positions = config["right_positions"]
try:
edge_image = canny(plate_image, CANNY_SIGMA)
offset = align_plates(edge_image, calibration_plate)
# Add the offset to get the well centers in the analyte plate
well_centers = generate_well_centers(
np.array(positions) + offset, config["plate_size"], rows,
columns)
assert len(well_centers) == rows * columns
plate_image /= (1 - plate_image + float_info.epsilon)
well_intensities = [find_well_intensity(plate_image, center)
for center in well_centers]
for well, intensity in zip(well_names, well_intensities):
plate[well] = intensity
except (AttributeError, IndexError) as err:
return {"error": str(err), "filename": filename}
return data
