Actually adding files

Author: calvint

Algorithms/ConvexHullWorkshop/ConvexHullWorkshop.zip

@@ -0,0 +1,93 @@
+'''
+Created on Nov 8, 2014
+
+@author: Gary
+'''
+from math import sqrt
+from math import pow
+
+class graph:
+    def __init__(self):
+        self.vertexNameArray       = [] # vertex names in an array
+        self.vertexIndexMap        = {} # vertex names to index dictionary
+        self.vertexPositionArray   = [] # x,y pair position array
+        self.edgeArray             = [] # array of (vertex index pair, weight)
+    
+    def addVertex(self, name, x, y):
+        self.vertexIndexMap[name] = self.vCount()
+        self.vertexNameArray.append(name)
+        self.vertexPositionArray.append((x,y))
+        
+    def addEdge(self, vName1, vName2, weight):
+        self.edgeArray.append((self.vertexIndexMap[vName1],self.vertexIndexMap[vName2],weight))
+        
+    def vCount(self): return len(self.vertexNameArray)
+    
+    def eCount(self): return len(self.edgeArray)
+    
+    # Access functions for vertex information
+    def  vX(   self, i): return self.vertexPositionArray[i][0]
+    def  vY(   self, i): return self.vertexPositionArray[i][1]
+    def  vName(self, i): return self.vertexNameArray[i]
+    
+    # Access functions for edge information
+    def  eV0X( self, i): return self.vertexPositionArray[self.edgeArray[i][0]][0]
+    def  eV0Y( self, i): return self.vertexPositionArray[self.edgeArray[i][0]][1]
+    def  eV1X( self, i): return self.vertexPositionArray[self.edgeArray[i][1]][0]
+    def  eV1Y( self, i): return self.vertexPositionArray[self.edgeArray[i][1]][1]
+    def  eWght(self, i): return self.edgeArray[i][2]
+    
+    #uses the cross product to find wether the angle turns left or right
+    def angleTurnsLeft(self, point1, middlePoint, point3):
+        crossProduct = (self.vX(middlePoint) - self.vX(point1)) * (self.vY(point3) - self.vY(point1)) - (self.vX(point3) - self.vX(point1)) * (self.vY(middlePoint) - self.vY(point1))
+        if crossProduct >= 0.0:
+            return True
+        else: 
+            return False
+        
+    
+    def findConvexHullEdges(self):
+        #find lowest vertex
+        yValMap = {}
+        for i in range(self.vCount()):
+            if self.vY(i) not in yValMap.keys():
+                yValMap[self.vY(i)] = []
+            yValMap[self.vY(i)].append(i)
+        lowestVertexIndex = yValMap[sorted(yValMap.keys())[0]][0]
+        
+        
+        #order other verticies acording to decreasing normalized x value
+        xNormalizedMap = {}
+        for i in range(self.vCount()):
+            if i != lowestVertexIndex:
+                #using formula: (Xi - X0)/(sqrt( (Xi - X0)^2 + (Yi - Y0)^2 )
+                normalizedXValue = (self.vX(i) - self.vX(lowestVertexIndex)) / sqrt( (self.vX(i) - self.vX(lowestVertexIndex))**2 + (self.vY(i) - self.vY(lowestVertexIndex))**2 )
+                if normalizedXValue not in xNormalizedMap.keys():
+                    xNormalizedMap[normalizedXValue] = i
+                else:
+                    if self.vX(i) < self.vX(xNormalizedMap[normalizedXValue]):
+                        xNormalizedMap[normalizedXValue] = i
+        orderedVerticies = [lowestVertexIndex]
+        for xValue in sorted(xNormalizedMap.keys(), reverse = True):
+            orderedVerticies.append(xNormalizedMap[xValue])
+        orderedVerticies.append(lowestVertexIndex)
+        
+        #select final and original edges
+        originallyTriedEdges = []
+        finalEdges = [(orderedVerticies[0], orderedVerticies[1])]
+        i=0
+        while i < len(orderedVerticies)-2:
+            if self.angleTurnsLeft(orderedVerticies[i], orderedVerticies[i+1], orderedVerticies[i+2]):
+                finalEdges.append((orderedVerticies[i+1],orderedVerticies[i+2]))
+                i += 1
+            else:
+                orderedVerticies.pop(i+1)
+                originallyTriedEdges.append(finalEdges.pop())
+                i -= 1
+        return originallyTriedEdges, finalEdges
+            
+        
+        
+        
+        
+        

Algorithms/ConvexHullWorkshop/graph.py

@@ -0,0 +1,17 @@
+a 20   30
+b 200  40
+c 30  350
+d 350 380
+e 100 300
+----------
+a b 3
+b c 4
+a c 5
+a d 4
+b d 2
+c d 1
+e a 2
+a e 5
+e c 3
+e d 3
+d e 4

Algorithms/ConvexHullWorkshop/graph.pyc

