예제 #1
0
파일: verify.py 프로젝트: tzyLee/107-2-ITC
def prewitt_ndimage(arr):
    UINT8 = np.iinfo(np.uint8)
    x = ndimage.prewitt(arr, axis=0)
    y = ndimage.prewitt(arr)
    temp = np.hypot(x, y).clip(UINT8.min, UINT8.max).astype(np.uint8)
    set_border(temp, 255)
    return temp
예제 #2
0
def test_multiple_modes():
    # Test that the filters with multiple mode cababilities for different
    # dimensions give the same result as applying a single mode.
    arr = np.array([[1., 0., 0.],
                    [1., 1., 0.],
                    [0., 0., 0.]])

    mode1 = 'reflect'
    mode2 = ['reflect', 'reflect']

    assert_equal(sndi.gaussian_filter(arr, 1, mode=mode1),
                 sndi.gaussian_filter(arr, 1, mode=mode2))
    assert_equal(sndi.prewitt(arr, mode=mode1),
                 sndi.prewitt(arr, mode=mode2))
    assert_equal(sndi.sobel(arr, mode=mode1),
                 sndi.sobel(arr, mode=mode2))
    assert_equal(sndi.laplace(arr, mode=mode1),
                 sndi.laplace(arr, mode=mode2))
    assert_equal(sndi.gaussian_laplace(arr, 1, mode=mode1),
                 sndi.gaussian_laplace(arr, 1, mode=mode2))
    assert_equal(sndi.maximum_filter(arr, size=5, mode=mode1),
                 sndi.maximum_filter(arr, size=5, mode=mode2))
    assert_equal(sndi.minimum_filter(arr, size=5, mode=mode1),
                 sndi.minimum_filter(arr, size=5, mode=mode2))
    assert_equal(sndi.gaussian_gradient_magnitude(arr, 1, mode=mode1),
                 sndi.gaussian_gradient_magnitude(arr, 1, mode=mode2))
    assert_equal(sndi.uniform_filter(arr, 5, mode=mode1),
                 sndi.uniform_filter(arr, 5, mode=mode2))
예제 #3
0
def compute_gradients(img):
    """
    Computes the gradients of the input image in the x and y direction using a
    differentiation filter.

    ##########################################################################
    # TODO: Design a differentiation filter and update the docstring. Stick  #
    # to a pure differentiation filter for this assignment.                  #
    # Hint: Look at Slide 14 from Lecture 3: Gradients.                      #
    ##########################################################################

    Input: Grayscale image of shape (H x W)
    Outputs: gx, gy gradients in x and y directions respectively

    """
    gray = np.copy(img)
    if (len(gray) == 3):
        gray = rgb2gray(gray)


#     gx = gy = np.zeros_like(img)
    gx = -ndimage.prewitt(gray, axis=1, mode='constant')
    gy = -ndimage.prewitt(gray, axis=0, mode='constant')

    ##########################################################################
    # TODO: Design a pure differentiation filter and use correlation to      #
    # compute the gradients gx and gy. You might have to try multiple        #
    # filters till the test below passes. All the tests after will fail if   #
    # this one does not pass.                                                #
    ##########################################################################
    return gx, gy
예제 #4
0
파일: cam.py 프로젝트: yuryyu/RPI4
def findedges(image, image_file, issave):
    data = image[y0:y1, x0:x1, :]
    x, y = np.meshgrid(np.arange(data.shape[1]), np.arange(data.shape[0]))
    gaus = scimg.fourier_gaussian(data[:, :, 0], sigma=0.01)
    can_x = scimg.prewitt(gaus, axis=0)
    can_y = scimg.prewitt(gaus, axis=1)
    can = np.hypot(can_x, can_y)
    # pulling out object edges
    fig3, ax3 = plt.subplots(2, 1, figsize=(10, 7))
    ax3[0].pcolormesh(x, y, can, cmap='gist_ncar')
    bin_size = 30  # total bins to show
    percent_cutoff = 0.05  # cutoff once main peak tapers to 5% of max
    hist_vec = np.histogram(can.ravel(), bins=bin_size)
    hist_x, hist_y = hist_vec[0], hist_vec[1]
    for ii in range(np.argmax(hist_x), bin_size):
        hist_max = hist_y[ii]
        if hist_x[ii] < percent_cutoff * np.max(hist_x):
            break
    # scatter points where objects exist
    ax3[1].plot(x[can > hist_max],
                y[can > hist_max],
                marker='.',
                linestyle='',
                label='Scatter Above 5% Dropoff')
    ax3[1].set_xlim(np.min(x), np.max(x))
    ax3[1].set_ylim(np.min(y), np.max(y))
    ax3[1].legend()
    if issave:
        plt.savefig(image_file.split('.')[0] + '_edges.png')
    else:
        plt.show()
    print(hist_vec[1])
    return stat_dsp(hist_vec[1], threshold)
예제 #5
0
 def run(self, ips, snap, img, para=None):
     nimg.prewitt(snap,
                  axis={
                      'horizontal': 0,
                      'vertical': 1
                  }[para['axis']],
                  output=img)
