def test_hough_peaks_dist():
    img = np.zeros((100, 100), dtype=np.bool_)
    img[:, 30] = True
    img[:, 40] = True
    hspace, angles, dists = tf.hough(img)
    assert len(tf.hough_peaks(hspace, angles, dists, min_distance=5)[0]) == 2
    assert len(tf.hough_peaks(hspace, angles, dists, min_distance=15)[0]) == 1
def test_hough_angles():
    img = np.zeros((10, 10))
    img[0, 0] = 1

    out, angles, d = tf.hough(img, np.linspace(0, 360, 10))

    assert_equal(len(angles), 10)
def test_hough_angles():
    img = np.zeros((10, 10))
    img[0, 0] = 1

    out, angles, d = tf.hough(img, np.linspace(0, 360, 10))

    assert_equal(len(angles), 10)
def test_hough_peaks_angle():
    img = np.zeros((100, 100), dtype=np.bool_)
    img[:, 0] = True
    img[0, :] = True

    hspace, angles, dists = tf.hough(img)
    assert len(tf.hough_peaks(hspace, angles, dists, min_angle=45)[0]) == 2
    assert len(tf.hough_peaks(hspace, angles, dists, min_angle=90)[0]) == 1

    theta = np.linspace(0, np.pi, 100)
    hspace, angles, dists = tf.hough(img, theta)
    assert len(tf.hough_peaks(hspace, angles, dists, min_angle=45)[0]) == 2
    assert len(tf.hough_peaks(hspace, angles, dists, min_angle=90)[0]) == 1

    theta = np.linspace(np.pi / 3, 4. / 3 * np.pi, 100)
    hspace, angles, dists = tf.hough(img, theta)
    assert len(tf.hough_peaks(hspace, angles, dists, min_angle=45)[0]) == 2
    assert len(tf.hough_peaks(hspace, angles, dists, min_angle=90)[0]) == 1
def test_hough():
    # Generate a test image
    img = np.zeros((100, 100), dtype=int)
    for i in range(25, 75):
        img[100 - i, i] = 1

    out, angles, d = tf.hough(img)

    y, x = np.where(out == out.max())
    dist = d[y[0]]
    theta = angles[x[0]]

    assert_equal(dist > 70, dist < 72)
    assert_equal(theta > 0.78, theta < 0.79)
def test_hough():
    # Generate a test image
    img = np.zeros((100, 100), dtype=int)
    for i in range(25, 75):
        img[100 - i, i] = 1

    out, angles, d = tf.hough(img)

    y, x = np.where(out == out.max())
    dist = d[y[0]]
    theta = angles[x[0]]

    assert_equal(dist > 70, dist < 72)
    assert_equal(theta > 0.78, theta < 0.79)
Beispiel #7
0
def hough_detect(diffs, vote_thresh=15):
    """ Use the Hough detection method to detect lines in the data.
    With enough lines, you can fill in the wave front."""
    detection = []
    print("Performing hough transform on binary maps...")
    for img in diffs:
        # Perform the hough transform on each of the difference maps
        transform, theta, d = hough(img)

        # Filter the hough transform results and find the best lines in the
        # data.  Keep detections that exceed the Hough vote threshold.
        indices = (transform > vote_thresh ).nonzero()
        distances = d[indices[0]]
        theta = theta[indices[1]]
	n =len(indices[1])
    
   
        print("Found " + str(n) + " lines.")
        # Perform the inverse transform to get a series of rectangular
        # images that show where the wavefront is.
        # Create a map which is the same as the
        invTransform = sunpy.make_map(np.zeros(img.shape), img._original_header)
        invTransform.data = np.zeros(img.shape)
        
        # Add up all the detected lines over each other.  The idea behind
        # adding up all the lines on top of each other is that pixels that
        # have larger number of detections are more likely to be in the
        # wavefront.  Note that we are using th Hough transform - which is used
        # to detect lines - to detect and fill in a region.  You might see this
        # as an abuse of the Hough transform!
        for i in range(0,len(indices[1])):
            nextLine = htLine(distances[i], theta[i], np.zeros(shape=img.shape))
            invTransform = invTransform + nextLine

        detection.append(invTransform)

    return detection