@@ -0,0 +1,91 @@
+'''
+Created on Nov 8, 2014
+
+@author: Gary
+'''
+
+import fileinput
+import graph
+import matplotlib.pyplot as plt
+from   matplotlib.path import Path
+import matplotlib.patches as patches
+import math
+    
+def plotEdge( plot_axis, x0, y0, x1, y1, weight, clr):
+    d0 = 4 # This is an offset so the edge is not drawn to the middle of vertex
+    d2 = 20 # This is an offset to the end of the arrow tails
+    dx = x1-x0
+    dy = y1-y0
+    length = math.sqrt(dx*dx+dy*dy)
+    if length > 0:
+        vx = dx/length
+        vy = dy/length
+        #plot_axis.plot([x0+vx*d0,x1-vx*d0],[y0+vy*d0,y1-vy*d0], color=clr) # Draw a line
+        #plot_axis.text( x0+dx/2, y0+dy/2, weight)
+        
+        verts = [(x0+vy*d0,y0-vx*d0),(x0+vy*40,y0-vx*40),(x1-vx*80,y1-vy*80),(x1-vx*d0,y1-vy*d0),]
+        codes = [Path.MOVETO,Path.CURVE4,Path.CURVE4,Path.CURVE4,]
+        path  = Path(verts,codes)
+        patch = patches.PathPatch( path, facecolor = 'none', edgecolor = clr)
+        plot_axis.add_patch( patch )
+
+        plot_axis.plot([x1-vx*d2+vy*3,x1-vx*d0],[y1-vy*d2-vx*3,y1-vy*d0], color=clr)
+        plot_axis.plot([x1-vx*d2-vy*3,x1-vx*d0],[y1-vy*d2+vx*3,y1-vy*d0], color=clr)
+
+        plot_axis.text( x0+dx/2+vy*10, y0+dy/2-vx*10, weight)
+
+# Parse graph.txt and populate mygraph structure.
+mygraph = graph.graph()
+isVertices = True
+for line in fileinput.input("graph.txt"):
+    if isVertices:
+        if "----------" in line:
+            isVertices = False
+        else: #read vertices in this part
+            split = line.split()
+            mygraph.addVertex(split[0],float(split[1]),float(split[2]))
+    else:     #read    edges in this part
+        split = line.split()
+        mygraph.addEdge(split[0], split[1], float(split[2]))
+    print line, isVertices
+
+fig = plt.figure()
+plt_ax  = fig.add_subplot(111)
+
+
+
+# Display vertices
+minX = minY =  1e1000
+maxX = maxY = -1e1000
+for iV in range (0, mygraph.vCount()):
+    x = mygraph.vX(iV)
+    y = mygraph.vY(iV)
+    plt_ax.plot(x,y,'wo', ms = 15)
+    minX = min(minX,x)
+    minY = min(minY,y)
+    maxX = max(maxX,x)
+    maxY = max(maxY,y)
+    plt_ax.text(x, y, mygraph.vName(iV), ha = 'center', va = 'center')
+padX = .10*(maxX-minX)+10
+padY = .10*(maxY-minY)+10
+plt_ax.axis([minX-padX, maxX+padX, minY-padY, maxY+padY])
+
+originallyTriedEdges, finalEdges = mygraph.findConvexHullEdges();
+
+# Display edges originally tried edges
+for edge in originallyTriedEdges:
+    x0 = mygraph.vX(edge[0])
+    y0 = mygraph.vY(edge[0])
+    x1 = mygraph.vX(edge[1])
+    y1 = mygraph.vY(edge[1])
+    plotEdge(plt_ax, x0, y0, x1, y1, "", 'red')
+    
+# Display final edges
+for edge in finalEdges:
+    x0 = mygraph.vX(edge[0])
+    y0 = mygraph.vY(edge[0])
+    x1 = mygraph.vX(edge[1])
+    y1 = mygraph.vY(edge[1])
+    plotEdge(plt_ax, x0, y0, x1, y1, "", 'black')
+
+plt.show()

Algorithms/ConvexHullWorkshop/graph.txt

@@ -0,0 +1,39 @@
+a 20   30
+b 100  40
+c 30  250
+d 60  130
+e 150  90
+f 240  60
+g 120 200
+h 200 160
+i 260 100
+j 360 400
+l 180 350
+m 280 300
+n 80  350
+o 350  40
+----------
+a b 3
+a c 2
+a d 5
+b c 4
+b d 1
+b g 2
+c d 7
+c g 5
+e f 4
+e g 3
+e h 2
+f h 3
+f i 4
+g l 1
+g n 1
+h i 1
+h m 3
+i m 2
+i o 2
+j l 7
+j m 3
+j o 4
+l m 5
+l n 6

Algorithms/ConvexHullWorkshop/graphParseAndPlot.py

@@ -0,0 +1,24 @@
+a 10 100
+b 100 200
+c 200 200
+d 300 200
+e 390 100
+f 300 10
+g 200 10
+h 100 10
+i 150 100
+----------
+a b 4
+b c 8
+b h 11
+a h 8
+h i 7
+h g 1
+i c 2
+i g 6
+c f 4
+g f 2
+c d 7
+d e 9
+d f 14
+e f 10