def test_multiple_modes():
    # Test that the filters with multiple mode cababilities for different
    # dimensions give the same result as applying a single mode.
    arr = np.array([[1., 0., 0.],
                    [1., 1., 0.],
                    [0., 0., 0.]])

    mode1 = 'reflect'
    mode2 = ['reflect', 'reflect']

    assert_equal(sndi.gaussian_filter(arr, 1, mode=mode1),
                 sndi.gaussian_filter(arr, 1, mode=mode2))
    assert_equal(sndi.prewitt(arr, mode=mode1),
                 sndi.prewitt(arr, mode=mode2))
    assert_equal(sndi.sobel(arr, mode=mode1),
                 sndi.sobel(arr, mode=mode2))
    assert_equal(sndi.laplace(arr, mode=mode1),
                 sndi.laplace(arr, mode=mode2))
    assert_equal(sndi.gaussian_laplace(arr, 1, mode=mode1),
                 sndi.gaussian_laplace(arr, 1, mode=mode2))
    assert_equal(sndi.maximum_filter(arr, size=5, mode=mode1),
                 sndi.maximum_filter(arr, size=5, mode=mode2))
    assert_equal(sndi.minimum_filter(arr, size=5, mode=mode1),
                 sndi.minimum_filter(arr, size=5, mode=mode2))
    assert_equal(sndi.gaussian_gradient_magnitude(arr, 1, mode=mode1),
                 sndi.gaussian_gradient_magnitude(arr, 1, mode=mode2))
    assert_equal(sndi.uniform_filter(arr, 5, mode=mode1),
                 sndi.uniform_filter(arr, 5, mode=mode2))
예제 #7
0
 def run(self, ips, snap, img, para = None):
     if para['axis']=='both':
         img[:] =  np.abs(nimg.prewitt(snap, axis=0, output=img.dtype))
         img += np.abs( nimg.prewitt(snap, axis=1, output=img.dtype))
     else:
         nimg.prewitt(snap, axis={'horizontal':0,'vertical':1}[para['axis']], output=img)
         img[:] = np.abs(img)
     img //= 3
예제 #8
0
def prewitt(img):
    """Function to apply a prewitt filter on a given input image.

    :param img: {numpy.array} image as numpy array
    :return: {numpy.array} filtered image
    """
    sx = ndimage.prewitt(img, axis=0, mode='constant')
    sy = ndimage.prewitt(img, axis=1, mode='constant')
    prew = np.hypot(sx, sy)
    return prew
예제 #9
0
def prewitt(im):
    """
	Edge detector using a Prewitt filter
	LONG RUN!

	Arguments:
			im    - input image

	For classifier - recommended multiple runs after applying gaussian filter w sigma 1.0-16.0
	"""
    im = im.astype('int32')
    sx = ndimage.prewitt(im, axis=(im.ndim - 2), mode='constant')
    sy = ndimage.prewitt(im, axis=(im.ndim - 1), mode='constant')
    return np.hypot(sx, sy)
def doCompute():
	inlpos = xa.SI['nrinl']//2
	crlpos = xa.SI['nrcrl']//2

	while True:
		xa.doInput()
		indata = xa.Input['Input']
		xa.Output['In-line gradient'] 		= prewitt(indata, axis=0)[inlpos,crlpos,:]
		xa.Output['Cross-line gradient'] 	= prewitt(indata, axis=1)[inlpos,crlpos,:]
		xa.Output['Z gradient'] 			= prewitt(indata, axis=2)[inlpos,crlpos,:]
		xa.Output['Average Gradient']		= 	(	xa.Output['In-line gradient'] 
												+	xa.Output['Cross-line gradient']
												+ xa.Output['Z gradient'] )/3
		xa.doOutput()
def doCompute():
    #
    # index of current trace position in Input numpy array
    #
    ilndx = xa.SI["nrinl"] // 2
    crldx = xa.SI["nrcrl"] // 2
    while True:
        xa.doInput()
        xa.Output["In-line gradient"] = prewitt(xa.Input, axis=0)[ilndx, crldx, :]
        xa.Output["Cross-line gradient"] = prewitt(xa.Input, axis=1)[ilndx, crldx, :]
        xa.Output["Z gradient"] = prewitt(xa.Input, axis=2)[ilndx, crldx, :]
        xa.Output["Average gradient"] = (
            xa.Output["In-line gradient"] + xa.Output["Cross-line gradient"] + xa.Output["Z gradient"]
        ) / 3
        xa.doOutput()
예제 #12
0
def genSimpleFeatures(volume):
    return [
     ndimage.prewitt(volume),
     ndimage.sobel(volume)
    ] + \
      genBlurSharpen(volume, 2.0) + \
      genBlurSharpen(volume, 5.0)
    def edge_filters(self):
        ''' Plot five edge-filters (kernels) in grayscale
        '''

        self.gray = rgb2gray(self.im)

        self.edges = {
            'Original': self.im,
            'Grayscale': self.gray,
            'Sobel': ndimage.sobel(self.gray),
            'Prewitt': ndimage.prewitt(self.gray),
            'Laplacian': ndimage.laplace(self.gray, mode='reflect'),
            'LoG': ndimage.gaussian_laplace(self.gray, sigma=1, mode='reflect')
        }

        fig, axes = plt.subplots(2, 3, figsize=(18, 10))
        axs = iter(axes.ravel())

        for name, edge in self.edges.items():
            ax = next(axs)
            ax.imshow(edge, cmap='gray')
            ax.set_title(name)

        fig.tight_layout()

        plt.savefig('.'.join(FNAME.split('.')[:-1]) + '_processed.png')