Beispiel #8
0
diffs = []

diffmap = 255*(abs(input_maps[1] - input_maps[0]) > diffthresh)

for i in range(0,ndiff):
    # difference map
    diffmap = 255*(abs(input_maps[i+1] - input_maps[i]) > diffthresh)

    # keep
    diffs.append(diffmap)

    # extract the image
    img = diffmap

    # Perform the hough transform on each of the difference maps
    transform,theta,d = hough(img)

    # Filter the hough transform results and find the best lines
    # in the data
    indices =  (transform >votethresh).nonzero()
    distances = d[indices[0]]
    theta = theta[indices[1]]
    n =len(indices[1])
    print("Found " + str(n) + " lines.")

    # Perform the inverse transform to get a series of rectangular
    # images that show where the wavefront is.
    invTransform = sunpy.map.BaseMap(input_maps[i+1])
    invTransform.data = np.zeros(imgShape)
    for i in range(0,n):
        nextLine = htLine( distances[i],theta[i], np.zeros(shape=imgShape) )
import numpy as np
import matplotlib.pyplot as plt

# Construct test image

image = np.zeros((100, 100))


# Classic straight-line Hough transform

idx = np.arange(25, 75)
image[idx[::-1], idx] = 255
image[idx, idx] = 255

h, theta, d = hough(image)

plt.figure(figsize=(8, 4))

plt.subplot(121)
plt.imshow(image, cmap=plt.cm.gray)
plt.title('Input image')

plt.subplot(122)
plt.imshow(np.log(1 + h),
           extent=[np.rad2deg(theta[-1]), np.rad2deg(theta[0]),
                   d[-1], d[0]],
           cmap=plt.cm.gray, aspect=1/1.5)
plt.title('Hough transform')
plt.xlabel('Angles (degrees)')
plt.ylabel('Distance (pixels)')
Beispiel #10
0
#temp = 255*(abs(input_maps[14] - input_maps[13]) > diffthresh)

for i in range(0,ndiff):
    # difference map - create separate maps for +ve and -ve differences
    diffmap_plus = 255*((input_maps[i+1] - input_maps[i]) > diffthresh)
    diffmap_minus = 255*((input_maps[i] - input_maps[i+1]) > diffthresh)
    # keep
    diffs.append(diffmap_plus)

    # extract the image
    img = diffmap_plus
    img2 = diffmap_minus

    # Perform the hough transform on the positive and negative difference maps separately
    transform,theta,d = hough(img)
    transform2,theta2,d2 = hough(img2)
    
   

    # Filter the hough transform results and find the best lines
    # in the data
    #indices =  (transform >votethresh).nonzero()
    #indices = (transform == transform.max()).nonzero()
    #instead of getting all lines above some threshold, just get the *strongest* line only
    #from the positive diffmap and the negative diffmap. May get more than 2 lines due to ties
    #in the accumulator
    #indices=((transform == transform.max())+(transform2 == transform2.max())).nonzero()
    

    indices = ((transform> votethresh)+(transform2 > votethresh)).nonzero()
from skimage import data

import numpy as np
import matplotlib.pyplot as plt

# Construct test image

image = np.zeros((100, 100))

# Classic straight-line Hough transform

idx = np.arange(25, 75)
image[idx[::-1], idx] = 255
image[idx, idx] = 255

h, theta, d = hough(image)

plt.figure(figsize=(8, 4))

plt.subplot(121)
plt.imshow(image, cmap=plt.cm.gray)
plt.title('Input image')

plt.subplot(122)
plt.imshow(np.log(1 + h),
           extent=[np.rad2deg(theta[-1]),
                   np.rad2deg(theta[0]), d[-1], d[0]],
           cmap=plt.cm.gray,
           aspect=1 / 1.5)
plt.title('Hough transform')
plt.xlabel('Angles (degrees)')
Beispiel #12
0
import numpy as np
import matplotlib.pyplot as plt

from skimage.transform import hough

