Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+morph/shape_predictor_68_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text

morph/README.md

@@ -0,0 +1,35 @@
+Project Name: Morph It
+
+Name of team members: Sovreign-Ariel McCarthy, Santiago Bruno, Yazmin Hernandez
+Class: CST-205
+Date: 3/15/2017
+Link to GitHub repo: https://github.com/CSUMB-SP17-CST205/project2-Team25
+Link to C9: https://ide.c9.io/yazminrh/yazminruby
+Your TA: Samuel
+
+Explanation of your project: A user can input two images in order to morph them together as one image.
+
+What did you plan to accomplish? We hoped the program would be similar to what it currently does, but a bit more user friendly, 
+    in that they wouldn't need to change the name of their image.
+    
+Where could you envision this project going? If you had more time, what would you have done? 
+    In the future we would like to implement a website that anyone could access and find by simply typing in "morph" as a keyword.
+
+Description of how to use the application:
+
+Use images within a similar size to 600x800
+
+Step 1:
+Import image into the morph folder
+
+Step 2:
+Go to the file named "points.py" go to line 37 and enter the name of the desired image.
+Do this for both images.
+
+Step 3:
+Go to the file named "faceMorph.py", go to line 73 and 74. Change those image names 
+
+
+
+Step 4
+Go to faceMorph.py on line, 73 & 74, change the image names to your image name of the two pictures you are using. Run it. 

morph/citedsources.txt

@@ -0,0 +1,13 @@
+facemorph.py - Satya Mallick
+http://www.learnopencv.com/face-morph-using-opencv-cpp-python/
+
+triangles.py - Satya Mallick
+https://github.com/spmallick/learnopencv/blob/master/Delaunay/delaunay.py
+
+Landmark detectin / points.py 
+http://stackoverflow.com/questions/39793680/how-to-get-points-coordinate-position-in-the-face-landmark-detection-program-of
+
+used dlib - c++ library 
+
+used skimage 
+