예제 #14
0
def doCompute():
    inlpos = xa.SI['nrinl'] // 2
    crlpos = xa.SI['nrcrl'] // 2

    while True:
        xa.doInput()
        indata = xa.Input['Input']
        xa.Output['In-line gradient'] = prewitt(indata, axis=0)[inlpos,
                                                                crlpos, :]
        xa.Output['Cross-line gradient'] = prewitt(indata, axis=1)[inlpos,
                                                                   crlpos, :]
        xa.Output['Z gradient'] = prewitt(indata, axis=2)[inlpos, crlpos, :]
        xa.Output['Average Gradient'] = (xa.Output['In-line gradient'] +
                                         xa.Output['Cross-line gradient'] +
                                         xa.Output['Z gradient']) / 3
        xa.doOutput()
def doCompute():
    #
    # index of current trace position in Input numpy array
    #
    ilndx = xa.SI['nrinl'] // 2
    crldx = xa.SI['nrcrl'] // 2
    while True:
        xa.doInput()
        xa.Output['In-line gradient'] = prewitt(xa.Input, axis=0)[ilndx,
                                                                  crldx, :]
        xa.Output['Cross-line gradient'] = prewitt(xa.Input, axis=1)[ilndx,
                                                                     crldx, :]
        xa.Output['Z gradient'] = prewitt(xa.Input, axis=2)[ilndx, crldx, :]
        xa.Output['Average gradient'] = (xa.Output['In-line gradient'] +
                                         xa.Output['Cross-line gradient'] +
                                         xa.Output['Z gradient']) / 3
        xa.doOutput()
예제 #16
0
def prewitt_operator(input, threshold=3, axis=2):
    input_y = np.ndarray(shape=(np.shape(input)[1:]), dtype=np.float32)
    input_x = np.ndarray(shape=(np.shape(input)[1:]), dtype=np.float32)
    output = np.ndarray(shape=(np.shape(input)), dtype=np.float32)
    for _ in range(len(input)):
        input_y[:, :] = ndimage.prewitt(input[_, :, :], 0)
        input_x[:, :] = ndimage.prewitt(input[_, :, :], 1)
        if axis == 0:
            output[_, :, :] = input_y[:, :]
        elif axis == 1:
            output[_, :, :] = input_x[:, :]
        elif axis == 2:
            output[_, :, :] = np.sqrt(
                np.square(input_x[:, :]) + np.square(input_y[:, :]))
            output[_, :, :] = Relu_threshold(output[_, :, :],
                                             threshold=threshold)
    return output
예제 #17
0
 def prewit(self):
     from scipy.ndimage import prewitt
     img = cv2.imread(self.fileName2, 0)
     prewit = prewitt(img)
     cv2.imwrite('./sonuclar/prewitt.png', prewit)
     w, h = self.gvFiltreIslem.width() - 5, self.gvFiltreIslem.height() - 5
     self.gvFiltreIslem.setScene(
         self.show_image('./sonuclar/prewitt.png', w, h))
예제 #18
0
def hpfPrewitt(fileName,num):

    workData = getData(fileName,num)
    preFilter = ndimage.prewitt(workData)
    mfSave = Image.fromarray(preFilter)
    mfSave = mfSave.convert('1')
    mfSave.save('Prewitt Filter.png')
    imageGUI.imdisplay('Prewitt Filter.png','Prewitt',1)
예제 #19
0
def test_multiple_modes_prewitt():
    # Test prewitt filter for multiple extrapolation modes
    arr = np.array([[1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 0.0]])

    expected = np.array([[1.0, -3.0, 2.0], [1.0, -2.0, 1.0], [1.0, -1.0, 0.0]])

    modes = ["reflect", "wrap"]

    assert_equal(expected, sndi.prewitt(arr, mode=modes))
예제 #20
0
def test_multiple_modes_prewitt():
    # Test prewitt filter for multiple extrapolation modes
    arr = np.array([[1., 0., 0.], [1., 1., 0.], [0., 0., 0.]])

    expected = np.array([[1., -3., 2.], [1., -2., 1.], [1., -1., 0.]])

    modes = ['reflect', 'wrap']

    assert_equal(expected, sndi.prewitt(arr, mode=modes))
