示例#1
0
cur_arr = cur_arr_3[:, :, 0]
from src.utils import preprocessing
import cv2
from src.utils.canny import decide_sigma

for sigma in [5]:
    for neighbor in [30]:
        blur = cv2.bilateralFilter(cur_arr.copy(), neighbor, sigma, sigma)
        showimage_pil(blur)
        cur_arr = blur
        sigma = 0.0
        r = 1
        threshold = 0.025
        while r > threshold:
            print "sigma: " + str(sigma)
            ret = my_canny(cur_arr, sigma=sigma, save=False, show=False)
            s, r = decide_sigma(ret, ret.size, threshold=threshold,show=True)
            if s is False:
                sigma += 0.5
            else:
                if sigma == 0.0 and r < 0.01:
                    sharpen = preprocessing.sharpen(blur, sigma=2)
                    cur_arr= sharpen
                    showimage_pil(sharpen)
                    r = 1

                    continue
                break

showimage_pil(ret)
parent_dir =  os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) # script directory
xray_dir = os.path.dirname(parent_dir)
os.chdir(xray_dir)
sys.path.append(parent_dir)
result_dir ='/Users/ruhansa/Desktop/result/xray/'
filenum = '1'
rawfn =  xray_dir+ '/data/' + filenum + '.jpg'
img =Image.open(rawfn)
width = img.size[0]
height = img.size[1]
arr = np.array(img.getdata(), dtype=np.uint8).reshape(height, width, 3)

## 2. do canny with ROI (TODO: Probabilisticly solve this problem)
from src.utils.canny import my_canny
fn = result_dir + filenum +'canny'
ret = my_canny(arr[:, :, 0], fn, sigma=2, save=DEBUG, show=DEBUG)
y1, x1 = 200, 150
y2, x2 = 500, 350
arr2 = np.array(ret[y1:y2, x1:x2], dtype=np.int16)
if DEBUG is True:
    temp = Image.fromarray(255*arr2.astype(np.uint8))
    temp.show()

## 3. using hough_transform to find initial horizontal line
from src.utils.hough import hough_horizontal
fn = result_dir + filenum + 'canny_hough'
lines_init = hough_horizontal(arr2, fn, hough_line_len=30, save=True, show=True, raw=img, xdiff=150, ydiff=200)


## 4. Extend line using smaller sigma (TODO: Probabilistically choose sigma)
from src.utils.util import extend_line_canny_points
示例#3
0
max_orientation, max_magnitude, max_frequency = gabor_feature_real(arr, sigmax=sigmax, sigmay=sigmay)
from src.utils.gabor import normalize
normal_gabor = normalize(max_magnitude)
fn = '/Users/ruhansa/Desktop/4.jpg'
saveimage_pil(normal_gabor, fn)
arr = filename2arr(fn)




from src.utils.canny import decide_sigma
sigma = 0.0
for i in range(5):
    print "sigma: " + str(sigma)
    ret = my_canny(arr, sigma=sigma, save=False, show=True)
    s = decide_sigma(ret, ret.size)
    if s is False:
        sigma += 0.5
    else:
        break

raw = Image.fromarray(arr)
w, h = raw.size
from src.utils.hough import my_hough_2
import math
v_hough_end = math.pi / 9
v_hough_start = - math.pi / 9
# horizontal
h_hough_end = math.pi / 2 + math.pi / 9
h_hough_start = math.pi / 2 - math.pi / 9
示例#4
0
            ROI = arr[box[1]:box[3], box[0]:box[2]]
            edges, sigma, cur_ROI= best_edges(ROI, threshold=0.02)
            # showimage_pil(edges)

            ### step3: hough
            from src.utils.hough import hough_horizontal
            fn = result_dir + '/' + testn  + 'canny_hough'
            lines_init, img3 = hough_horizontal(edges, fn=None, hough_line_len=40, line_gap=50, save=False, show=True, raw=img3, xdiff=box[0], ydiff=box[1])
            if debug is True:
                raw_input("line detect from bounding box")

            ### 4. Extend line using smaller sigma
            from src.utils.util import extend_line_points
            from src.utils.canny import my_canny
            canny1 = my_canny(cur_ROI,  sigma=(sigma-2), save=False, show=False)

            from src.utils.util import line_struct
            xdiff=box[0]
            ydiff=box[1]

            for line in lines_init:
                l = line_struct()
                l.line = [[line[0][0] + xdiff, line[0][1] + ydiff], [line[1][0] + xdiff, line[1][1] + ydiff]]
                left, right = extend_line_points(line, edges=canny1)
                if left is not -1:
                    if len(left) is not 0:
                        l.extend_pts_left = [[left[i][0] + xdiff, left[i][1] + ydiff] for i in range(len(left))]
                    if len(right) is not 0:
                        l.extend_pts_right = [[right[i][0] + xdiff, right[i][1] + ydiff] for i in range(len(right))]
                if l.getLen() <= mean and l.getLen() > mean/5:
示例#5
0
fn = result_folder + testn + '_' + clfn + '/boxes.pkl'
boxes = pickle.load(open(fn, "rb"))
"""
###############################
detect edges based on boxes
###############################
"""
from src.utils.hough import hough_horizontal, hough_vertical
from src.utils.canny import my_canny
from src.utils.preprocessing import normalize
box = boxes[2]
window = arr[box[1]+5: box[3]-5, box[0]+5: box[2]-5] # to eliminate the edge scenario
width = window.shape[1]
height = window.shape[0]
window = normalize(window)
ret = my_canny(window, sigma=0.0, save=False, show=DEBUG)
raw = Image.fromarray(np.zeros((height, width)))
lineh, raw = hough_horizontal(ret, hough_line_len=30,line_gap=50, save=False, show=True, raw=raw)
linev, raw = hough_vertical(ret,hough_line_len=30,line_gap=50, save=False, show=True, raw=raw )
raw.show()
f = np.array(raw.convert('L').getdata()).reshape(height, width)/255.

from src.utils.canny import decide_sigma
decide_sigma(f, area=width*height)

from src.utils.GVF import GVF, normalize_GVF_external_force
u, v = GVF(f, 0.2, 80)
px,py = normalize_GVF_external_force(u, v)
from src.utils.io import show_vector
line, plt = show_vector(px, 0-py, skip=6, holdon=True)
from src.utils.snake import snake_disp