morph/faceMorph.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+import numpy as np
+import cv2
+import sys
+
+# Read points from text file
+def readPoints(path) :
+    # Create an array of points.
+    points = [];
+    # Read points
+    with open(path) as file :
+        for line in file :
+            x, y = line.split()
+            points.append((int(x), int(y)))
+
+    return points
+
+# Apply affine transform calculated using srcTri and dstTri to src and
+# output an image of size.
+def applyAffineTransform(src, srcTri, dstTri, size) :
+    
+    # Given a pair of triangles, find the affine transform.
+    warpMat = cv2.getAffineTransform( np.float32(srcTri), np.float32(dstTri) )
+    
+    # Apply the Affine Transform just found to the src image
+    dst = cv2.warpAffine( src, warpMat, (size[0], size[1]), None, flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101 )
+
+    return dst
+
+
+# Warps and alpha blends triangular regions from img1 and img2 to img
+def morphTriangle(img1, img2, img, t1, t2, t, alpha) :
+
+    # Find bounding rectangle for each triangle
+    r1 = cv2.boundingRect(np.float32([t1]))
+    r2 = cv2.boundingRect(np.float32([t2]))
+    r = cv2.boundingRect(np.float32([t]))
+
+
+    # Offset points by left top corner of the respective rectangles
+    t1Rect = []
+    t2Rect = []
+    tRect = []
+
+
+    for i in xrange(0, 3):
+        tRect.append(((t[i][0] - r[0]),(t[i][1] - r[1])))
+        t1Rect.append(((t1[i][0] - r1[0]),(t1[i][1] - r1[1])))
+        t2Rect.append(((t2[i][0] - r2[0]),(t2[i][1] - r2[1])))
+
+
+    # Get mask by filling triangle
+    mask = np.zeros((r[3], r[2], 3), dtype = np.float32)
+    cv2.fillConvexPoly(mask, np.int32(tRect), (1.0, 1.0, 1.0), 16, 0);
+
+    # Apply warpImage to small rectangular patches
+    img1Rect = img1[r1[1]:r1[1] + r1[3], r1[0]:r1[0] + r1[2]]
+    img2Rect = img2[r2[1]:r2[1] + r2[3], r2[0]:r2[0] + r2[2]]
+
+    size = (r[2], r[3])
+    warpImage1 = applyAffineTransform(img1Rect, t1Rect, tRect, size)
+    warpImage2 = applyAffineTransform(img2Rect, t2Rect, tRect, size)
+
+    # Alpha blend rectangular patches
+    imgRect = (1.0 - alpha) * warpImage1 + alpha * warpImage2
+
+    # Copy triangular region of the rectangular patch to the output image
+    img[r[1]:r[1]+r[3], r[0]:r[0]+r[2]] = img[r[1]:r[1]+r[3], r[0]:r[0]+r[2]] * ( 1 - mask ) + imgRect * mask
+
+
+if __name__ == '__main__' :
+
+    filename1 = 'hillary_clinton.jpg'
+    filename2 = 'ted_cruz.jpg'
+    alpha = 0.5
+    
+    # Read images
+    img1 = cv2.imread(filename1);
+    img2 = cv2.imread(filename2);
+    
+    # Convert Mat to float data type
+    img1 = np.float32(img1)
+    img2 = np.float32(img2)
+
+    # Read array of corresponding points
+    points1 = readPoints('coordinates1.txt')
+    points2 = readPoints('coordinates2.txt')
+    points = [];
+
+    # Compute weighted average point coordinates
+    for i in xrange(0, len(points1)):
+        x = ( 1 - alpha ) * points1[i][0] + alpha * points2[i][0]
+        y = ( 1 - alpha ) * points1[i][1] + alpha * points2[i][1]
+        points.append((x,y))
+
+
+    # Allocate space for final output
+    imgMorph = np.zeros(img1.shape, dtype = img1.dtype)
+
+    # Read triangles from tri.txt
+    with open("tri.txt") as file :
+        for line in file :
+            x,y,z = line.split()
+            
+            x = int(x)
+            y = int(y)
+            z = int(z)
+            
+            t1 = [points1[x], points1[y], points1[z]]
+            t2 = [points2[x], points2[y], points2[z]]
+            t = [points[x], points[y], points[z]]
+
+            # Morph one triangle at a time.
+            morphTriangle(img1, img2, imgMorph, t1, t2, t, alpha)
+
+
+    # Display Result
+    #cv2.imshow("Morphed Face", np.uint8(imgMorph))
+    cv2.imwrite('Morphed.jpg',imgMorph)
+    cv2.waitKey(0)

morph/points.py

@@ -0,0 +1,44 @@
+import dlib
+import numpy as np
+from skimage import io
+import random as r #imported to make the file name randomized
+
+
+class GetPoints: #class container so that code can be reused easily, and is modular
+    def __init__(self, image):
+        self.predictor_path = "shape_predictor_68_face_landmarks.dat"
+        
+        self.detector = dlib.get_frontal_face_detector()
+        self.predictor = dlib.shape_predictor(self.predictor_path)
+        
+        self.img = io.imread(image)
+        
+        self.dets = self.detector(self.img)
+
+    def get_coors(self):
+        save_coordinates = open(str(r.randint(0,100)) + 'coordinates.txt', 'a') #randint changes the name of the text file
+        
+        for k, d in enumerate(self.dets):
+            shape = self.predictor(self.img, d)
+        
+        vec = np.empty([68, 2], dtype = int)
+        
+        for b in range(68): #gets the coordinates of the picture passed in
+            vec[b][0] = shape.part(b).x
+            vec[b][1] = shape.part(b).y
+            save_coordinates.write(str(vec[b][0]) + " "+ str(vec[b][1]) + "\n") #adds them to the randomized text file
+
+        extra_points = ['514 360', '294 676', '0 680', '599 588', '0 0', '0 400', '0 799', '300 799',
+             '599 799', '599 400', '599 0' , '300 0']
+        
+        for i in range(len(extra_points)): #this accesses the array of extra points and writes them into the text file
+            save_coordinates.write(extra_points[i] + "\n")
+        
+        save_coordinates.close() #this closes the picture
+
+name = "ted_cruz" #this will have to be gotten from the user instead of hardcoding
+image = name + ".jpg"
+
+x = GetPoints(image) #pass the file name into the class to be converted into a text file
+x.get_coors() #this calls the object so that files can be used appropriately
+