예제 #21
0
def file_controller(in_path, out_path):
    """ ---------- pre-process image ---------- """
    image = cv2.imread(in_path) 
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (3, 3), 0)

    """ ---------- create cv2 canny detections ---------- """
    start = time.time()
    cannywide = cv2.Canny(blurred, 10, 200)
    end = time.time()
    print("canny_wide: " + str(end - start))
    
    start = time.time()
    cannytight = cv2.Canny(blurred, 225, 250)
    end = time.time()
    print("canny_tight: " + str(end - start))

    start = time.time()
    cannyauto = auto_canny(blurred)              # uses auto_canny function with sigma
    end = time.time()
    print("canny_auto: " + str(end - start))

    """ ---------- create laplacian detection ---------- """
    start = time.time()
    lap = cv2.Laplacian(blurred,cv2.CV_64F)
    end = time.time()
    print("laplacian: " + str(end - start))

    """ ---------- create sobel operations ---------- """
    start = time.time()
    sobelx = cv2.Sobel(blurred,cv2.CV_64F,1,0,ksize=5)  # x
    end = time.time()
    print("sobel_x: " + str(end - start))

    start = time.time()
    sobely = cv2.Sobel(blurred,cv2.CV_64F,0,1,ksize=5)  # y
    end = time.time()
    print("sobel_y: " + str(end - start))

    """ ---------- create prewitt operator ---------- """
    start = time.time()
    prewitt = ndi.prewitt(blurred)    
    end = time.time()
    print("prewitt: " + str(end - start))

    """ ---------- write detections to files ---------- """
    start = time.time()
    cv2.imwrite(out_path + '_canny_auto.jpg', cannyauto)
    cv2.imwrite(out_path + '_canny_tight.jpg', cannytight)
    cv2.imwrite(out_path + '_canny_wide.jpg', cannywide)
    cv2.imwrite(out_path + '_laplacian.jpg', lap)
    cv2.imwrite(out_path + '_sobel_x.jpg', sobelx)
    cv2.imwrite(out_path + '_sobel_y.jpg', sobely)
    cv2.imwrite(out_path + '_prewitt.jpg', prewitt)
    end = time.time()
    print("Writing images out: " + str(end - start))
    def on_prewitt_btn_filter_clicked(self):
        from scipy.ndimage import prewitt
        img = cv2.imread(self.fileName)
        prewit = prewitt(img)

        cv2.imwrite('./islenen/prewitt.png', prewit)

        w, h = self.operationsGV_filterTab.width(
        ) - 5, self.operationsGV_filterTab.height() - 5
        self.operationsGV_filterTab.setScene(
            self.show_image('./islenen/prewitt.png', w, h))
예제 #23
0
def prewitt(in_path, out_path):
    """ Take a directory path, writes result to another path """
    print("Creating prewitt...")
    start = time.time()  # timer start

    img = image_preprocess(in_path)
    p = ndi.prewitt(img)
    cv2.imwrite(out_path + '_prewitt.jpg', p)

    end = time.time()  # timer end
    print("total time: " + str(round(end - start, 2)))
예제 #24
0
    def convolute(self, image, filtr):
        from scipy import ndimage
        if filtr == 'SOBEL':
            return ndimage.sobel(image)
        if filtr == 'GAUSSIAN':
            return ndimage.gaussian_filter(image,sigma=20)
        if filtr == 'LAPLACE':
            return ndimage.laplace(image)
        if filtr == 'UNIFORM':
            return ndimage.uniform_filter(image)
        if filtr == 'PREWITT':
            return ndimage.prewitt(image)
######################################################################
예제 #25
0
 def prewittFilterRGB(inputData):
     r = np.zeros(inputData.shape)
     g = np.zeros(inputData.shape)
     b = np.zeros(inputData.shape)
     ndimage.prewitt(inputData, axis=1, output=r)
     ndimage.prewitt(inputData, axis=0, output=g)
     ndimage.prewitt(inputData, axis=2, output=b)
     return GradientCalculation.normalize(np.concatenate((r[...,np.newaxis],g[...,np.newaxis],b[...,np.newaxis]),axis=3))
예제 #26
0
def test_multiple_modes_prewitt():
    # Test prewitt filter for multiple extrapolation modes
    arr = np.array([[1., 0., 0.],
                    [1., 1., 0.],
                    [0., 0., 0.]])

    expected = np.array([[1., -3., 2.],
                         [1., -2., 1.],
                         [1., -1., 0.]])

    modes = ['reflect', 'wrap']

    assert_equal(expected,
                 sndi.prewitt(arr, mode=modes))
예제 #27
0
def filter(img):
    #Take greyscale image of 256 * 192
    result = img
    result = nd.sobel(result)
    result = nd.prewitt(result)
    result = nd.median_filter(result, size=20)

    #Eliminate grey areas more than 190 these are white areas
    mask1 = result > 190
    mask1 = (mask1 != True)
    mask1 = mask1 * 1
    result = result * mask1

    #Return greyscale image of 256 * 192
    img = Image.fromarray(result)
    return img.convert('L')
