def process_image(path): im = Image.open(path) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda (i, x1, y1, x2, y2): (x2 - x1) * (y2 - y1)) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print '%s -> (no text!)' % path return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) text_im = im.crop(crop) return text_im
def process_image(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! _, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[ 1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. draw = ImageDraw.Draw(im) c_info = props_for_contours(contours, edges) i = 0 for c in c_info: i += 1 this_crop = c['x1'], c['y1'], c['x2'], c['y2'] t = orig_im.crop((c['x1'], c['y1'], c['x2'], c['y2'])) t.show() tex = pytesseract.image_to_string(t) if tex: print("{}:".format(i)) print(pytesseract.image_to_string(t)) # t.show() draw.rectangle(this_crop, outline='blue') draw.rectangle(crop, outline='red') im.save(out_path) draw.text((50, 50), path, fill='red') orig_im.save(out_path) im.show() text_im = orig_im.crop(crop) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def process_image(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] text_im = orig_im.crop(crop) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def reduce_noise_edges(im): structuring_element = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 1)) opening = cv2.morphologyEx(im, cv2.MORPH_OPEN, structuring_element) maxed_rows = rank_filter(opening, -4, size=(1, 20)) maxed_cols = rank_filter(opening, -4, size=(20, 1)) debordered = np.minimum(np.minimum(opening, maxed_rows), maxed_cols) return debordered
def crop_text_from_image(image): image = Image.open(image) scale, new_image = downscale(image) edges = cv2.Canny(np.asarray(new_image), 100, 200) ret, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[ 1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return image crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] text_im = image.crop(crop).convert('RGB') return text_im
def test_size_footprint_both_set(): # test for input validation, expect user warning when # size and footprint is set with suppress_warnings() as sup: sup.filter(UserWarning, "ignoring size because footprint is set") arr = np.random.random((10, 20, 30)) rank_filter(arr, 5, size=2, footprint=np.ones((1, 1, 10), dtype=bool))
def process_image(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[ 1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. #draw = ImageDraw.Draw(im) #c_info = props_for_contours(contours, edges) #for c in c_info: # this_crop = c['x1'], c['y1'], c['x2'], c['y2'] # draw.rectangle(this_crop, outline='blue') #draw.rectangle(crop, outline='red') #im.save(out_path) #draw.text((50, 50), path, fill='red') #orig_im.save(out_path) #im.show() text_im = orig_im.crop(crop) text_im = text_im.convert('RGB') bytesim = cv2.cvtColor(np.asarray(text_im), cv2.COLOR_BGR2GRAY) ret, bytesim = cv2.threshold(np.asarray(bytesim), 127, 255, cv2.THRESH_BINARY) if img_estim(bytesim, 127) == 'dark': ret, bytesim = cv2.threshold(np.asarray(text_im), 127, 255, cv2.THRESH_BINARY_INV) text_im = Image.fromarray(bytesim) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def remove_lines(_original_image, image, rank, kernel_size): maxed_rows = rank_filter(image, rank, size=(kernel_size[0], kernel_size[1])) maxed_cols = rank_filter(image, rank, size=(kernel_size[1], kernel_size[0])) return numpy.minimum(numpy.minimum(image, maxed_rows), maxed_cols)
def extract_lattice(img, filter_length=30, rank=1, size_close=5, **kwargs): """ Actual lattice extraction """ maxed_rows = rank_filter(img, -rank, size=(1, filter_length)) maxed_cols = rank_filter(img, -rank, size=(filter_length, 1)) filtered = np.maximum(np.maximum(img, maxed_rows), maxed_cols) lattice = np.minimum(maxed_rows, maxed_cols) return lattice
def dtm_rank(data, size): rmin = int(size[0] * size[1] * 0.05) rmax = int(size[0] * size[1] * 0.95) print "flter param:", rmin, rmax, size[0], size[1] rX = filters.rank_filter(data, rmin, (size[0], size[1])) rY = filters.rank_filter(data, rmin, (size[1], size[0])) rX = filters.rank_filter(rX, rmax, (size[0], size[1])) rY = filters.rank_filter(rY, rmax, (size[1], size[0])) return (rX + rY) / 2.0
def dtm_rank(data,size): rmin = int(size[0]*size[1]*0.05) rmax = int(size[0]*size[1]*0.95) print "flter param:", rmin,rmax,size[0],size[1] rX = filters.rank_filter(data,rmin,(size[0],size[1])) rY = filters.rank_filter(data,rmin,(size[1],size[0])) rX = filters.rank_filter(rX,rmax,(size[0],size[1])) rY = filters.rank_filter(rY,rmax,(size[1],size[0])) return (rX+rY)/2.0
def process_image(path, out_path): #read image orig_im = Image.open(path) #downscale image to less than 2048 scale, im = downscale_image(orig_im) #find gray scale image to find contours in it edges = cv2.Canny(np.asarray(im), 100, 200) #find contours in image contours = cv2.findContours(edges.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) contours = imutils.grab_contours(contours) #return coordinates of all boundind rectangles of contours with area greater than half the total image's area #also returns index of what contour it represents borders = find_border_components(contours, edges) #sort rectangles found based on their area borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[ 1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) #variable that will store contour for minimum area contour rectangle out of all found in previous step border_contour = None if len(borders): #find contour with min area bounding rectangle using index returned border_contour = contours[borders[0][0]] # edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges.copy()) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. # draw = ImageDraw.Draw(im) # c_info = props_for_contours(contours, edges) # for c in c_info: # this_crop = c['x1'], c['y1'], c['x2'], c['y2'] # draw.rectangle(this_crop, outline='blue') # draw.rectangle(crop, outline='red') # im.save(out_path) # draw.text((50, 50), path, fill='red') # orig_im.save(out_path) # im.show() text_im = orig_im.crop(crop) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def process_image(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) print("edges") print(edges) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) print(contours) print("edges") print(edges) borders = find_border_components(contours, edges) print("borders") print(borders) # exit() # borders.sort(key=lambda (i, x1, y1, x2, y2): (x2 - x1) * (y2 - y1)) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. #draw = ImageDraw.Draw(im) #c_info = props_for_contours(contours, edges) #for c in c_info: # this_crop = c['x1'], c['y1'], c['x2'], c['y2'] # draw.rectangle(this_crop, outline='blue') #draw.rectangle(crop, outline='red') #im.save(out_path) #draw.text((50, 50), path, fill='red') #orig_im.save(out_path) #im.show() text_im = orig_im.crop(crop) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def process_image(path, out_path_lat, out_path_long): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda (i, x1, y1, x2, y2): (x2 - x1) * (y2 - y1)) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print '%s -> (no text!)' % path return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. #draw = ImageDraw.Draw(im) #c_info = props_for_contours(contours, edges) #for c in c_info: # this_crop = c['xx1'], c['y1'], c['x2'], c['y2'] # draw.rectangle(this_crop, outline='blue') #draw.rectangle(crop, outline='red') #im.save(out_path) #draw.text((50, 50), path, fill='red') #orig_im.save(out_path) #im.show() text_im = orig_im.crop(crop) cropped_im = crop_half(text_im) cropped_im = crop_thin(cropped_im) cropped_im_lat = crop_lat(cropped_im) cropped_im_long = crop_long(cropped_im) cropped_im_lat.save(out_path_lat) cropped_im_long.save(out_path_long) print '%s -> %s' % (path, out_path_lat) print '%s -> %s' % (path, out_path_long)
def process_image(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) # TODO: it's better to convolve the image with gaussian blur # like: cv2.GaussianBlur(gray, (5, 5), 0) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! _, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) print("OK") borders.sort(key=lambda i, x1, y1, x2, y2: (x2 - x1) * (y2 - y1)) print("OK") border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered.astype(np.int32) print(edges.shape) contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. #show borders draw = ImageDraw.Draw(im) c_info = props_for_contours(contours, edges) for c in c_info: this_crop = c['x1'], c['y1'], c['x2'], c['y2'] draw.rectangle(this_crop, outline='blue') draw.rectangle(crop, outline='red') im.save(out_path) draw.text((50, 50), path, fill='red') orig_im.save(out_path) im.show() text_im = orig_im.crop(crop) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def dtm_rank2(data, size, tr): rmin = int(size[0] * size[1] * 0.05) rmax = int(size[0] * size[1] * 0.95) print "flter param:", rmin, rmax, size[0], size[1] rX = filters.rank_filter(data, rmin, (size[0], size[1])) rY = filters.rank_filter(data, rmin, (size[1], size[0])) rX = filters.rank_filter(rX, rmax, (size[0], size[1])) rY = filters.rank_filter(rY, rmax, (size[1], size[0])) diff = data - ((rX + rY) / 2.0) out = data[:, :] mask = diff > tr out[mask] = data[mask] - diff[mask] return out
def dtm_rank2i(data,size,tr): rmin = int(size[0]*size[1]*0.95) rmax = int(size[0]*size[1]*0.05) print "invert flter param:", rmin,rmax,size[0],size[1] rX = filters.rank_filter(data,rmin,(size[0],size[1])) rY = filters.rank_filter(data,rmin,(size[1],size[0])) rX = filters.rank_filter(rX,rmax,(size[0],size[1])) rY = filters.rank_filter(rY,rmax,(size[1],size[0])) diff = data-((rX+rY)/2.0) out = np.copy(data)#data[:,:] mask = diff>tr out[mask]=data[mask]+diff[mask] return out
def process_image_without_save(im, scale=1): # edges = cv2.Canny(np.asarray(im), 100, 200) im = cv2.bilateralFilter(im, 9, 25, 175) edges = cv2.Canny(im, 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! _, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda (i, x1, y1, x2, y2): (x2 - x1) * (y2 - y1)) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: # print '%s -> (no text!)' % path return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) if scale != 1: crop = [int(x / scale) for x in crop] # upscale to the original image size. # draw = ImageDraw.Draw(im) # c_info = props_for_contours(contours, edges) # for c in c_info: # this_crop = c['x1'], c['y1'], c['x2'], c['y2'] # draw.rectangle(this_crop, outline='blue') # draw.rectangle(crop, outline='red') # im.save(out_path) # draw.text((50, 50), path, fill='red') # orig_im.save(out_path) # im.show() # text_im = im.crop(crop) # Crop from x, y, w, h -> 100, 200, 300, 400 # NOTE: its img[y: y + h, x: x + w] and *not* img[x: x + w, y: y + h] # text_im = im[crop[1]: crop[3], crop[0]: crop[2]] # return text_im return crop
def process_crop_image(img): orig_im = Image.fromarray(img) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[ 1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: return img crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. #draw = ImageDraw.Draw(im) #c_info = props_for_contours(contours, edges) #for c in c_info: # this_crop = c['x1'], c['y1'], c['x2'], c['y2'] # draw.rectangle(this_crop, outline='blue') #draw.rectangle(crop, outline='red') #im.save(out_path) #draw.text((50, 50), path, fill='red') #orig_im.save(out_path) #im.show() text_im = orig_im.crop(crop) output = np.array(text_im) return output
def process_image(img): orig_im = img scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) #print edges _, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda (i, x1, y1, x2, y2): (x2-x1)*(y2-y1)) border_contour = None if len(borders): borders_contour = contours[borders[0][0]] edges = remove_border(borders_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print "No Text!" return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] text_im = orig_im.crop(crop) text_im.save("cropped.png") # text_im.ConvertToMono(255, 255, 255) text = image_to_string(text_im) if args.t: fo = open(args.t, "a") fo.write(text + "\nEnd of Slide\n\n") fo.close() else: fo = open("notes.txt", "a") fo.write(text + "\nEnd of Slide\n\n"); fo.close() print "\nI think your notes say:\n\n" print(text)
def process_image(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # Dilating image before finding a border. major = cv2.__version__.split('.')[0] if major == '3': ret, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) else: contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[ 1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_b(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove borders using a rank filter. max_rows = rank_filter(edges, -4, size=(1, 20)) max_cols = rank_filter(edges, -4, size=(20, 1)) deborder = np.minimum(np.minimum(edges, max_rows), max_cols) edges = deborder contours = find_comp(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = optimal_comp(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) # upscale to the original image size. crop = [int(x / scale) for x in crop] text_im = orig_im.crop(crop) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def dtm_rank2(data,size,tr): datat = np.copy(data) data = None rmin = int(size[0]*size[1]*0.05) rmax = int(size[0]*size[1]*0.95) # print "flter param:", rmin,rmax,size[0],size[1] rX = filters.rank_filter(datat,rmin,(size[0],size[1])) rY = filters.rank_filter(datat,rmin,(size[1],size[0])) rX = filters.rank_filter(rX,rmax,(size[0],size[1])) rY = filters.rank_filter(rY,rmax,(size[1],size[0])) diff = datat-((rX+rY)/2.0) out = datat[:,:] mask = diff>tr out[mask]=datat[mask]-diff[mask] return out
def order_statistics_filter(grid,window_size=(3,3,3),statistics_type='median',rank=1): filtered = grid.copy() if statistics_type=='minimum': scifilt.minimum_filter(grid,window_size,None,filtered, mode='nearest') elif statistics_type=='maximum': scifilt.maximum_filter(grid,window_size,None,filtered, mode='nearest') elif statistics_type=='median': scifilt.median_filter(grid,window_size,None,filtered, mode='nearest') elif statistics_type[:-2]=='percentile' or statistics_type[:-2]=='per': per = np.int(statistics_type[-2:]) scifilt.percentile_filter(grid,per,window_size,None,filtered, mode='nearest') elif statistics_type=='rank': scifilt.rank_filter(grid,rank,window_size,None,filtered, mode='nearest') return filtered return filtered
def test_rankFilter1d(): for mode in modes.keys(): size = np.random.randint(1000, 2000, [ 1, ]).item() cShape = NumCpp.Shape(1, size) cArray = NumCpp.NdArray(cShape) data = np.random.randint(100, 1000, [ size, ]).astype(float) cArray.setArray(data) kernalSize = 0 while kernalSize % 2 == 0: kernalSize = np.random.randint(5, 15) rank = np.random.randint(0, kernalSize - 1, [ 1, ]).item() constantValue = np.random.randint(0, 5, [ 1, ]).item() # only actaully needed for constant boundary condition dataOutC = NumCpp.rankFilter1d( cArray, kernalSize, rank, modes[mode], constantValue).getNumpyArray().flatten() dataOutPy = filters.rank_filter(data, rank, footprint=np.ones([ kernalSize, ]), mode=mode, cval=constantValue) assert np.array_equal(dataOutC, dataOutPy)
def do_cfar(amp, quantile=0.65): # threshold = 1.3 * rank_filter(amp, rank=int(np.ceil(1 * 32 * quantile)), size=(32, 1)) # 200 x 17 footprint = [ [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [1, 1, 1], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], ] filter_length = 10 for k in range(3): threshold = 0.9 * rank_filter(amp[k, ...], rank=int(np.ceil(1 * filter_length * quantile)), size=(filter_length, 1)) # threshold = 1.3*rank_filter(amp[k, ...], rank=int(np.count_nonzero(footprint)*quantile), footprint=footprint) # threshold = rank_filter(peaks, rank=-1, size=(3, 5)) amp[k, ...] = amp[k, ...] * (amp[k, ...] > threshold) return amp
def test_rankFilter(): for mode in modes.keys(): shape = np.random.randint(100, 200, [ 2, ]).tolist() cShape = NumCpp.Shape(shape[0], shape[1]) # noqa cArray = NumCpp.NdArray(cShape) data = np.random.randint(100, 1000, shape) # noqa cArray.setArray(data) kernalSize = 0 while kernalSize % 2 == 0: kernalSize = np.random.randint(5, 15) rank = np.random.randint(0, kernalSize**2 - 1, [ 1, ]).item() constantValue = np.random.randint(0, 5, [ 1, ]).item() # only actaully needed for constant boundary condition dataOutC = NumCpp.rankFilter(cArray, kernalSize, rank, modes[mode], constantValue).getNumpyArray() dataOutPy = filters.rank_filter(data, rank, size=kernalSize, mode=mode, cval=constantValue) assert np.array_equal(dataOutC, dataOutPy)
def process_image(img): orig_im = img #orig_im = cv2.cvtColor(np.asarray(orig_im, dtype=np.uint8), cv2.COLOR_BGR2GRAY) # orig_im = cv2.fromarray(orig_im) scale, im = downscale_image(PIL.Image.fromarray(orig_im)) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! _, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda b: (b[3] - b[1]) * (b[4] - b[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. draw = ImageDraw.Draw(im) c_info = props_for_contours(contours, edges) for c in c_info: this_crop = c['x1'], c['y1'], c['x2'], c['y2'] draw.rectangle(this_crop, outline='blue') draw.rectangle(crop, outline='red') #im.save(out_path) #draw.text((50, 50), path, fill='red') #orig_im.save(out_path) #im.show() text_im = PIL.Image.fromarray(orig_im).crop(crop) return text_im
def preprocess_image(path): # orig_im = Image.open(path) orig_im = path scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[ 1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. #Start draw = ImageDraw.Draw(im) c_info = props_for_contours(contours, edges) for c in c_info: this_crop = c['x1'], c['y1'], c['x2'], c['y2'] text_im = orig_im.crop(crop) # text_im.show() return text_im
def dtm_v3(data, rank, shape, tr): tdata = np.copy(data) data = None ranked = filters.rank_filter(tdata, rank, shape) diff = tdata - ranked tdata[diff > tr] = np.nan lerp = filters.gaussian_filter(interp(tdata), 1.2) return lerp
def dtm_v3(data,rank,shape,tr): tdata = np.copy(data) data=None ranked = filters.rank_filter(tdata,rank,shape) diff = tdata - ranked tdata[diff>tr]=np.nan lerp = filters.gaussian_filter(interp(tdata),1.2) return lerp
def process_image(path, out_path): orig_im = Image.open(path) im = cv2.imread(path, cv2.IMREAD_GRAYSCALE) scale, im = downscale_image(im) edges = cv2.Canny(im, 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! _, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -5, size=(1, 20)) maxed_cols = rank_filter(edges, -5, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. # draw and show cropped rectangle area in the original image rgb_im = orig_im.convert('RGB') draw = ImageDraw.Draw(rgb_im) draw.rectangle(crop, outline='red') rgb_im.show() text_im = orig_im.crop(crop) text_im.show() text_im.save(out_path) print('%s -> %s' % (path, out_path))
def process_image(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) image1, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda (i, x1, y1, x2, y2): (x2 - x1) * (y2 - y1)) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours, img3 = find_components(edges) if len(contours) == 0: print '%s -> (no text!)' % path return height, width = img3.shape edges2 = cv2.Canny(img3, 50, 150, apertureSize=3) Image.fromarray(edges2).show() lines2 = cv2.HoughLinesP(edges2, 1, np.pi / 180, 100, minLineLength=width / 10.0, maxLineGap=20) angle = 0.0 for linp in lines2[0]: angle += np.arctan2(linp[2] - linp[0], linp[3] - linp[1]) # cv2.imwrite('images/autorotate/houghlines.jpg', img3) imgFinal = cv2.imread(path, 0) deskewed_image = ndimage.rotate(imgFinal, angle / len(lines2[0])) cv2.imwrite(out_path, deskewed_image)
def crop_image(image): '''Crop the IMAGE, and return the croped version.''' orig_im = Image.fromarray(image) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) debugger.save_img(edges, 'edges') # TODO: dilate image _before_ finding a border. This is crazy sensitive! temp, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) debugger.display('crop_image: borders: ', borders) try: borders.sort( key=lambda area: (area[3] - area[1]) * (area[4] - area[2])) except TypeError as e: print(e) sys.exit('Cannot crop the image, exit now.') border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = 255 * (debordered > 0).astype(np.uint8) contours = find_components(edges) crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) # upscale to the original image size. crop = [int(x / scale) for x in crop] text_im = np.array(orig_im.crop(crop)) return text_im
def Page_Crop(path, out_path): orig_im = Image.open(path) orig_im = rotation_fixing(orig_im) plt.imshow(orig_im) plt.show() scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) Y = borders borders = sorted( borders, key=lambda Y: (Y[3] - Y[1]) * (Y[4] - Y[2]) ) # #{i, x1, y1, x2, y2} (x2 - x1) * (y2 - y1)) (i, x1, y1, x2, y2) : (x2 - x1) * (y2 - y1) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. text_im = orig_im.crop(crop) #text_im.save(out_path) plt.imshow(text_im) plt.show() print('Saved %s -> %s' % (path, out_path))
def process_image2(path, out_path): orig_im = Image.open(path) scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) image1, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda (i, x1, y1, x2, y2): (x2 - x1) * (y2 - y1)) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours, img3 = find_components(edges) if len(contours) == 0: print '%s -> (no text!)' % path return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. draw = ImageDraw.Draw(im) c_info = props_for_contours(contours, edges) for c in c_info: this_crop = c['x1'], c['y1'], c['x2'], c['y2'] draw.rectangle(this_crop, outline='blue') draw.rectangle(crop, outline='red') im.show() text_im = orig_im.crop(crop) text_im.save(out_path)
def process_image(frame): orig_im = frame.copy() scale, im = downscale_image(orig_im) edges = cv2.Canny(np.asarray(im), 100, 200) # TODO: dilate image _before_ finding a border. This is crazy sensitive! _, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort( key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. maxed_rows = rank_filter(edges, -4, size=(1, 20)) maxed_cols = rank_filter(edges, -4, size=(20, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) edges = debordered contours = find_components(edges) if len(contours) == 0: return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. print(crop) #cuts and shows the selected text area text_im = orig_im[crop[1]:(crop[1]+crop[3]),crop[0]:(crop[0]+crop[2])] cv2.imshow('Corte',text_im) text_string = text_recog(text_im) speech(text_string)
def process_image(path, out_path): print ('Starting...') orig_im = cv2.imread(path) im = cv2.cvtColor(orig_im, cv2.COLOR_BGR2GRAY) scale, gray = downscale_image(im) params = auto_canny (gray) edges = cv2.Canny(np.asarray(gray), params[0], params[1]) # TODO: dilate image _before_ finding a border. This is crazy sensitive! contours,hierachy=cv2.findContours(edges,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) borders = find_border_components(contours, edges) borders.sort(key=lambda i_x1_y1_x2_y2: (i_x1_y1_x2_y2[3] - i_x1_y1_x2_y2[1]) * (i_x1_y1_x2_y2[4] - i_x1_y1_x2_y2[2])) border_contour = None if len(borders): border_contour = contours[borders[0][0]] edges = remove_border(border_contour, edges) edges = 255 * (edges > 0).astype(np.uint8) # Remove ~1px borders using a rank filter. # Leave horizontal lines - JM # maxed_cols = rank_filter(edges, -4, size=(20, 1)) # debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) maxed_rows = rank_filter(edges, -4, size=(1, 20)) debordered = np.minimum(edges, maxed_rows) edges = debordered contours = find_components(edges) if len(contours) == 0: print('%s -> (no text!)' % path) return crop = find_optimal_components_subset(contours, edges) crop = pad_crop(crop, contours, edges, border_contour) crop = [int(x / scale) for x in crop] # upscale to the original image size. #draw = ImageDraw.Draw(im) #c_info = props_for_contours(contours, edges) #for c in c_info: # this_crop = c['x1'], c['y1'], c['x2'], c['y2'] # draw.rectangle(this_crop, outline='blue') #draw.rectangle(crop, outline='red') #im.save(out_path) #draw.text((50, 50), path, fill='red') #orig_im.save(out_path) #im.show() img = Image.open(path) text_im = img.crop(crop) text_im.save(out_path) print('%s -> %s' % (path, out_path))
def dtm_krauss_2015_rank(dsm,ps,minf_r,t_ps): nx,ny = dsm.shape scale = t_ps/ps nnx = int(nx/scale+0.5) nny = int(ny/scale+0.5) scale_int = int(scale+0.5) print scale print scale_int rmin = int(minf_r*minf_r*0.05) # minf = filters.minimum_filter(dsm,minf_r) minf = filters.rank_filter(dsm,rmin,(minf_r,minf_r)) dwn = cv2.resize(minf,(nny,nnx),interpolation = cv2.INTER_NEAREST) # dwn = scipy.misc.imresize(minf,(nnx,nny),interp='cubic') dwn_o = ndimage.grey_opening(dwn,5) dwn_g = filters.gaussian_filter(dwn_o,2.5) # return scipy.misc.imresize(dwn_g,(nx,ny),interp='cubic') return cv2.resize(dwn_g,(ny,nx),interpolation = cv2.INTER_CUBIC)
def brightPixelMask(self, pic, size=5, r=1.2): ''' pixels with much higher intensity compare to adjacent pixels will be masked, this mask is used when there are some bright spots/pixels whose intensity is higher than its neighbors but not too high. Only use this on a very good powder averaged data. Otherwise it may mask wrong pixels. This mask has similar functions as 'selfcorr' function. However, this mask will only consider pixels' local neighbors pixels and tend to mask more pixels. While 'selfcorr' function compare one pixel to other pixels in same bin. :param pic: 2d array, image array to be processed :param size: int, size of local area to test if a pixel is a bright pixel :param r: float, a threshold for masked pixels :return: 2d array of boolean, 1 stands for masked pixel ''' rank = snf.rank_filter(pic, -size, size) ind = snm.binary_dilation(pic > rank * r, np.ones((3, 3))) return ind
def detwfrac(swir21): """ :param swir21: :return: """ water_ref=0.008 # assumed kernel=7 mbuffer=(kernel-1)/2 row = swir21.shape[0] col = swir21.shape[1] target=np.zeros((row+2*mbuffer,col+2*mbuffer)) row = target.shape[0] col = target.shape[1] target[mbuffer-1:row-1-mbuffer,mbuffer-1:col-1-mbuffer] = swir21 perc=round(0.95*(kernel)**2.0) - 2 # finds perc value dry_ref = filters.rank_filter(np.maximum(0,target),int(perc),footprint=np.ones((kernel,kernel))) watf = np.minimum(1.0,np.maximum(0.0, (target - dry_ref)/(water_ref - dry_ref))) watf[target < 0.01] = 1.0 waterfrac = watf[mbuffer-1:row-1-mbuffer,mbuffer-1:col-1-mbuffer] return waterfrac
def preprocess_image(raw_image, threshold=0.0025, sigma=1.0, minf_size=1, rank_size=1, sobel=True): """ Applies an edge filter followed by a noise reduction filter. Very good at locating powder rings and filtering everything else out. Parameters ---------- raw_image : ndarray An image to find the edges of Returns ------- binary_image : ndarray, np.bool A binary image, with "1" where there are powder rings/strong edges """ # flatten the image into a two-D array and later re-process it # convert to cheetah-like format if raw_image.shape == (4,16,185,194): non_flat_img = True image = np.zeros((1480, 1552), dtype=np.float) # flat image for i in range(8): for j in range(4): x_start = 185 * i x_stop = 185 * (i+1) y_start = 388 * j y_stop = 388 * (j+1) two_by_one = np.hstack(( raw_image[j,i*2,:,:], raw_image[j,i*2+1,:,:])).astype(np.float) image[x_start:x_stop,y_start:y_stop] = two_by_one elif len(raw_image.shape) == 2: non_flat_img = False image = raw_image.astype(np.float) else: raise ValueError('`raw_image` should be 2d or shape-(4,16,185,194), got' ': %s' % str(raw_image.shape)) # apply rank filter & gaussian filter if rank_size > 2: image = filters.rank_filter(image, -1, size=rank_size) if sigma > 0.1: image = filters.gaussian_filter(image, sigma=sigma) image -= image.min() assert image.min() == 0 assert image.max() > 0 # threshold image = (image > (image.max() * threshold)) if minf_size > 2: image = filters.minimum_filter(image, size=minf_size) if sobel: image = np.abs(filters.sobel(image, 0)) + np.abs(filters.sobel(image, 1)) if non_flat_img: image = read.enforce_raw_img_shape( image.astype(np.bool) ) else: image = image.astype(np.bool) return image
(array2d <= np.roll(array2d, -1, 0)) & (array2d <= np.roll(array2d, 1, 1)) & (array2d <= np.roll(array2d, -1, 1))) data_scaled=data#[0::5,0::5] #data_min = data_scaled #mask_min = local_minima(data_scaled) #data_scaled[~mask_min] = np.NAN #remove small holes maxit = 3 for it in range(0,maxit): data_open = ndimage.grey_closing(data_scaled,size=(3,3)) print "small holes filled" #data_open = ndimage.grey_opening(data_scaled,size=(3,3)) data_open = filters.rank_filter(data_open,3,3) #data_open = filters.gaussian_filter(data_open,sigma=5/2.0) #data_open[np.isnan(data_open)]=-9999 #zfy = float(data.shape[0])/data_open.shape[0] #zfx = float(data.shape[1])/data_open.shape[1] #data_out = scipy.misc.imresize(data_open,(data.shape[0],data.shape[1]),interp='bilinear').astype(np.float_) #data_out=ndimage.interpolation.zoom(data_open,(zfy,zfx)) #local_min v2 #set bad_matches to nan #bad_matches=energy>0.7 #data[bad_matches]=np.NAN #resample 5x down data_dwn=np.zeros(data.shape)
def processImage(blur, lowthreshold=200, highThreshold=450, tag=""): edges = cv2.Canny(blur, lowthreshold, highThreshold) contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) cv2.drawContours(edges, contours, -1, (255, 255, 255), -1) cv2.imwrite("edges%s.png" % tag, edges) # (_, img) = cv2.threshold(edges, 110, 255, cv2.THRESH_BINARY) # cv2.imwrite('edges3%s.png' % tag,img) # scale = psegutils.estimate_scale(img) # binary = remove_hlines(img, blur, scale) # cv2.imwrite('edges4%s.png' % tag,binary*255) # binary = remove_vlines(binary, blur, scale) # edges=binary*255 # cv2.imwrite('edges2%s.png' % tag,edges) # minLineLength = 70 # maxLineGap = 50 # height, width = edges.shape # theta = 0 # lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap) # if lines is not None: # for x1,y1,x2,y2 in lines[0]: # if x2 == x1: # cv2.line(edges,(x1,0),(x1,height),(0,0,0),2) # theta = 0 # else: # tanTheta = float((y2-y1))/(x2-x1) # tmp = np.arctan2(y2-y1, x2-x1) * 180/np.pi # if tmp != 0.0 and tmp != 90.0: # theta=math.fabs(tmp) # else: # theta = 0 # print theta, y2-y1, x2-x1 # ystart=int((0-x1)*tanTheta+y1) # yend = int((width-x1)*tanTheta + y1) # cv2.line(edges,(0,ystart),(width,yend),(0,0,0),2) # cv2.imwrite('houghlines5%s.png' % tag,edges) # if theta > 85 and theta < 95: # theta = 90 - theta # elif theta < 5: # theta = -theta # elif theta > 175: # theta = 180 - theta # print tag,theta # if theta != 0: # blur = rotate(blur, theta) # cv2.imwrite('rotate%s.png' % tag,blur) # # edges = cv2.Canny(blur,200,450) # contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # cv2.drawContours(edges,contours,-1,(255,255,255),1) # cv2.imwrite('edges%s.png' % tag,edges) # # minLineLength = 70 # maxLineGap = 50 # height, width = edges.shape # theta = 0 # lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap) # for x1,y1,x2,y2 in lines[0]: # if x2 == x1: # cv2.line(edges,(x1,0),(x1,height),(0,0,0),2) # else: # tanTheta = float((y2-y1))/(x2-x1) # theta = np.arctan2(y2-y1, x2-x1) * 180/np.pi # ystart=int((0-x1)*tanTheta+y1) # yend = int((width-x1)*tanTheta + y1) # cv2.line(edges,(0,ystart),(width,yend),(0,0,0),2) # cv2.imwrite('houghlines5%s.png' % tag,edges) # kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 1)) # edges = cv2.erode(edges, kernel, iterations = 1) # kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 3)) # edges = cv2.erode(edges, kernel, iterations = 1) maxed_rows = rank_filter(edges, -4, size=(1, 30)) # vertical maxed_cols = rank_filter(edges, -4, size=(30, 1)) debordered = np.minimum(np.minimum(edges, maxed_rows), maxed_cols) # edges = debordered cv2.imwrite("edges1%s.png" % tag, edges) return edges
def moving_window_atribute(data,atribute='mean',window=(3,3,3),percentile=50,rank=1,clip_limits=(0,1),fisher=True,border_mode='nearest'): #reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’ # minimum,maximum,median,percentile,rank,mean,variance,std,clip,sum,product,peak2peak,signal2noise,skewness # kurtosis if atribute == 'minimum': atrib = data.copy() scifilt.minimum_filter(data,window,None,atrib, mode=border_mode) return atrib elif atribute == 'maximum': atrib = data.copy() scifilt.maximum_filter(data,window,None,atrib, mode=border_mode) return atrib elif atribute == 'median': atrib = data.copy() scifilt.median_filter(data,window,None,atrib, mode=border_mode) return atrib elif atribute == 'percentile': atrib = data.copy() scifilt.percentile_filter(data,percentile,window,None,atrib, mode=border_mode) return atrib elif atribute == 'rank': atrib = data.copy() scifilt.rank_filter(data,rank,window,None,atrib, mode=border_mode) return atrib elif atribute == 'mean': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): atrib[i,j,k] = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].mean() return atrib elif atribute == 'variance': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): atrib[i,j,k] = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].var() return atrib elif atribute == 'std': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): atrib[i,j,k] = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].std() return atrib elif atribute == 'clip': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): m = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].flatten() l0 = np.percentile(m,clip_limits[0]) l1 = np.percentile(m,clip_limits[1]) m.clip(l0,l1) atrib[i,j,k] = np.percentile(m,50) return atrib elif atribute == 'sum': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): atrib[i,j,k] = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].sum() return atrib elif atribute == 'product': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): atrib[i,j,k] = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].prod() return atrib elif atribute == 'peak2peak': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): atrib[i,j,k] = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].ptp() return atrib elif atribute == 'signal2noise': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): m = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].mean() v = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].std() atrib[i,j,k] = m/v return atrib elif atribute == 'skewness': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): m = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].flatten() v = st.skew(m) atrib[i,j,k] = v return atrib elif atribute == 'kurtosis': atrib = data.copy() blocks = atrib.shape for i in xrange(blocks[0]): for j in xrange(blocks[1]): for k in xrange(blocks[2]): m = data[np.clip(i-window[0],0,blocks[0]):i+window[0]+1,np.clip(j-window[1],0,blocks[1]):j+window[1]+1,np.clip(k-window[2],0,blocks[2]):k+window[2]+1].flatten() v = st.kurtosis(m,fisher=fisher) atrib[i,j,k] = v return atrib else: return False
gauss256 = data-mean_convoluted(data,86,86)#filters.gaussian_filter(lm,2.5,truncate=2) #(w - 1)/2 = int(truncate*sigma + 0.5)#trunc=sigma/((w-1)/2)+0.5 merge = (gauss8+gauss16+gauss32+gauss64+gauss128+gauss256)/6.0 """ #maskk=out-packet #out[maskk>2]=packet[maskk>2] maxit = 30 tr = 0.5#(5.0,4.0,3.0,2.5,2.0) for it in range(0,maxit): print "itrration ", it+1 packet = packet_mean(out) maskk=out-packet # out[maskk>tr[it]]=np.NAN # maskk[maskk>tr[it]]=np.NAN minf=filters.rank_filter(out,45,11)#filters.minimum_filter(out,11) minf=filters.gaussian_filter(minf,3) out[maskk>tr]=minf[maskk>tr] # out[maskk>tr]=filters.gaussian_filter(out[maskk>tr],3) # out[maskk>tr[it]]=minf[maskk>tr[it]] # out=fill(out) # out[maskk>tr[it]]=packet[maskk>tr[it]] print "tr value =", tr#[it] print "mean value =", np.mean(out) #mm=np.zeros(maskk.shape) #mm[maskk>1.2]=1 #open_square = ndimage.binary_opening(mm) #reconstruction = ndimage.binary_fill_holes(mm) #reconstruction=fill(out,