morph/shape_predictor_68_face_landmarks.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbdc2cb80eb9aa7a758672cbfdda32ba6300efe9b6e6c7a299ff7e736b11b92f
+size 99693937

morph/tri.txt

@@ -0,0 +1,149 @@
+38 40 37
+35 30 29
+38 37 20
+18 37 36
+33 32 30
+54 64 53
+30 32 31
+59 48 60
+19 79 20
+40 31 41
+36 37 41
+21 39 38
+35 34 30
+51 33 52
+40 29 31
+57 58 66
+36 17 18
+35 52 34
+2 73 1
+65 66 62
+58 67 66
+53 63 52
+61 67 49
+53 65 63
+56 66 65
+55 10 9
+4 73 3
+64 54 55
+69 74 70
+25 79 78
+18 17 72
+43 42 22
+23 79 24
+46 54 35
+14 68 13
+16 26 78
+0 73 17
+1 0 36
+73 72 17
+79 19 72
+19 37 18
+1 36 41
+0 17 36
+37 19 20
+18 72 19
+21 38 20
+39 40 38
+79 23 20
+28 29 39
+41 31 2
+59 67 58
+29 30 31
+34 33 30
+21 27 39
+28 42 29
+52 33 34
+62 66 67
+3 73 2
+48 4 3
+73 0 1
+41 2 1
+31 3 2
+37 40 41
+39 29 40
+57 7 58
+31 48 3
+5 4 48
+70 73 4
+32 49 31
+60 49 59
+7 69 6
+10 75 9
+59 5 48
+70 4 5
+7 6 58
+70 5 6
+31 49 48
+49 67 59
+6 59 58
+6 5 59
+8 7 57
+69 70 6
+12 71 11
+75 74 69
+48 49 60
+32 33 50
+49 50 61
+49 32 50
+51 61 50
+62 67 61
+33 51 50
+63 65 62
+51 62 61
+51 52 63
+51 63 62
+52 35 53
+47 46 35
+54 10 55
+56 57 66
+56 8 57
+69 8 9
+69 7 8
+53 55 65
+9 8 56
+9 75 69
+56 55 9
+11 71 10
+77 71 13
+13 71 12
+10 76 75
+10 71 76
+65 55 56
+10 54 11
+53 64 55
+53 35 54
+12 54 13
+12 11 54
+54 14 13
+68 77 13
+35 42 47
+16 77 68
+45 16 15
+26 25 78
+15 68 14
+15 16 68
+22 42 27
+42 35 29
+27 42 28
+44 25 45
+44 47 43
+46 14 54
+45 46 44
+45 14 46
+39 27 28
+22 23 43
+21 22 27
+21 20 23
+43 23 24
+22 21 23
+44 43 24
+47 42 43
+25 44 24
+46 47 44
+16 45 26
+15 14 45
+45 25 26
+24 79 25
+77 78 71
+77 16 78

morph/triangles.py