예제 #28
0
def crFind(img, var, nsig=10., sigfrac=0.3):
    simg = img / var**0.5
    deriv = ndimage.prewitt(abs(simg))
    deriv = ndimage.sobel(deriv)

    mean, std = clip(deriv[deriv != 0.])
    crmask = numpy.where(abs(deriv) > 15 * std, 1, 0)
    crmask = ndimage.maximum_filter(crmask, 3)
    #crmask = ndimage.minimum_filter(crmask,3)
    crmask = numpy.where((crmask == 1) & (simg > 5), 1, 0)
    return crmask
    thresh = nsig * var**0.5
    n = 5
    blkimg = img.repeat(n, 0).repeat(n, 1)
    deriv = ndimage.laplace(blkimg) * -1.
    deriv[deriv < 0] = 0.
    d = iT.resamp(deriv, n)
    m = numpy.where((d > thresh) & (img > thresh), 1, 0)
    bmap = ndimage.maximum_filter(m, 5)
    cond = (bmap == 1) & (d > thresh * sigfrac) & (img > thresh * sigfrac)
    m[cond] = 1
    return m
예제 #29
0
파일: image.py 프로젝트: hanyang7427/study
import numpy as np
import scipy.misc as sm
import scipy.ndimage as sn
import matplotlib.pyplot as mp
# 加载图像
image1 = sm.ascent().astype(np.float32)
# 均值滤波
image2 = sn.median_filter(image1, (42, 42))
# 旋转图像
image3 = sn.rotate(image1, angle=45)
# 浮雕图像
image4 = sn.prewitt(image1)
mp.gcf().set_facecolor(np.ones(3) * 240 / 255)
mp.subplot(221)
mp.title('Original', fontsize=16)
mp.xlabel('Width', fontsize=12)
mp.ylabel('Height', fontsize=12)
ax = mp.gca()
ax.xaxis.set_major_locator(mp.MultipleLocator(128))
ax.xaxis.set_minor_locator(mp.MultipleLocator(32))
ax.yaxis.set_major_locator(mp.MultipleLocator(128))
ax.yaxis.set_minor_locator(mp.MultipleLocator(32))
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
mp.imshow(image1, cmap='gray')
mp.subplot(222)
mp.title('Median', fontsize=16)
mp.xlabel('Width', fontsize=12)
mp.ylabel('Height', fontsize=12)
ax = mp.gca()
ax.xaxis.set_major_locator(mp.MultipleLocator(128))
예제 #30
0
mp.axis('off')
mp.imshow(original, cmap='gray')
# #高斯模糊
median = sn.median_filter(original, 10)
mp.subplot(2, 2, 2)
mp.axis('off')
mp.imshow(median, cmap='gray')
print(median)
#旋转
median1 = sn.rotate(original, 45)
mp.subplot(2, 2, 3)
mp.axis('off')
mp.imshow(median1, cmap='gray')
print(median1)
#边缘识别
prewitt = sn.prewitt(original)
mp.subplot(2, 2, 4)
mp.axis('off')
mp.imshow(prewitt, cmap='gray')
print(prewitt)

# #角度旋转
# rotate = sn.rotate(original, 45)
# #边缘识别
# prewitt = sn.prewitt(original)
# mp.figure('Image', facecolor='lightgray')
# mp.subplot(221)
# mp.title('Original', fontsize=16)
# mp.axis('off')
# mp.imshow(original, cmap='gray')
# mp.subplot(222)
예제 #31
0
    def __init__(self,
                 image_matrix,
                 sigma=1.0,
                 thresHigh=40,
                 thresLow=6,
                 thresHighLimit=2**18):

        self.imin = image_matrix
        self.thresHigh = thresHigh
        self.thresLow = thresLow

        mask = numpy.ones(self.imin.shape, dtype=bool)
        fsmooth = lambda x: gaussian_filter(x, sigma, mode='constant')
        imout = smooth_with_function_and_mask(self.imin, fsmooth, mask)

        grady = ndi.prewitt(imout, axis=1, mode='constant') * -1.0
        gradx = ndi.prewitt(imout, axis=0, mode='constant')

        grad = numpy.hypot(gradx, grady)

        # Net gradient is the square root of sum of square of the horizontal
        # and vertical gradients

        # grad = numpy.hypot(gradx, grady)
        theta = numpy.arctan2(grady, gradx)
        theta = 180 + (180 / pi) * theta
        # Only significant magnitudes are considered. All others are removed
        x, y = where(grad < 10)
        theta[x, y] = 0
        grad[x, y] = 0

        # The angles are quantized. This is the first step in non-maximum
        # supression. Since, any pixel will have only 4 approach directions.
        x0, y0 = where(((theta < 22.5) + (theta >= 157.5) * (theta < 202.5) +
                        (theta >= 337.5)) == True)
        x45, y45 = where(((theta >= 22.5) * (theta < 67.5) + (theta >= 202.5) *
                          (theta < 247.5)) == True)
        x90, y90 = where(((theta >= 67.5) * (theta < 112.5) +
                          (theta >= 247.5) * (theta < 292.5)) == True)
        x135, y135 = where(((theta >= 112.5) * (theta < 157.5) +
                            (theta >= 292.5) * (theta < 337.5)) == True)

        # self.theta = theta
        # Image.fromarray(self.theta).convert('L').save('Angle map.jpg')
        theta[x0, y0] = 0.
        theta[x45, y45] = 45.
        theta[x90, y90] = 90.
        theta[x135, y135] = 135.

        self.grad = grad[1:-1, 1:-1]
        self.theta = theta[1:-1, 1:-1]

        x, y = self.grad.shape
        grad2 = self.grad.copy()

        for i in range(x):
            for j in range(y):

                if self.theta[i, j] == 0.:
                    test = self.nms_check(grad2, i, j, 1, 0, -1, 0)
                    if not test:
                        self.grad[i, j] = 0

                elif self.theta[i, j] == 45.:
                    test = self.nms_check(grad2, i, j, 1, -1, -1, 1)
                    if not test:
                        self.grad[i, j] = 0

                elif self.theta[i, j] == 90.:
                    test = self.nms_check(grad2, i, j, 0, 1, 0, -1)
                    if not test:
                        self.grad[i, j] = 0
                elif self.theta[i, j] == 135.:
                    test = self.nms_check(grad2, i, j, 1, 1, -1, -1)
                    if not test:
                        self.grad[i, j] = 0

        init_point = self.initPt(thresHighLimit)
        # Hysteresis tracking. Since we know that significant edges are
        # continuous contours, we will exploit the same.
        # thresHigh is used to track the starting point of edges and
        # thresLow is used to track the whole edge till end of the edge.

        self.segments = Segments.Segments()
        segment = [init_point]

        while init_point != -1:
            # print 'next segment at',init_point
            self.grad[init_point[0], init_point[1]] = -1
            p2 = init_point
            p1 = init_point
            p0 = init_point
            p0 = self.nextNbd(p0, p1, p2)

            while p0 != -1:
                segment.append(p0)
                p2 = p1
                p1 = p0
                self.grad[p0[0], p0[1]] = -1
                p0 = self.nextNbd(p0, p1, p2)

            if len(segment) >= 2:
                self.segments.append(segment)

            init_point = self.nextPt(self.grad)
            segment = [init_point]

        self.stippleSegmentList = []
