def drawPoly(vertices, win, color='white'): vert = vertices.copy() vert += [vert[0]] for i in range(len(vert) - 1): x1, y1, x2, y2 = *vert[i], *vert[i + 1] #print(win,color,x1,y1,x2,y2) drawLine(win, color, x1, y1, x2, y2)
def plotProgresskMeans(X, centroids, previous, idx, K, i): #PLOTPROGRESSKMEANS is a helper function that displays the progress of #k-Means as it is running. It is intended for use only with 2D data. # PLOTPROGRESSKMEANS(X, centroids, previous, idx, K, i) plots the data # points with colors assigned to each centroid. With the previous # centroids, it also plots a line between the previous locations and # current locations of the centroids. # # Plot the examples plotDataPoints(X, idx, K, i) current = centroids for last in previous[::-1]: # Plot the centroids as black x's plt.plot(current[:, 0], current[:, 1], linestyle='None', marker='x', markeredgecolor='k', ms=10, lw=3) # Plot the history of the centroids with lines for j in range(current.shape[0]): drawLine(current[j, :], last[j, :]) current = last #end # Title plt.title('Iteration number %d' % i)
def plotProgresskMeans(X, centroids, previous, idx, K, i): #PLOTPROGRESSKMEANS is a helper function that displays the progress of #k-Means as it is running. It is intended for use only with 2D data. # PLOTPROGRESSKMEANS(X, centroids, previous, idx, K, i) plots the data # points with colors assigned to each centroid. With the previous # centroids, it also plots a line between the previous locations and # current locations of the centroids. # # plt.hold(True) # Plot the examples pdp.plotDataPoints(X, idx, K) # Plot the centroids as black x's plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=400, c='k', linewidth=1) # Plot the history of the centroids with lines for j in range(centroids.shape[0]): dl.drawLine(centroids[j, :], previous[j, :], c='b') # Title plt.title('Iteration number {:d}'.format(i + 1)) return
def plotProgresskMeans(X, centroids, previous, idx, K, i): #PLOTPROGRESSKMEANS is a helper function that displays the progress of #k-Means as it is running. It is intended for use only with 2D data. # PLOTPROGRESSKMEANS(X, centroids, previous, idx, K, i) plots the data # points with colors assigned to each centroid. With the previous # centroids, it also plots a line between the previous locations and # current locations of the centroids. # # plt.hold(True) # Plot the examples pdp.plotDataPoints(X, idx, K) # Plot the centroids as black x's plt.scatter(centroids[:,0], centroids[:,1], marker='x', s=400, c='k', linewidth=1) # Plot the history of the centroids with lines for j in xrange(centroids.shape[0]): dl.drawLine(centroids[j, :], previous[j, :], c='b') # Title plt.title('Iteration number {:d}'.format(i+1)) return
def plotProgresskMeans(X, centroids, previous, idx, K, i): plotDataPoints(X, idx) plt.plot(previous[:, 0], previous[:, 1], 'rx', lw=3) plt.plot(centroids[:, 0], centroids[:, 1], 'kx', lw=3) for j in range(centroids.shape[0]): drawLine(centroids[j, :], previous[j, :]) plt.title('Iteration number %d' % i) plt.show(block=False)
def plotProgressKmeans(X, centroids, previous, idx, K, i): plotDataPoints(X, idx, K) plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', edgecolors='b') for j in range(centroids.shape[0]): drawLine(centroids[j, :], previous[j, :]) plt.title('Iteration number {}'.format(i)) plt.show()
def draw_2d_polygon(self, l2d, color, undraw=False): n = len(l2d) drawPoly(l2d[:n // 2], win, color) drawPoly(l2d[n // 2:], win, color) #scanLineUtil(l2d[:n//2], win ,"green") #scanLineUtil(l2d[n//2:], win, "purple") for i in range(n // 2): x1, y1, x2, y2 = l2d[i][0], l2d[i][1], l2d[(n // 2) + i][0], l2d[(n // 2) + i][1] drawLine(win, color, x1, y1, x2, y2) if undraw: drawAxis(win, port)
def plotProgressKMeans(X, history_centroids, idx, K, i): #PLOTPROGRESSKMEANS is a helper function that displays the progress of #k-Means as it is running. It is intended for use only with 2D data. # PLOTPROGRESSKMEANS(X, centroids, previous, idx, K, i) plots the data # points with colors assigned to each centroid. With the previous # centroids, it also plots a line between the previous locations and # current locations of the centroids. plotDataPoints(X, idx, K) plt.plot(history_centroids[0:i+1, :, 0], history_centroids[0:i+1, :, 1], linestyle='', marker='x', markersize=10, linewidth=3, color='k') plt.title('Iteration number {}'.format(i + 1)) for centroid_idx in range(history_centroids.shape[1]): for iter_idx in range(i): drawLine(history_centroids[iter_idx, centroid_idx, :], history_centroids[iter_idx + 1, centroid_idx, :])
def main(): if (input('Defualt viewPort is (-400 -400, 400 400). Change?(y/Y)') in ('y', 'Y')): x, y = map(int, input('viewPort\'s xMax yMax : ').split()) new_view = ViewPort(-x, -y, x, y) else: new_view = ViewPort(-400, -400, 400, 400) print('ViewPort :', new_view) win = new_view.init_view() x, y, x1, y1 = drawLine(win) xmin, ymin, xmax, ymax = map( int, input( 'Enter Cliping Window\'s Endpoints <xmin> <ymin> <xmax> <ymax> :' ).split()) drawPoly([(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)], win) temp = cohenSutherlandClip(x, y, x1, y1, xmin, ymin, xmax, ymax) if not temp: return pixel = bresenham(*temp) for i in pixel: x, y = i win.plot(*i, 'green') input('Exit?')
def plotProgresskMeans(X, centroids, previous, idx, K, i): # Plot the examples plotDataPoints(X, idx, K) # Plot the centroids as black x's plt.plot(centroids[:, 0], centroids[:, 1], marker='x', markeredgecolor='k', markersize=10, linewidth=3, linestyle='None') #plt.scatter(centroids[:,0], centroids[:,1], marker='x', s=400, c='k', linewidth=1) # Plot the history of the centroids with lines for j in range(centroids.shape[0]): drawLine(centroids[j, :], previous[j, :], c='b') # Title plt.title('Iteration number ' + str(i)) #return plt
def plotProgresskMeans(X, centroids, previous, idx, K, i): #PLOTPROGRESSKMEANS is a helper function that displays the progress of #k-Means as it is running. It is intended for use only with 2D data. # PLOTPROGRESSKMEANS(X, centroids, previous, idx, K, i) plots the data # points with colors assigned to each centroid. With the previous # centroids, it also plots a line between the previous locations and # current locations of the centroids. # # Plot the examples plotDataPoints(X, idx, K) # Plot the centroids as black x's plot(centroids[:,0], centroids[:,1], 'x', mec='k', ms=10, mew=3) # Plot the history of the centroids with lines for j in range(size(centroids, 0)): drawLine(centroids[j, :], previous[j, :], 'b') # Title title('Iteration number #%d' % (i+1))
input('Program paused. Press Enter to continue...') ## =============== Part 2: Principal Component Analysis =============== # You should now implement PCA, a dimension reduction technique. You # should complete the code in pca.m # print('Running PCA on example dataset.') # Before running PCA, it is important to first normalize X X_norm, mu, sigma = featureNormalize(X) # Run PCA U, S, V = pca(X_norm) drawLine(mu, mu+1.5*S[0]*U[:, 0]) drawLine(mu, mu+1.5*S[1]*U[:, 1]) show() print('Top eigenvector: ') print(' U(:,1) = %f %f ', U[0,0], U[1,0]) print('(you should expect to see -0.707107 -0.707107)') input('Program paused. Press Enter to continue...') ## =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced # dimensional space. This will show you what the data looks like when # using only the corresponding eigenvectors to reconstruct it.
# should complete the code in pca.py # print '\nRunning PCA on example dataset.\n' # Before running PCA, it is important to first normalize X X_norm, mu, sigma = featureNormalize(X) # Run PCA U, s = pca(X_norm) # Compute mu, the mean of the each feature # Draw the eigenvectors centered at mean of data. These lines show the # directions of maximum variations in the dataset. hold(True) drawLine(mu, mu + 1.5 * s[0] * U[:,0].T, '-k', linewidth=2) drawLine(mu, mu + 1.5 * s[1] * U[:,1].T, '-k', linewidth=2) hold(False) fig.show() print 'Top eigenvector:' print ' U[:,0] = %f %f' % (U[0,0], U[1,0]) print '\n(you should expect to see -0.707107 -0.707107)' print 'Program paused. Press enter to continue.' raw_input() ## =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced
# Project the data onto K = 1 dimension K = 1 Z = projectData(X_norm, U, K) print('Projection of the first example: {:f}'.format(Z[0][0])) print('(this value should be about 1.481274)') X_rec = recoverData(Z, U, K) print('Approximation of the first example: {:f} {:f}'.format( X_rec[0, 0], X_rec[0, 1])) print('(this value should be about -1.047419 -1.047419)') # Draw lines connecting the projected points to the original points plt.hold(True) plt.scatter(X_rec[:, 0], X_rec[:, 1], s=75, facecolors='none', edgecolors='r') for i in range(X_norm.shape[0]): drawLine(X_norm[i, :], X_rec[i, :], linestyle='--', color='k', linewidth=1) plt.hold(False) input('Program paused. Press <Enter> to continue...') ## =============== Part 4: Loading and Visualizing Face Data ============= # We start the exercise by first loading and visualizing the dataset. # The following code will load the dataset into your environment # print('Loading face dataset.\n') # Load Face dataset mat = scipy.io.loadmat('ex7faces.mat') X = np.array(mat["X"]) # Display the first 100 faces in the dataset
plt.xlim(0.5, 6.5) plt.ylim(2, 8) plt.gca().set_aspect('equal', adjustable='box') plt.show() # =============== 2.2 Implementing PCA =============== print('Running PCA on example dataset.') # Before running PCA, it is important to first normalize X X_norm, mu, sigma = featureNormalize(X) # Run PCA U, S, V = pca(X_norm) plt.figure() drawLine(mu, mu + 1.5 * S[0] * U[:, 0].T) drawLine(mu, mu + 1.5 * S[1] * U[:, 1].T) plt.show() print('Top eigenvector:') print('U = ', U[:, 0]) print('(you should expect to see -0.70710678 -0.70710678)') # =================== 2.3 Dimensionality reduction with PCA =================== print('Dimension reduction on example dataset.') # Plot the normalized dataset (returned from pca) plt.figure() plt.scatter(X_norm[:, 0], X_norm[:, 1], facecolors='none', edgecolors='b') plt.xlim(-4, 3) plt.ylim(-4, 3)
# should complete the code in pca.m # print('Running PCA on example dataset.\n') # Before running PCA, it is important to first normalize X X_norm, mu, _ = fn.featureNormalize(X) # Run PCA U, S = pca.pca(X_norm) # Compute mu, the mean of the each feature # Draw the eigenvectors centered at mean of data. These lines show the # directions of maximum variations in the dataset. plt.hold(True) dl.drawLine(mu, mu + 1.5 * S[0, 0] * U[:, 0].T, c='k', linewidth=2) dl.drawLine(mu, mu + 1.5 * S[1, 1] * U[:, 1].T, c='k', linewidth=2) plt.hold(False) print('Top eigenvector: \n') print(' U(:,1) = {:f} {:f} \n'.format(U[0, 0], U[1, 0])) print('(you should expect to see -0.707107 -0.707107)') raw_input('Program paused. Press enter to continue.') ## =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced # dimensional space. This will show you what the data looks like when # using only the corresponding eigenvectors to reconstruct it. #
def ex7_pca(): ## Machine Learning Online Class # Exercise 7 | Principle Component Analysis and K-Means Clustering # # Instructions # ------------ # # This file contains code that helps you get started on the # exercise. You will need to complete the following functions: # # pca.m # projectData.m # recoverData.m # computeCentroids.m # findClosestCentroids.m # kMeansInitCentroids.m # # For this exercise, you will not need to change any code in this file, # or any other files other than those mentioned above. # ## Initialization #clear ; close all; clc ## ================== Part 1: Load Example Dataset =================== # We start this exercise by using a small dataset that is easily to # visualize # print('Visualizing example dataset for PCA.\n') # The following command loads the dataset. You should now have the # variable X in your environment mat = scipy.io.loadmat('ex7data1.mat') X = mat['X'] # Visualize the example dataset plt.plot(X[:, 0], X[:, 1], 'wo', ms=10, mec='b', mew=1) plt.axis([0.5, 6.5, 2, 8]) plt.savefig('figure1.png') print('Program paused. Press enter to continue.') #pause ## =============== Part 2: Principal Component Analysis =============== # You should now implement PCA, a dimension reduction technique. You # should complete the code in pca.m # print('\nRunning PCA on example dataset.\n') # Before running PCA, it is important to first normalize X X_norm, mu, sigma = featureNormalize(X) # Run PCA U, S = pca(X_norm) # Compute mu, the mean of the each feature # Draw the eigenvectors centered at mean of data. These lines show the # directions of maximum variations in the dataset. #hold on print(S) print(U) drawLine(mu, mu + 1.5 * np.dot(S[0], U[:,0].T)) drawLine(mu, mu + 1.5 * np.dot(S[1], U[:,1].T)) #hold off plt.savefig('figure2.png') print('Top eigenvector: ') print(' U(:,1) = %f %f ' % (U[0,0], U[1,0])) print('\n(you should expect to see -0.707107 -0.707107)') print('Program paused. Press enter to continue.') #pause ## =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced # dimensional space. This will show you what the data looks like when # using only the corresponding eigenvectors to reconstruct it. # # You should complete the code in projectData.m # print('\nDimension reduction on example dataset.\n\n') # Plot the normalized dataset (returned from pca) fig = plt.figure() plt.plot(X_norm[:, 0], X_norm[:, 1], 'bo') # Project the data onto K = 1 dimension K = 1 Z = projectData(X_norm, U, K) print('Projection of the first example: %f' % Z[0]) print('\n(this value should be about 1.481274)\n') X_rec = recoverData(Z, U, K) print('Approximation of the first example: %f %f' % (X_rec[0, 0], X_rec[0, 1])) print('\n(this value should be about -1.047419 -1.047419)\n') # Draw lines connecting the projected points to the original points plt.plot(X_rec[:, 0], X_rec[:, 1], 'ro') for i in range(X_norm.shape[0]): drawLine(X_norm[i,:], X_rec[i,:]) #end plt.savefig('figure3.png') print('Program paused. Press enter to continue.\n') #pause ## =============== Part 4: Loading and Visualizing Face Data ============= # We start the exercise by first loading and visualizing the dataset. # The following code will load the dataset into your environment # print('\nLoading face dataset.\n\n') # Load Face dataset mat = scipy.io.loadmat('ex7faces.mat') X = mat['X'] # Display the first 100 faces in the dataset displayData(X[:100, :]) plt.savefig('figure4.png') print('Program paused. Press enter to continue.\n') #pause ## =========== Part 5: PCA on Face Data: Eigenfaces =================== # Run PCA and visualize the eigenvectors which are in this case eigenfaces # We display the first 36 eigenfaces. # print('\nRunning PCA on face dataset.\n(this mght take a minute or two ...)\n') # Before running PCA, it is important to first normalize X by subtracting # the mean value from each feature X_norm, mu, sigma = featureNormalize(X) # Run PCA U, S = pca(X_norm) # Visualize the top 36 eigenvectors found displayData(U[:, :36].T) plt.savefig('figure5.png') print('Program paused. Press enter to continue.') #pause ## ============= Part 6: Dimension Reduction for Faces ================= # Project images to the eigen space using the top k eigenvectors # If you are applying a machine learning algorithm print('\nDimension reduction for face dataset.\n') K = 100 Z = projectData(X_norm, U, K) print('The projected data Z has a size of: ') print(formatter('%d ', Z.shape)) print('\n\nProgram paused. Press enter to continue.') #pause ## ==== Part 7: Visualization of Faces after PCA Dimension Reduction ==== # Project images to the eigen space using the top K eigen vectors and # visualize only using those K dimensions # Compare to the original input, which is also displayed print('\nVisualizing the projected (reduced dimension) faces.\n') K = 100 X_rec = recoverData(Z, U, K) # Display normalized data #subplot(1, 2, 1) displayData(X_norm[:100,:]) plt.gcf().suptitle('Original faces') #axis square plt.savefig('figure6.a.png') # Display reconstructed data from only k eigenfaces #subplot(1, 2, 2) displayData(X_rec[:100,:]) plt.gcf().suptitle('Recovered faces') #axis square plt.savefig('figure6.b.png') print('Program paused. Press enter to continue.') #pause ## === Part 8(a): Optional (ungraded) Exercise: PCA for Visualization === # One useful application of PCA is to use it to visualize high-dimensional # data. In the last K-Means exercise you ran K-Means on 3-dimensional # pixel colors of an image. We first visualize this output in 3D, and then # apply PCA to obtain a visualization in 2D. #close all; close all; clc # Re-load the image from the previous exercise and run K-Means on it # For this to work, you need to complete the K-Means assignment first A = matplotlib.image.imread('bird_small.png') # If imread does not work for you, you can try instead # load ('bird_small.mat') A = A / 255 X = A.reshape(-1, 3) K = 16 max_iters = 10 initial_centroids = kMeansInitCentroids(X, K) centroids, idx = runkMeans('7', X, initial_centroids, max_iters) # Sample 1000 random indexes (since working with all the data is # too expensive. If you have a fast computer, you may increase this. sel = np.random.choice(X.shape[0], size=1000) # Setup Color Palette #palette = hsv(K) #colors = palette(idx(sel), :) # Visualize the data and centroid memberships in 3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(X[sel, 0], X[sel, 1], X[sel, 2], cmap='rainbow', c=idx[sel], s=8**2) ax.set_title('Pixel dataset plotted in 3D. Color shows centroid memberships') plt.savefig('figure8.png') print('Program paused. Press enter to continue.') #pause ## === Part 8(b): Optional (ungraded) Exercise: PCA for Visualization === # Use PCA to project this cloud to 2D for visualization # Subtract the mean to use PCA X_norm, mu, sigma = featureNormalize(X) # PCA and project the data to 2D U, S = pca(X_norm) Z = projectData(X_norm, U, 2) # Plot in 2D fig = plt.figure() plotDataPoints(Z[sel, :], [idx[sel]], K, 0) plt.title('Pixel dataset plotted in 2D, using PCA for dimensionality reduction') plt.savefig('figure9.png') print('Program paused. Press enter to continue.\n')
# should complete the code in pca.m # print('Running PCA on example dataset.\n'); # Before running PCA, it is important to first normalize X X_norm, mu, _ = fn.featureNormalize(X) # Run PCA U, S = pca.pca(X_norm) # Compute mu, the mean of the each feature # Draw the eigenvectors centered at mean of data. These lines show the # directions of maximum variations in the dataset. plt.hold(True) dl.drawLine(mu, mu + 1.5 * S[0,0] * U[:,0].T, c='k', linewidth=2) dl.drawLine(mu, mu + 1.5 * S[1,1] * U[:,1].T, c='k', linewidth=2) plt.hold(False) print('Top eigenvector: \n') print(' U(:,1) = {:f} {:f} \n'.format(U[0,0], U[1,0])) print('(you should expect to see -0.707107 -0.707107)') raw_input('Program paused. Press enter to continue.') ## =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced # dimensional space. This will show you what the data looks like when
# You should now implement PCA, a dimension reduction technique. You # should complete the code in pca.m # print('\nRunning PCA on example dataset.\n\n') # Before running PCA, it is important to first normalize X X_norm, mu, sigma = featureNormalize(X) # Run PCA U, S = pca(X_norm) # Compute mu, the mean of the each feature # Draw the eigenvectors centered at mean of data. These lines show the # directions of maximum variations in the dataset. drawLine(mu, mu + 1.5 * S[0] * U[:, 0], 'k-') drawLine(mu, mu + 1.5 * S[1] * U[:, 1], 'k-') print('Top eigenvector: \n') print(' U(:,1) = %f %f \n' % (U[0, 0], U[1, 0])) print('\n(you should expect to see -0.707107 -0.707107)\n') input('Program paused. Press enter to continue.\n') ## =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced # dimensional space. This will show you what the data looks like when # using only the corresponding eigenvectors to reconstruct it. # # You should complete the code in projectData.m
# Before running PCA, it is important to first normalize X X_norm, mu, sigma = featureNormalize(X) # Run PCA U, S, _ = pca(X_norm) print('Top eigenvector:') print(' U(:,0) = %f %f' % (U[0, 0], U[1, 0])) print('(you should expect to see -0.707107 -0.707107)\n') # Draw the eigenvectors centered at mean of data. These lines show the # directions of maximum variations in the dataset. plt.scatter(X[:, 0], X[:, 1], marker='o', s=12, edgecolors='blue', facecolors='none') drawLine(mu, mu + 1.5 * S[0] * U[:, 0]) drawLine(mu, mu + 1.5 * S[1] * U[:, 1]) plt.show() # =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced # dimensional space. This will show you what the data looks like when # using only the corresponding eigenvectors to reconstruct it. # # You should complete the code in projectData.py print('Dimension reduction on example dataset.') # Project the data onto K = 1 dimension K = 1
# should complete the code in pca.py # print '\nRunning PCA on example dataset.\n' # Before running PCA, it is important to first normalize X X_norm, mu, sigma = featureNormalize(X) # Run PCA U, s = pca(X_norm) # Compute mu, the mean of the each feature # Draw the eigenvectors centered at mean of data. These lines show the # directions of maximum variations in the dataset. hold(True) drawLine(mu, mu + 1.5 * s[0] * U[:, 0].T, '-k', linewidth=2) drawLine(mu, mu + 1.5 * s[1] * U[:, 1].T, '-k', linewidth=2) hold(False) fig.show() print 'Top eigenvector:' print ' U[:,0] = %f %f' % (U[0, 0], U[1, 0]) print '\n(you should expect to see -0.707107 -0.707107)' print 'Program paused. Press enter to continue.' raw_input() ## =================== Part 3: Dimension Reduction =================== # You should now implement the projection step to map the data onto the # first k eigenvectors. The code will then plot the data in this reduced # dimensional space. This will show you what the data looks like when
if img.ndim == 3: img = rgb2gray(img) img = np.float64(img) / 255.0 # actual Hough line code function calls Im = myEdgeFilter(img, sigma) # H, rhoScale, thetaScale = myHoughTransform(Im, threshold, rhoRes, thetaRes) # rhos, thetas = myHoughLines(H, nLines) # thresh_img = Im > threshold # lines = houghlines(thresh_img, 180 * (thetaScale / math.pi), rhoScale, # rhos, thetas, fillgap=5, minlength=20) # everything below here just saves the outputs to files filename_w_ext = os.path.basename(imglist[i]) filename, file_extension = os.path.splitext(filename_w_ext) fname = os.path.join(resultsdir, filename + '_01edge.png') temp = np.uint8(255.0 * np.sqrt(Im / np.max(Im))) sp.misc.imsave(fname, temp) fname = os.path.join(resultsdir, filename + '_02threshold.png') temp = np.uint8(255.0 * (Im > threshold)) sp.misc.imsave(fname, temp) fname = os.path.join(resultsdir, filename + '_03hough.png') sp.misc.imsave(fname, H / np.max(H)) fname = os.path.join(resultsdir, filename + '_04lines.png') img2 = img for j in range(len(lines)): img2 = drawLine(img2, lines[j]['point1'], lines[j]['point2']) temp = np.uint8(255.0 * img2) sp.misc.imsave(fname, temp)