@@ -0,0 +1,126 @@
+#!/usr/bin/python
+ 
+import cv2
+import numpy as np
+import random
+ 
+# Check if a point is inside a rectangle
+def rect_contains(rect, point) :
+    if point[0] < rect[0] :
+        return False
+    elif point[1] < rect[1] :
+        return False
+    elif point[0] > rect[2] :
+        return False
+    elif point[1] > rect[3] :
+        return False
+    return True
+ 
+# Draw a point
+def draw_point(img, p, color ) :
+    cv2.circle( img, p, 2, color, cv2.cv.CV_FILLED, cv2.CV_AA, 0 )
+ 
+ 
+# Draw delaunay triangles
+def draw_delaunay(img, subdiv, delaunay_color ) :
+ 
+    triangleList = subdiv.getTriangleList();
+    size = img.shape
+    r = (0, 0, size[1], size[0])
+ 
+    for t in triangleList :
+         
+        pt1 = (t[0], t[1])
+        pt2 = (t[2], t[3])
+        pt3 = (t[4], t[5])
+         
+        if rect_contains(r, pt1) and rect_contains(r, pt2) and rect_contains(r, pt3) :
+         
+            cv2.line(img, pt1, pt2, delaunay_color, 1, cv2.CV_AA, 0)
+            cv2.line(img, pt2, pt3, delaunay_color, 1, cv2.CV_AA, 0)
+            cv2.line(img, pt3, pt1, delaunay_color, 1, cv2.CV_AA, 0)
+ 
+ 
+# Draw voronoi diagram
+def draw_voronoi(img, subdiv) :
+ 
+    ( facets, centers) = subdiv.getVoronoiFacetList([])
+ 
+    for i in xrange(0,len(facets)) :
+        ifacet_arr = []
+        for f in facets[i] :
+            ifacet_arr.append(f)
+         
+        ifacet = np.array(ifacet_arr, np.int)
+        color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+ 
+        cv2.fillConvexPoly(img, ifacet, color, cv2.CV_AA, 0);
+        ifacets = np.array([ifacet])
+        cv2.polylines(img, ifacets, True, (0, 0, 0), 1, cv2.CV_AA, 0)
+        cv2.circle(img, (centers[i][0], centers[i][1]), 3, (0, 0, 0), cv2.cv.CV_FILLED, cv2.CV_AA, 0)
+ 
+ 
+if __name__ == '__main__':
+ 
+    # Define window names
+    win_delaunay = "Delaunay Triangulation"
+    win_voronoi = "Voronoi Diagram"
+ 
+    # Turn on animation while drawing triangles
+    animate = True
+     
+    # Define colors for drawing.
+    delaunay_color = (255,255,255)
+    points_color = (0, 0, 255)
+ 
+    # Read in the image.
+    img = cv2.imread("d.jpg");
+     
+    # Keep a copy around
+    img_orig = img.copy();
+     
+    # Rectangle to be used with Subdiv2D
+    size = img.shape
+    rect = (0, 0, size[1], size[0])
+     
+    # Create an instance of Subdiv2D
+    subdiv = cv2.Subdiv2D(rect);
+ 
+    # Create an array of points.
+    points = [];
+     
+    # Read in the points from a text file
+    with open("d.jpg.txt") as file :
+        for line in file :
+            x, y = line.split()
+            points.append((int(x), int(y)))
+ 
+    # Insert points into subdiv
+    for p in points :
+        subdiv.insert(p)
+         
+        # Show animation
+        if animate :
+            img_copy = img_orig.copy()
+            # Draw delaunay triangles
+            draw_delaunay( img_copy, subdiv, (255, 255, 255) );
+            cv2.imwrite("win_delaunay1.jpg", img_copy)
+            cv2.waitKey(100)
+ 
+    # Draw delaunay triangles
+    draw_delaunay( img, subdiv, (255, 255, 255) );
+ 
+    # Draw points
+    for p in points :
+        draw_point(img, p, (0,0,255))
+ 
+    # Allocate space for Voronoi Diagram
+    img_voronoi = np.zeros(img.shape, dtype = img.dtype)
+ 
+    # Draw Voronoi diagram
+    draw_voronoi(img_voronoi,subdiv)
+ 
+    # Show results
+    cv2.imwrite("win_delaunay.jpg",img)
+    cv2.imwrite("win_voronoi.jpg",img_voronoi)
+    cv2.waitKey(0)