# different edge detection methods
cam.capture(data, 'rgb')  # capture image
# diff of gaussians
t0 = time.time()
grad_xy = scimg.gaussian_gradient_magnitude(data[:, :, 0], sigma=1.5)
##grad_xy = np.mean(grad_xy,2)
t_grad_xy = time.time() - t0
# laplacian of gaussian
t0 = time.time()
lap = scimg.gaussian_laplace(data[:, :, 0], sigma=0.7)
t_lap = time.time() - t0
# Canny method without angle
t0 = time.time()
gaus = scimg.fourier_gaussian(data[:, :, 0], sigma=0.05)
can_x = scimg.prewitt(gaus, axis=0)
can_y = scimg.prewitt(gaus, axis=1)
can = np.hypot(can_x, can_y)
##can = np.mean(can,2)
t_can = time.time() - t0
# Sobel method
t0 = time.time()
sob_x = scimg.sobel(data[:, :, 0], axis=0)
sob_y = scimg.sobel(data[:, :, 0], axis=1)
sob = np.hypot(sob_x, sob_y)
##sob = np.mean(sob,2)
t_sob = time.time() - t0

# plotting routines and labeling
fig, ax = plt.subplots(2, 2, figsize=(12, 6))
ax[0, 0].pcolormesh(x, y, grad_xy, cmap='gray')
예제 #33
0
 def eval(self, source_data):
     return ndimage.prewitt(source_data, *self.args, **self.kwargs)
예제 #34
0
dataDir = "/home/arb/Delme/"
plt.imshow(griddata, origin='lower')

plt.gray()
cb = plt.colorbar()
cb.set_label('Value Range')
plt.xlabel('GridEast')
plt.ylabel('GridNorth')
plt.suptitle('Raw data')
plt.savefig(dataDir + 'r15_raw' + '.png')
plt.show()

#Calculate derivatives
gridSobel = nd.sobel(griddata)
gridLaplace = nd.laplace(griddata)
gridPrewitt = nd.prewitt(griddata)
gridGaussian = nd.gaussian_filter(griddata, 1)
gridMinimum = nd.minimum_filter(griddata, size=(3, 3))

#Plot a derivative
plt.imshow(gridGaussian, origin='lower')
plt.gray()
#show image
cb = plt.colorbar()
cb.set_label('Value Range')
plt.xlabel('GridEast')
plt.ylabel('GridNorth')
plt.suptitle('Raw data')
plt.savefig(dataDir + 'r15_gaussianDerivative' + '.png')
plt.show()
예제 #35
0
img = plt.imshow(image, cmap=plt.cm.gray)
#中值滤波器扫描信息的每一个数据点,并替换为相邻数据点的中值。对
#图像应用中值滤波器并显示在第二个子图中
plt.subplot(222)
plt.title("Median Filter")
filtered = ndimage.median_filter(image, size=(42, 42))
plt.imshow(filtered, cmap=plt.cm.gray)
#旋转图像并显示在第三个子图中
plt.subplot(223)
plt.title("Rotated")
rotated = ndimage.rotate(image, 90)
plt.imshow(rotated, cmap=plt.cm.gray)
#Prewitt滤波器是基于图像强度的梯度计算
plt.subplot(224)
plt.title("Prewitt Filter")
filtered = ndimage.prewitt(image)
plt.imshow(filtered, cmap=plt.cm.gray)
plt.show()

