예제 #1
0
def koponging(bw):
    bwr = bw.copy()
    
    # remove filler
    rollup, rolldown, rollleft, rollright = nph.roll_all(bwr)
    bwr -= bwr * rolldown * rollup * rollright * rollleft
    
    # remove zigzag
    rollup, rollright = nph.roll_up(bwr), nph.roll_right(bwr)
    rolldownleft = nph.roll_left(nph.roll_down(bwr))
    bwr -= bwr * rollup * rollright * (rolldownleft == False)
    
    rollright, rolldown = nph.roll_right(bwr), nph.roll_down(bwr)
    rollupleft = nph.roll_left(nph.roll_up(bwr))
    bwr -= bwr * rollright * rolldown * (rollupleft == False)
    
    rolldown, rollleft = nph.roll_down(bwr), nph.roll_left(bwr)
    rollupright = nph.roll_right(nph.roll_up(bwr))
    bwr -= bwr * rolldown * rollleft * (rollupright == False)
    
    rollleft, rollup = nph.roll_left(bwr), nph.roll_up(bwr)
    rolldownright = nph.roll_right(nph.roll_down(bwr))
    bwr -= bwr * rollleft * rollup * (rolldownright == False)
    
    return bwr
예제 #2
0
def get_identity(tulang):
    rollup, rolldown, rollleft, rollright = nph.roll_all(tulang)
    rollupleft = nph.roll_left(rollup)
    rollupright = nph.roll_right(rollup)
    rolldownleft = nph.roll_left(rolldown)
    rolldownright = nph.roll_right(rolldown)
    
    neighbors = tulang.astype(np.uint8)*(0+rollup+rolldown+rollleft+rollright+rollupleft+rollupright+rolldownleft+rolldownright)
    ujung_nonzero = (neighbors == 1).nonzero()
    simpangan_nonzero = (neighbors > 2).nonzero()
    
    ujung = []
    for i in range(0, ujung_nonzero[0].shape[0]):
        ujung.append((ujung_nonzero[0][i], ujung_nonzero[1][i]))
    
    simpangan = []
    for i in range(0, simpangan_nonzero[0].shape[0]):
        simpangan.append((simpangan_nonzero[0][i], simpangan_nonzero[1][i]))
    
    # remove redundant simpangan
    i = 0
    while i < len(simpangan):
        yi, xi = simpangan[i]
        j = i+1
        while j < len(simpangan):
            yj, xj = simpangan[j]
            if yi-1 <= yj <= yj+1 and xi-1 <= xj <= xi+1:
                simpangan.pop(j)
                j -= 1
            j += 1
        i += 1
    
    return (ujung, simpangan)
예제 #3
0
def gaussian(img):
    # kernel = [1, 3, 5, 3, 1]
    kernel = [1, 4, 7, 9, 7, 4, 1]
    
    kernel_count = len(kernel)
    kernel_half = (kernel_count-1)/2
    rolls = range(0, len(kernel))
    result = np.zeros(img.shape, dtype=np.float)
    
    rolls[kernel_half] = img.astype(np.float)
    for i in range(1, kernel_half+1):
        rolls[kernel_half+i] = nph.roll_left(rolls[kernel_half+i-1], img[:,-1].copy())
        rolls[kernel_half-i] = nph.roll_right(rolls[kernel_half-i+1], img[:,0].copy())
    for i in range(0, kernel_count):
        result += rolls[i] * kernel[i]
    result /= sum(kernel)
    
    rolls[kernel_half] = result.copy()
    result = 0
    for i in range(1, kernel_half+1):
        rolls[kernel_half+i] = nph.roll_up(rolls[kernel_half+i-1], img[-1].copy())
        rolls[kernel_half-i] = nph.roll_down(rolls[kernel_half-i+1], img[0].copy())
    for i in range(0, kernel_count):
        result += rolls[i] * kernel[i]
    result /= sum(kernel)
    
    return result.round().astype(np.uint8)
예제 #4
0
def create_rolls(gray, kernel):
    mid = (len(kernel)-1)/2
    
    rolls = []
    for y in kernel:
        roll = []
        for x in y:
            roll.append(gray.copy().astype(np.float))
        rolls.append(roll)
    
    for i in range(0, mid):
        for j in range(0, i+1):
            for k in range(0, len(rolls)):
                rolls[j][k][:] = nph.roll_down(rolls[j][k], rolls[mid][j][0].copy())
    
    for i in range(len(rolls)-1, mid, -1):
        for j in range(len(rolls)-1, i-1, -1):
            for k in range(0, len(rolls)):
                rolls[j][k][:] = nph.roll_up(rolls[j][k], rolls[mid][j][-1].copy())
    
    for i in range(0, mid):
        for j in range(0, i+1):
            for k in range(0, len(rolls)):
                rolls[k][j][:] = nph.roll_right(rolls[k][j], rolls[k][mid][:, 0].copy())
    
    for i in range(len(rolls)-1, mid, -1):
        for j in range(len(rolls)-1, i-1, -1):
            for k in range(0, len(rolls)):
                rolls[k][j][:] = nph.roll_left(rolls[k][j], rolls[k][mid][:, -1].copy())
    
    return rolls
예제 #5
0
def mulsum(gray, operator_baris, operator_kolom, y, x):
    rolled = np.array(gray, dtype=np.int32)
    
    if y == 0:
        rolled[:] = nph.roll_down(rolled)
    elif y == 2:
        rolled[:] = nph.roll_up(rolled)
    
    if x == 0:
        rolled[:] = nph.roll_right(rolled)
    elif x == 2:
        rolled[:] = nph.roll_left(rolled)
    
    return rolled * (operator_baris[y][x] + operator_kolom[y][x])