img = np.zeros((100, 150), dtype=bool)
img[30, :] = 1
img[:, 65] = 1
img[35:45, 35:50] = 1
for i in range(90):
    img[i, i] = 1
img += np.random.random(img.shape) > 0.95

out, angles, d = hough(img)

plt.subplot(1, 2, 1)

plt.imshow(img, cmap=plt.cm.gray)
plt.title('Input image')

plt.subplot(1, 2, 2)
plt.imshow(out,
           cmap=plt.cm.bone,
           extent=(d[0], d[-1], np.rad2deg(angles[0]), np.rad2deg(angles[-1])))
plt.title('Hough transform')
plt.xlabel('Angle (degree)')
plt.ylabel('Distance (pixel)')

plt.subplots_adjust(wspace=0.4)
plt.show()
Beispiel #13
0
import numpy as np
import matplotlib.pyplot as plt

from skimage.transform import hough

img = np.zeros((100, 150), dtype=bool)
img[30, :] = 1
img[:, 65] = 1
img[35:45, 35:50] = 1
for i in range(90):
    img[i, i] = 1
img += np.random.random(img.shape) > 0.95

out, angles, d = hough(img)

plt.subplot(1, 2, 1)

plt.imshow(img, cmap=plt.cm.gray)
plt.title('Input image')

plt.subplot(1, 2, 2)
plt.imshow(out, cmap=plt.cm.bone,
           extent=(d[0], d[-1],
                   np.rad2deg(angles[0]), np.rad2deg(angles[-1])))
plt.title('Hough transform')
plt.xlabel('Angle (degree)')
plt.ylabel('Distance (pixel)')

plt.subplots_adjust(wspace=0.4)
plt.show()
import Whale as w

spec_data = w.get_spectrogram(5)
munged_data = ndimage.gaussian_filter(spec_data, sigma=1.0)
black_white = munged_data > 2.0 * munged_data.mean()
data = black_white

# Compute the medial axis (skeleton) and the distance transform
skel, distance = medial_axis(data, return_distance=True)
skel1 = skeletonize(data)

# Distance to the background for pixels of the skeleton
dist_on_skel = distance * skel
dist_on_skel1 = distance * skel1

h, theta, d = hough(skel1)
lines = probabilistic_hough(skel1, threshold=6, line_length=5, line_gap=3)
lines = sorted(lines)

plt.figure(figsize=(8, 4))
plt.subplot(141)
plt.imshow(data, cmap=plt.cm.gray, interpolation='nearest')
plt.axis('off')
plt.subplot(142)
plt.imshow(dist_on_skel, cmap=plt.cm.spectral, interpolation='nearest')
plt.contour(data, [0.5], colors='w')
plt.axis('off')
plt.subplot(143)
plt.imshow(dist_on_skel1, cmap=plt.cm.spectral, interpolation='nearest')
plt.contour(data, [0.5], colors='w')
plt.axis('off')
#temp = 255*(abs(input_maps[14] - input_maps[13]) > diffthresh)

for i in range(0, ndiff):
    # difference map - create separate maps for +ve and -ve differences
    diffmap_plus = 255 * ((input_maps[i + 1] - input_maps[i]) > diffthresh)
    diffmap_minus = 255 * ((input_maps[i] - input_maps[i + 1]) > diffthresh)
    # keep
    diffs.append(diffmap_plus)

    # extract the image
    img = diffmap_plus
    img2 = diffmap_minus

    # Perform the hough transform on the positive and negative difference maps separately
    transform, theta, d = hough(img)
    transform2, theta2, d2 = hough(img2)

    # Filter the hough transform results and find the best lines
    # in the data
    #indices =  (transform >votethresh).nonzero()
    #indices = (transform == transform.max()).nonzero()
    #instead of getting all lines above some threshold, just get the *strongest* line only
    #from the positive diffmap and the negative diffmap. May get more than 2 lines due to ties
    #in the accumulator
    indices = ((transform == transform.max()) +
               (transform2 == transform2.max())).nonzero()
    distances = d[indices[0]]
    theta = theta[indices[1]]
    n = len(indices[1])
    print("Found " + str(n) + " lines.")