print u"音频处理"
#使用scipy.io.wavfile模块中的read函数可以将该文件转换为一个NumPy
#数组
#使用read函数读入文件,返回采样率和音频数据
from scipy.io import wavfile
import urllib2
import sys

sample_rate, data = wavfile.read(WAV_FILE)
#应用tile函数
repeated = np.tile(data, 4)
#使用write函数写入一个新文件
예제 #36
0
def sky_ref_patch_detection(I_origin):
    """
    RETURN:
    S: list:[Sb, Sg, Sr]
    sky_prob_map
    """
    I_gray = cv2.cvtColor(I_origin, cv2.COLOR_BGR2GRAY)
    sky_prob_map = np.zeros(I_gray.shape)
    # initialize sky prob map with pixels strictly within ideal blue range
    sky_prob_map[ in_idea_blue_rg(I_origin) ] = 1.0
    # sky is ONLY in top one third
    # sky_prob_map[sky_prob_map.shape[0]*1.0/3:-1,...] = 0.0

    # exponentially decrease sky prob where gradient is too large (>_grad_percent*255.)
    _grad_x = np.absolute( ndi.prewitt(I_gray, axis=1 ,mode='nearest') )
    _grad_y = np.absolute( ndi.prewitt(I_gray, axis=0 ,mode='nearest') )
    _rv = norm(loc=0., scale=255./3.) # 3*sigma = 255, rv ~ random variable

    _grad_percent = 0.10 # 0.05 of the original paper
    cond_mod_sky_prob = (sky_prob_map ==1.0) & \
                        ((_grad_x >_grad_percent*255.) | (_grad_y >_grad_percent*255.)) # average of gradx, y
    sky_prob_map[ cond_mod_sky_prob ] = _rv.pdf( (_grad_x + _grad_y)/2.0 )[ cond_mod_sky_prob ]

    # detect bimodal
    _L = cv2.cvtColor(I_origin, cv2.COLOR_BGR2LAB)[...,0]
    detect_res = cape_util.detect_bimodal(
        [cape_util.get_smoothed_hist( cape_util.mask_skin(_L, sky_prob_map!=0.0) )]
    )[0] # detect_bimodal is an array f
    if (detect_res[0] == True): #could return F or None, must be ==True
        print 'bimodal detected in current sky_ref_patch'
        sky_prob_map[ I_gray ==detect_res[1] ] = 0.0 #exclude pixels correspond to the dark mode

    # get mean and std from each b,g,r channel of detected sky
    S = []
    if ( np.sum( _get_top_one_third(sky_prob_map) ) !=0): # top 1/3 has sky
        sky_prob_map_bgr = _2to3(sky_prob_map)
        for i in range(3): #B, G, R
            masked_I_one_thrid = cape_util.mask_skin( # mask non-blue area 0, copy the rest
                _get_top_one_third(I_origin)[...,i]
                , _get_top_one_third(sky_prob_map)!=0.0 # sky_prob map changed after previous step
            )
            mean, std = get_sky_ref_patch( masked_I_one_thrid, sky_prob_map )
            S.append(mean)
            _rv_sky_patch = norm(loc=mean, scale=std)

            # re-assign (where sky prob>0), normalize to p(median) = 1.0
            sky_prob_map_bgr[...,i][sky_prob_map>0.0] = \
                _rv_sky_patch.pdf(I_origin[...,i])[sky_prob_map>0.0] / _rv_sky_patch.pdf(mean)
        _b=1.; _g=5.; _r=3.
        sky_prob_map = (_b*sky_prob_map_bgr[...,0] + _g*sky_prob_map_bgr[...,1] + _r*sky_prob_map_bgr[...,2]) / (_b+_g+_r)

        # remove small patches: image opening on sky_prob_map
        _h,_w = sky_prob_map.shape[0:2]
        _kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(_h/12,_w/16))
        sky_mask_opened = cv2.morphologyEx(sky_prob_to_01(sky_prob_map).astype('uint8'), cv2.MORPH_OPEN, _kernel)
        sky_prob_map[sky_mask_opened==0.0] = 0.0 # set sky_prob_map to 0 where removed from sky_mask_opened
    else:
        print 'sky not detected in top 1/3'

    plt.imshow(sky_prob_map); plt.show() # rainbow map
    print 'S(b,g,r): ',S
    return S, sky_prob_map
예제 #37
0
 def run(self, ips, img, buf, para=None):
     nimg.prewitt(img, output=buf)
예제 #38
0
import numpy as np
import matplotlib.pyplot as plt
from scipy import ndimage


image = misc.lena().astype(np.float32)

plt.subplot(221)
plt.title("Original Image") 
img = plt.imshow(image, cmap=plt.cm.gray) 
plt.axis("off")

plt.subplot(222) 
plt.title("Median Filter") 
filtered = ndimage.median_filter(image, size=(42,42))
plt.imshow(filtered, cmap=plt.cm.gray) 
plt.axis("off")

plt.subplot(223) 
plt.title("Rotated") 
rotated = ndimage.rotate(image, 90)
plt.imshow(rotated, cmap=plt.cm.gray) 
plt.axis("off")

