def calculateDelaunayTriangles(self, rect, points): #create subdiv subdiv = cv2.Subdiv2D(rect) # Insert points into subdiv for p in points: subdiv.insert(p) triangleList = subdiv.getTriangleList() delaunayTri = [] pt = [] count = 0 for t in triangleList: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if self.rectContains(rect, pt1) and self.rectContains( rect, pt2) and self.rectContains(rect, pt3): count = count + 1 ind = [] for j in xrange(0, 3): for k in xrange(0, len(points)): if (abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0): ind.append(k) if len(ind) == 3: delaunayTri.append((ind[0], ind[1], ind[2])) pt = [] return delaunayTri
def calculateDelaunayTriangles(rect, points): # subdiv subdiv = cv2.Subdiv2D(rect) print("subdiv: ", subdiv) # 将点插入subdiv for p in points: subdiv.insert(p) triangleList = subdiv.getTriangleList() delaunayTri = [] pt = [] for t in triangleList: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) # 确保检测点是否在rect里面 if rectContains(rect, pt1) and rectContains( rect, pt2) and rectContains(rect, pt3): ind = [] # 通过坐标获取面部点 for j in range(0, 3): for k in range(0, len(points)): if (abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0): ind.append(k) # 三个点组成一个三角形。 三角形数组对应于FaceMorph中的文件tri.txt if len(ind) == 3: delaunayTri.append((ind[0], ind[1], ind[2])) pt = [] return delaunayTri
def calculateDelaunayTriangles_subdiv(rect, points, img): subdiv = cv2.Subdiv2D(rect) for p in points: subdiv.insert(p) # imgToShow = np.copy(img) # draw_delaunay(imgToShow, subdiv) # showBGRimage(imgToShow) triangleList = subdiv.getTriangleList() delaunayTri = [] pt = [] for t in triangleList: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if rectContains(rect, pt1) and rectContains( rect, pt2) and rectContains(rect, pt3): ind = [] for j in xrange(0, 3): for k in xrange(0, len(points)): if (abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0): ind.append(k) if len(ind) == 3: delaunayTri.append((ind[0], ind[1], ind[2])) elif len(ind) > 3: ind = best_solution(ind, 3, 5) delaunayTri.append((ind[0], ind[1], ind[2])) else: logging.error('Insufficient points for making triangle') pt = [] return delaunayTri
def delaunay_triangulation(img_height, img_width, avg_landmarks): ''' Triangulation of the dest_img needs to have the same patterns of the triangulation of the src_img, meaning the connection of the points has to be the same. After the triangulation of the src_img, we use the indices of the landmark points in the triangulation so we can replicate the same triangulation on the dest_img ''' # Make a landmark_coords list and a searchable landmark_coords_dict landmark_coords = [(int(x[0]), int(x[1])) for x in avg_landmarks] landmark_coords_dict = {x[0]:x[1] for x in list(zip(landmark_coords, range(76)))} # Make a bounding rectangle rect = (0, 0, img_height, img_width) # Use OpenCV to subdivide the bounding rect subdiv = cv2.Subdiv2D(rect); # Add landmark_coords to the subdiv for coord in landmark_coords : subdiv.insert(coord) # use the subdiv create the delaunay triangulation list subdiv_triangles = subdiv.getTriangleList(); delaunay_triangles=[] for triang in subdiv_triangles: triang_coord1 = (int(triang[0]), int(triang[1])) triang_coord2 = (int(triang[2]), int(triang[3])) triang_coord3 = (int(triang[4]), int(triang[5])) if point_in_rect(rect, triang_coord1) and \ point_in_rect(rect, triang_coord2) and \ point_in_rect(rect, triang_coord3) : delaunay_triangles.append((landmark_coords_dict[triang_coord1], landmark_coords_dict[triang_coord2], landmark_coords_dict[triang_coord3])) return delaunay_triangles
def calculateDelaunayTriangles(rect, points): #create subdiv subdiv = cv2.Subdiv2D(rect); # Insert points into subdiv for p in points: p1=(int(p[0]),int(p[1])) if p1[1]<=rect[2]-1 and p1[0]<=rect[2]-1 and p1[1]>=rect[0] and p1[0]>=rect[0]: subdiv.insert(p1) triangleList = subdiv.getTriangleList(); delaunayTri = [] pt = [] for t in triangleList: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if rectContains(rect, pt1) and rectContains(rect, pt2) and rectContains(rect, pt3): ind = [] #Get face-points (from 68 face detector) by coordinates for j in range(0, 3): for k in range(0, len(points)): if(abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0): ind.append(k) # Three points form a triangle. Triangle array corresponds to the file tri.txt in FaceMorph if len(ind) == 3: delaunayTri.append((ind[0], ind[1], ind[2])) pt = [] return delaunayTri
def calculate_delaunay_triangles(rect, points): # create subdiv subdiv = cv2.Subdiv2D(rect) # Insert points into subdiv for p in points: subdiv.insert((p[0], p[1])) triangle_list = subdiv.getTriangleList() delaunay_tri = [] pt = [] for t in triangle_list: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if rect_contains_point(rect, pt1) and rect_contains_point( rect, pt2) and rect_contains_point(rect, pt3): ind = [] # Get face-points (from 68 face detector) by coordinates for j in range(0, 3): for k in range(0, len(points)): if ((abs(pt[j][0] - points[k][0]) < 1.0) and (abs(pt[j][1] - points[k][1]) < 1.0)): # if(np.logical_and((abs(pt[j][0] - points[k][0]) < 1.0), (abs(pt[j][1] - points[k][1]) < 1.0))): ind.append(k) # Three points form a triangle. Triangle array corresponds to the file tri.txt in FaceMorph if len(ind) == 3: delaunay_tri.append((ind[0], ind[1], ind[2])) pt = [] return delaunay_tri
def make_delaunay(f_w, f_h, theList): # Make a rectangle. rect = (0, 0, f_w, f_h) # Create an instance of Subdiv2D. subdiv = cv2.Subdiv2D(rect) # Make a points list and a searchable dictionary. theList = theList points = [(int(x[0]), int(x[1])) for x in theList] dictionary = {x[0]: x[1] for x in list(zip(points, range(76)))} # Insert points into subdiv for p in points: subdiv.insert(p) # Make a delaunay triangulation list. list4 = draw_delaunay(f_w, f_h, subdiv, dictionary) # Return the list. return list4
def calculateDelaunayTriangles(rect, points): subdiv = cv2.Subdiv2D(rect) # Create subdiv #print(points) for p in points: subdiv.insert((p[0], p[1])) # Insert points into subdiv triangleList = subdiv.getTriangleList( ) #get the information of triangle dividing delaunayTri = [] #find which point that the triangle point refers to for t in triangleList: ind = [] for j in range(0, 3): for k in range(0, len(points)): if abs(t[2 * j] - points[k][0]) < 0.5 and abs( t[2 * j + 1] - points[k][1]) < 0.5: ind.append(k) break if len(ind) == 3: delaunayTri.append(ind) return delaunayTri
def barycentric_interp(lidar_image): rect = (0, 0, lidar_image.shape[1], lidar_image.shape[0]) lidar_smooth_result = np.zeros( (lidar_image.shape[0], lidar_image.shape[1]), dtype=np.uint8) subdiv = cv2.Subdiv2D(rect) for i in range(0, lidar_image.shape[0]): index = i * lidar_image.shape[1] for j in range(0, lidar_image.shape[1]): if lidar_image[i][j] > 0: subdiv.insert([(j, i)]) index += 1 for i in range(0, lidar_image.shape[0]): for j in range(0, lidar_image.shape[1]): if lidar_image[i][j] > 0: lidar_smooth_result[i][j] = lidar_image[i][j] else: loc, edge, vertex = subdiv.locate((j, i)) neighbor_point = [] for k in range(0, 3): neighbor_point.extend([ np.array(subdiv.getVertex(subdiv.edgeOrg(edge)[0])[0], dtype=np.int) ]) edge = subdiv.getEdge(edge, cv2.Subdiv2D_NEXT_AROUND_LEFT) valid_points = np.full(3, fill_value=False, dtype=np.bool) for k in range(0, 3): if 0 <= neighbor_point[k][0] < lidar_image.shape[1] and 0 <= neighbor_point[k][1] < \ lidar_image.shape[0]: valid_points[k] = True if np.all(valid_points): u, v, w = barycentric(np.array([j, i]), neighbor_point[0], neighbor_point[1], neighbor_point[2]) lidar_smooth_result[i][j] = lidar_image[neighbor_point[0][1]][neighbor_point[0][0]] * u + \ lidar_image[neighbor_point[1][1]][neighbor_point[1][0]] * v + \ lidar_image[neighbor_point[2][1]][neighbor_point[2][0]] * w return lidar_smooth_result
def makeHeighmap(path, name, size, points, heights, tile): # bail if it doesnt look right total_samples = len(points) if total_samples != len(heights): print("Lengths don't match") return # convert mercator to pixels and map pixels to height values # bbox = getTileMercatorBoundingBox(tile[0], tile[1], tile[2]) bbox = getBoundingBox(points) point_heights = {} for i in range(total_samples): x = int(remap(points[i][0], bbox[0], bbox[1], 0, size - 1)) y = int(remap(points[i][1], bbox[2], bbox[3], size - 1, 0)) point_heights[(x, y)] = heights[i] # subdivision from opencv, can do voronoi and its dual the delaunay triangulation subdiv = cv2.Subdiv2D((0, 0, size, size)) for p in point_heights.iterkeys(): subdiv.insert(p) (facets, centers) = subdiv.getVoronoiFacetList([]) # an image where we will rasterize the voronoi cells image = numpy.zeros((size, size, 3), dtype = 'uint8') for i in xrange(0, len(facets)): ifacet_arr = [] for f in facets[i]: ifacet_arr.append(f) ifacet = numpy.array(ifacet_arr, numpy.int) # the color is the height at the voronoi cite for this cell, offset to bring to unsigned 16bits height = point_heights[(centers[i][0], centers[i][1])] + 32768 # to back them into a standard texture we split the high and low order bytes, note the order is G B R color = (int(math.floor(height % 255)), int(math.floor(height / 255) % 255), 0) # we exploit the fact that voronoi cells are convex polygons for faster rasterization cv2.fillConvexPoly(image, ifacet, color, cv2.CV_AA, 0) # we'll keep the result here cv2.imwrite(path + '/' + name + '.png', image)
def _mesh_initializer(landmarks): """ Get triangulation mesh: Call subdiv.getEdgelist() to obtain mesh edges :param landmarks: facial landmark numpy array :return: """ if not isinstance(landmarks, np.ndarray): landmarks = face_utils.shape_to_np(landmarks) landmarks = landmarks.astype(np.int32) size = __output_shape landmarks_added = np.array( [[0, 0], [size[0] // 2, 0], [size[0] - 1, 0], [0, size[1] // 2], [0, size[1] - 1], [size[0] - 1, size[1] // 2], [size[0] // 2, size[1] - 1], [size[0] - 1, size[1] - 1]], dtype=np.int32) landmarks = np.append(landmarks, landmarks_added, axis=0).astype(np.int32) rect = (0, 0, size[1], size[0]) subdiv = cv2.Subdiv2D(rect) for i in range(landmarks.shape[0]): subdiv.insert((landmarks[i][0], landmarks[i][1])) return subdiv
def measure_triangle(image, points): rect = (0, 0, image.shape[1], image.shape[0]) sub_div = cv2.Subdiv2D(rect) for p in points: sub_div.insert(p) triangle_list = sub_div.getTriangleList() triangle = [] pt = [] for t in triangle_list: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if rect_contains(rect, pt1) and rect_contains( rect, pt2) and rect_contains(rect, pt3): ind = [] for j in range(0, 3): for k in range(0, len(points)): # ? if abs(pt[j][0] - points[k][0]) < 1e-7 and abs( pt[j][1] - points[k][1]) < 1e-7: ind.append(k) break if len(ind) == 3: triangle.append((ind[0], ind[1], ind[2])) else: print('errors:', len(ind)) pt = [] return triangle
def calculate_delaunay(img,points): rect = (0,0,img.shape[1],img.shape[0]) subdiv = cv2.Subdiv2D(rect) print(img.shape) for p in points: subdiv.insert(p) triangles = subdiv.getTriangleList() indexes = [] for tri in triangles: pt1 = np.float32([tri[0],tri[1]]) pt2 = np.float32([tri[2],tri[3]]) pt3 = np.float32([tri[4],tri[5]]) index1 = np.argmin(np.sqrt(((np.float32(points) - pt1)**2).sum(axis = 1)),axis = 0) index2 = np.argmin(np.sqrt(((np.float32(points) - pt2)**2).sum(axis = 1)),axis = 0) index3 = np.argmin(np.sqrt(((np.float32(points) - pt3)**2).sum(axis = 1)),axis = 0) indexes.append((index1,index2,index3)) return indexes
def getTriangles(mesh, imageShape): rect = (0, 0, imageShape[0], imageShape[1]) subdiv = cv2.Subdiv2D(rect) subdiv.insert(list(mesh)) triangles = subdiv.getTriangleList() filteredIndexTriangles = [] for triangle in triangles: if (rect[0] <= triangle[0] < rect[2] and rect[0] <= triangle[2] < rect[2] and rect[0] <= triangle[4] < rect[2] and rect[1] <= triangle[1] < rect[3] and rect[1] <= triangle[3] < rect[3] and rect[1] <= triangle[5] < rect[3]): cornerIndices = [] for index in range(0, 6, 2): cornerIndices.append( np.where( (mesh == [triangle[index], triangle[index + 1]]).all(axis=1))[0][0]) filteredIndexTriangles.append(cornerIndices) filteredIndexTriangles = np.array(filteredIndexTriangles) return filteredIndexTriangles
def get_deluanay_triangles_from_landmarks(self, landmarks, bounds): self.say("Getting Deluanay triangles from landmarks... ", "") subdiv2d = cv2.Subdiv2D(bounds) for landmark in landmarks: x, y = landmark subdiv2d.insert((x, y)) triangles = subdiv2d.getTriangleList() deluanay_triangles = [] for triangle in triangles: x1, y1, x2, y2, x3, y3 = triangle point1 = (x1, y1) point2 = (x2, y2) point3 = (x3, y3) if self.__is_point_in_bounds(point1, bounds) and \ self.__is_point_in_bounds(point2, bounds) and \ self.__is_point_in_bounds(point3, bounds): deluanay_triangles.append((point1, point2, point3)) self.say("done") return deluanay_triangles
def _triangulate(self) -> None: # rect (tuple) - "xmin", "ymin", "w", "h" rect = cv2.boundingRect(np.array(self._points)) subdiv = cv2.Subdiv2D(rect) for pt in self._points: subdiv.insert(pt) self._trianglar_grid = [] # trangules trangules = subdiv.getTriangleList() for tri in trangules: # vertices of a triangule tri = [ (tri[0], tri[1]), (tri[2], tri[3]), (tri[4], tri[5]) ] # point indices of a trangule tri_pts = [] for v in tri: # go through all points for idx, pt in enumerate(self._points): if (abs(v[0] - pt[0]) < 1) and (abs(v[1] - pt[1]) < 1): tri_pts.append(idx) self._trianglar_grid.append(tri_pts)
def calculateDelaunayTriangles(rect, points): # Create subdiv subdiv = cv2.Subdiv2D(rect) # Insert points into subdiv for p in points: subdiv.insert((p[0], p[1])) #subdiv.insert([(p[0], p[1]) for p in points]) # List of triangles. Each triangle is a list of 3 points ( 6 numbers ) triangleList = subdiv.getTriangleList() # Find the indices of triangles in the points array delaunayTri = [] for t in triangleList: pt = [] pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if rectContains(rect, pt1) and rectContains( rect, pt2) and rectContains(rect, pt3): ind = [] for j in range(0, 3): for k in range(0, len(points)): if (abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0): ind.append(k) if len(ind) == 3: delaunayTri.append((ind[0], ind[1], ind[2])) return delaunayTri
def calculateDelaunayTriangles(rect, points): #create subdiv subdiv = cv2.Subdiv2D(rect) # Insert points into subdiv for p in points: subdiv.insert(p) triangleList = subdiv.getTriangleList() delaunayTri = [] pt = [] for t in triangleList: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if rectContains(rect, pt1) and rectContains( rect, pt2) and rectContains(rect, pt3): ind = [] #Get face-points (from 68 face detector) by coordinates for j in range(0, 3): for k in range(0, len(points)): if (abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0): ind.append(k) if len(ind) == 3: delaunayTri.append((ind[0], ind[1], ind[2])) pt = [] return delaunayTri
def delaunay(size, points, removeOutlier=False): triList = [] rect = (0, 0, size[1], size[0]) subdivOriginal = cv2.Subdiv2D(rect) for p in points: subdivOriginal.insert(p) triangleList = subdivOriginal.getTriangleList() triangleList = triangleList.astype(np.int32) if removeOutlier == True: for triangle in triangleList: pt1 = (triangle[0], triangle[1]) pt2 = (triangle[2], triangle[3]) pt3 = (triangle[4], triangle[5]) if rect_contains(rect, pt1) and rect_contains(rect, pt2) and rect_contains(rect, pt3): triList.append((pt1, pt2, pt3)) else: for triangle in triangleList: pt1 = (triangle[0], triangle[1]) pt2 = (triangle[2], triangle[3]) pt3 = (triangle[4], triangle[5]) triList.append((pt1, pt2, pt3)) return triList
def construct_triangulation(img, points): rect = (0, 0, img.shape[1], img.shape[0]) sub_div = cv2.Subdiv2D(rect) bound_points = [ ShapeEngine.get_bound_point(img, -(i + 1)) for i in range(8) ] for point in bound_points: sub_div.insert(point) for p in points: sub_div.insert(p) triangle_list = sub_div.getTriangleList() triangles = [] bound_triangles = [] for t in triangle_list: pt = [(t[0], t[1]), (t[2], t[3]), (t[4], t[5])] ind = [] for j in range(3): idx = None for k in range(len(points)): if abs(pt[j][0] - points[k][0]) < 1e-6 and abs( pt[j][1] - points[k][1]) < 1e-6: idx = k break if idx is None: for k in range(len(bound_points)): if abs(pt[j][0] - bound_points[k][0]) < 1e-6 and abs( pt[j][1] - bound_points[k][1]) < 1e-6: idx = -(k + 1) break if idx is None: continue ind.append(idx) if len(ind) == 3: if all(map(lambda x: x >= 0, ind)): triangles.append(ind) else: bound_triangles.append(ind) return triangles, bound_triangles
def triangulation(land_points, img): points = np.array(land_points, np.int32) chull = cv2.convexHull(points) rect = cv2.boundingRect(chull) rectangle = np.asarray(rect) subdiv = cv2.Subdiv2D(rect) p_list = [] for p in land_points: p_list.append((p[0], p[1])) for p in p_list: subdiv.insert(p) triangles = subdiv.getTriangleList() triangles = np.array(triangles, dtype=np.int32) vert = [] VPoint = [] pt = [] for t in triangles: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) temp = [] for i in range(3): for j in range(len(points)): if (abs(pt[i][0] - points[j][0]) < 1.0 and abs(pt[i][1] - points[j][1]) < 1.0): temp.append(j) if len(temp) == 3: vert.append((points[temp[0]], points[temp[1]], points[temp[2]])) VPoint.append((temp[0], temp[1], temp[2])) pt = [] #cv2.line(img, tuple(points[temp[0]]), tuple(points[temp[1]]), (0, 0, 255), 2) #cv2.line(img, tuple(points[temp[1]]), tuple(points[temp[2]]), (0, 0, 255), 2) #cv2.line(img, tuple(points[temp[0]]), tuple(points[temp[2]]), (0, 0, 255), 2) vert = np.asarray(vert) VPoint = np.asarray(VPoint) chull = np.reshape(chull, (chull.shape[0], chull.shape[2])) return img, vert, VPoint, chull
def getDelaunayTriangles(points): #获取点的边界 convexHullPoints = getConvexHullPoints(points) #print convexHullPoints rec = cv2.boundingRect(np.int32([convexHullPoints])) #print rec subdiv = cv2.Subdiv2D((0, 0, rec[0] + rec[2], rec[1] + rec[3])) for point in points: #print point,rec,(0, 0, rec[0]+rec[2],rec[1]+rec[3]) subdiv.insert((point[0], point[1])) triangles = subdiv.getTriangleList() validTriangles = [] for triangle in triangles: pt1 = (triangle[0], triangle[1]) pt2 = (triangle[2], triangle[3]) pt3 = (triangle[4], triangle[5]) if pt1 not in points or pt2 not in points or pt3 not in points: continue validTriangles.append(np.int32([pt1, pt2, pt3])) #print np.int32([pt1,pt2,pt3]) return np.int32(validTriangles)
def measure_triangle(image, points): #(src_img, morph_points) # print('measure_triangle===') rect = (0, 0, image.shape[1], image.shape[0]) sub_div = cv2.Subdiv2D(rect) for p in points: sub_div.insert(p) # print('p',image.shape,p) # sub_div.insert((p[1],p[0])) triangle_list = sub_div.getTriangleList() triangle = [] pt = [] for t in triangle_list: pt.append((t[0], t[1])) pt.append((t[2], t[3])) pt.append((t[4], t[5])) pt1 = (t[0], t[1]) pt2 = (t[2], t[3]) pt3 = (t[4], t[5]) if rect_contains(rect, pt1) and rect_contains( rect, pt2) and rect_contains(rect, pt3): ind = [] for j in range(0, 3): for k in range(0, len(points)): if abs(pt[j][0] - points[k][0]) < 1.0 and abs( pt[j][1] - points[k][1]) < 1.0: ind.append(k) if len(ind) == 3: triangle.append((ind[0], ind[1], ind[2])) pt = [] return triangle
def _delaunay_triangulation(self): """ Delaunay triangulation https://blog.csdn.net/zhaoyin214/article/details/87942919 """ # rect (tuple) - "xmin", "ymin", "w", "h" rect = cv2.boundingRect(self._points.values) subdiv = cv2.Subdiv2D(rect) for _, pt in self._points.iterrows(): subdiv.insert(tuple(pt)) # index of points consist of a trangular triangulation_pt_indices = [] triangule_list = subdiv.getTriangleList() for tri in triangule_list: # vertices of a triangule tri_vertices = [(tri[0], tri[1]), (tri[2], tri[3]), (tri[4], tri[5])] # index of points consist of a trangular tri_pt_idx_list = [] for vertex in tri_vertices: # traverse all points for pt_idx, pt in self._points.iterrows(): if (abs(vertex[0] - pt.x) < 1) and \ (abs(vertex[1] - pt.y) < 1): tri_pt_idx_list.append(pt_idx) triangulation_pt_indices.append(tri_pt_idx_list) self._triangulation_pt_indices = pd.DataFrame( triangulation_pt_indices, columns=TRIANGULATION_COLUMES)
def voronoi(self, img, landmark_dict, colors=None, remove_bg=False): if remove_bg: img_copy = np.full(img.shape, 255, dtype=np.uint8) else: img_copy = img.copy() #Copy image to not affect the original one bg = None for landmark in landmark_dict: landmark_points = landmark_dict[landmark] hull_pts = np.int32(landmark_points) size = img.shape rect = (0, 0, size[1], size[0]) #Create subdiv with the whole image subdiv = cv2.Subdiv2D(rect) subdiv.insert(landmark_points) (facets, centers) = subdiv.getVoronoiFacetList([]) k = len(colors) for i in range(len(facets)): if colors: (rb, rg, rr) = colors[i % k] else: (rb, rg, rr) = self.pick_random_colors(1)[0] ith_facet = list() for f in facets[i]: ith_facet.append(f) ith_facet = np.array(ith_facet, np.int) cv2.fillConvexPoly(img_copy, ith_facet, (rb, rg, rr)) return img_copy
def voronoi_from_pixels(pixels, dimensions, pixelsOfInterest): # Create the subdiv which will hold the voronoi information rect = (0, 0, dimensions[0], dimensions[1]) subdiv = cv2.Subdiv2D(rect) for pixel in pixelsOfInterest: p = pixel[0], pixel[1] subdiv.insert(p) # Allocate space for Voronoi Diagram # img_voronoi should have shape (height, width, channels) img_voronoi = np.zeros(shape=(HEIGHT, WIDTH, 3), dtype=np.uint8) # Draw Voronoi diagram (facets, centers) = subdiv.getVoronoiFacetList([]) facetCount = len(facets) for i in range(0, len(facets)): ifacet_arr = [] for f in facets[i]: ifacet_arr.append(f) ifacet = np.array(ifacet_arr, np.int) p = centers[i] y = int(p[1]) x = int(p[0]) rgb = stateRepresentation.get_rgb_pixel_from_frame(pixels, x, y) # Get BGR color color = [rgb[2], rgb[1], rgb[0]] cv2.fillConvexPoly(img_voronoi, ifacet, color, cv2.LINE_AA, 0) ifacets = np.array([ifacet]) cv2.polylines(img_voronoi, ifacets, True, (0, 0, 0), 1, cv2.LINE_AA, 0) s = img_voronoi.shape l = len(img_voronoi) return img_voronoi
def drawTriangles(fileName, imageType): image = cv2.imread(fileName) if ("cat" in imageType): imageMarked, imagePts = tempPtsToCatImage(fileName) else: imageMarked, imagePts = markTheHumanFace(fileName) subdiv = cv2.Subdiv2D((0, 0, image.shape[1], image.shape[0])) for i in range(68): subdiv.insert(imagePts[i]) height = image.shape[0] width = image.shape[1] subdiv.insert((0, 0)) subdiv.insert((width / 2, 0)) subdiv.insert((width - 1, 0)) subdiv.insert((width - 1, height / 2)) subdiv.insert((width - 1, height - 1)) subdiv.insert((width / 2, height - 1)) subdiv.insert((0, height - 1)) subdiv.insert((0, height / 2)) triangles = subdiv.getTriangleList() colorGreen = (0, 255, 0) for i in range(len(triangles)): sel_triangle = triangles[i].astype(np.int) cv2.line(image, (sel_triangle[0], sel_triangle[1]), (sel_triangle[2], sel_triangle[3]), colorGreen) cv2.line(image, (sel_triangle[0], sel_triangle[1]), (sel_triangle[4], sel_triangle[5]), colorGreen) cv2.line(image, (sel_triangle[2], sel_triangle[3]), (sel_triangle[4], sel_triangle[5]), colorGreen) return image
def makeDelaunay(image, listOfPoints): '''the input is an image file read in by opencv and a list of average points the output is the final triangulation points in a list of tuples ''' size = image.shape rect = (0, 0, size[0], size[0]) # Create an instance of Subdiv2D. subdiv = cv2.Subdiv2D(rect) # Make a points list and a searchable dictionary. theList = listOfPoints points = [(int(x[0]), int(x[1])) for x in theList] #making a tuple of points #the following line might still need some testing dictionary = {x[0]: x[1] for x in list(zip(points, range(len(points))))} # Insert points into subdiv for p in points: subdiv.insert(p) # Make a delaunay triangulation list. return draw_delaunay(subdiv, dictionary, rect)
def generate_voronoi_diagram(img): if (type_grid == "random"): points = np.random.rand(num_cells, 2) points = scale_points(points) keyPoints = np.array(points) elif (type_grid == "const"): brief = cv2.xfeatures2d.SIFT_create(num_cells) kp = brief.detect(img, None) keyPoints = cv2.KeyPoint_convert(kp) points = [] for keyPoint in keyPoints: points.append((keyPoint[0], keyPoint[1])) size = img.shape print(size) subdiv2DShape = (0, 0, size[1], size[0]) subdiv = cv2.Subdiv2D(subdiv2DShape) for p in points: subdiv.insert(p) return subdiv
def delaunaryTriangles(rect,points): #print(points,rect) subdiv = cv2.Subdiv2D(rect) pointsDict = {} #Get the triangle list for i,p in enumerate(points) : subdiv.insert((int(p[0]),int(p[1]))) pointsDict[(int(p[0]),int(p[1]))] = i triangleList = subdiv.getTriangleList(); triangleIndList = [] #Get the index of the triangle points for t in triangleList : pt1 = (int(t[0]), int(t[1])) pt2 = (int(t[2]), int(t[3])) pt3 = (int(t[4]), int(t[5])) if pt1 in pointsDict and pt2 in pointsDict and pt3 in pointsDict: triangleIndList.append([pointsDict[pt1],pointsDict[pt2],pointsDict[pt3]]) return triangleIndList