plt.subplot(224) 
plt.title("Prewitt Filter") 
filtered = ndimage.prewitt(image)
plt.imshow(filtered, cmap=plt.cm.gray) 
plt.axis("off")
plt.show()
예제 #39
0
파일: image.py 프로젝트: jiangxinly02/scipy
def prewitt_image(image):
    return sn.prewitt(image)
예제 #40
0
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import BaggingClassifier
from scipy import ndimage

from sklearn import linear_model
import matplotlib.pyplot as plt

Targets = np.genfromtxt("data/targets.csv")

Data = []
for i in range(1, 279):
    imagefile = nib.load("data/set_train/train_" + str(i) + ".nii")
    image = imagefile.get_data()
    I = image[:, :, :, 0]
    I = np.asarray(I, dtype='float')
    I = ndimage.prewitt(I, axis=0)
    I = ndimage.gaussian_filter(I, sigma=1)
    imagefile.uncache()
    Data.append(np.asarray(I))

Data = np.asarray(Data)

X_train, X_test, y_train, y_test = \
    train_test_split(Data, Targets, test_size=0.33, random_state=42, stratify=Targets)

#X_train = Data
#y_train = Targets

print "fitting has started"

clf = linear_model.LogisticRegression()
예제 #41
0
파일: relief.py 프로젝트: nix/mapsaw
def reliefshade(deminfo, dem, surface):

    vertical_exaggeration = 2.0
    # light_gamma < 1 brings out detail in the flats, hides it in hills facing the lightsource
    light_gamma = 0.9
    light_level = 0.5
    # shade_gamma > 1 brings out detail in darkest slopes at the expense of some gentle ones
    shade_gamma = 2.0
    shade_level = 0.5
    # imhof sez the light is golden - #fffbf4 maybe?
    # and the shade is purple - #060009 maybe?
    #lightcolor = (1.0, 0.98, 0.95)
    #shadecolor = (1.0, 0.98, 0.95)
    #shadecolor = (0.7, 0.8, 1.0)
    #lightcolor = (1.0, 1.0, 1.0)
    lightcolor = (1.0, 1.0, 0.9)
    shadecolor = (1.0, 1.0, 1.0)
    #shadecolor = (0.8, 0.8, 1.0)

    # scale adjusts for horizontal and vertical units as well as
    # any height exaggeration.
    scale = vertical_exaggeration / deminfo.grid.meters_per_grid()

    # 2d prewitt filter kernel with axis=1 is [[-1, 0, 1]
    #                                          [-1, 0, 1]
    #                                          [-1, 0, 1]]
    dvdx = scale * ndimage.prewitt(dem, axis=1, mode='nearest')
    dvdy = -scale * ndimage.prewitt(dem, axis=0, mode='nearest')

    #glumpy_loop(N.outer(dvdx, (1,1,1)).reshape(surface.shape))

    # the idea of separating light and shadow is from lars
    #  ahlzen's toposm work, this is slightly different.

    # normal vector is (-dvdx, -dvdy, 1)
    #  norm of normal is sqrt(dvdx * dvdx + dvdy * dvdy + 1)
    # vector toward light is (-1, 1, 1)
    #  norm of light vector sqrt(3)
    norm = N.sqrt(3 * (dvdx * dvdx + dvdy * dvdy + 1))
    
    # light_dir = (-1, 1, 1)
    # cos(theta) = light_dir . normal / |normal| |light_dir|
    #
    costh = (dvdx - dvdy + 1) / norm

    # separate into illumination and (self-)shadow

    # costh_level is costh for a horizontal surface.  anything brighter
    #  than this is light, anything darker is shade.
    # this is (light=0,shade=1)
    costh_level = 1.0 / sqrt(3)

    # the minimum possible costh is for a cliff facing southwest
    #  which would have dvdx=-BIG and dvdy=+BIG.  plug that into
    #  the costh formula and you get -sqrt(2/3)
    # this is the darkest possible shade (light=0,shade=0)
    costh_min = -sqrt(2.0 / 3.0)

    # light is 1.0 for a surface pointing sunward and 0.0 at horizontal
    light = N.clip((costh - costh_level) / (1 - costh_level), 0, 1)
    light = light ** (1/light_gamma)

    # shade is 1.0 for horizontal and 0.0 for a vertical cliff facing
    #   away from the lightsource.
    # note that shade=0 is still darkest, 1 is lightest
    shade = N.clip((costh-costh_min) / (costh_level-costh_min), 0, 1)
    shade = shade ** (1/shade_gamma)

    # this would be a great place for a "tone mapping" like step
    # to adapt the relief to meadows or mountains.

    #  N.outer flattens so must reshape to rgb afterward
    light = N.outer(light, lightcolor).reshape(surface.shape)
    shade = N.outer(shade, shadecolor).reshape(surface.shape)

    # moderate the effect of light and shade here
    light = light * light_level
    shade = shade * shade_level + (1 - shade_level)

    # light brings the surface closer to the light color
    #  XXX the white highlights look like plastic, mix in
    #  the surface color a bit more?
    lit = (1 - (1-surface) * (1-light))

    # shade darkens to black anywhere
    relief = lit * shade

    return relief