0:\n\t\t\tzIndexMin = zIndexList.index(min(zIndexList))\n\t\t\tgeneIdx = gIndexList[zIndexMin]\n\t\t\tz = self.chromosome[geneIdx,0]\n\t\t\tcolor = self.chromosome[geneIdx,1]\n\t\t\tpoly = self.chromosome[geneIdx,2]\n\n\t\t\tcol = color.getColor()\n\t\t\tcords = poly.getCords()\n\t\t\tbrush = aggdraw.Brush(col)\n\n\t\t\t#dr.ellipse((x, y, x+rad, y+rad), None, brush)\n\t\t\tdr.polygon(cords, None, brush)\n\t\t\tdr.flush()\n\n\t\t\tif 0: # Debug - draw dot in center of polygon\n\t\t\t\tcenter = (poly.xAnchor, poly.yAnchor, poly.xAnchor+5, poly.yAnchor+5)\n\t\t\t\tdr.ellipse(center, None, aggdraw.Brush((255,0,0,255)))\n\t\t\t\tdr.flush()\n\n\t\t\tzIndexList.pop(zIndexMin)\n\t\t\tgIndexList.pop(zIndexMin)\n\n\t\tself.image = self.image.convert(\"RGB\")","def img_roi(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(self,img):\r\n #defining a blank mask\r\n mask = np.zeros_like(img) \r\n #checking number of image channel(color/grayscale) and applying mask\r\n if len(img.shape) > 2:\r\n ignore_mask_color = (255,255,255)\r\n else:\r\n ignore_mask_color = 255\r\n #filling color to pixels inside the polygon \r\n cv2.fillPoly(mask, self.vertices_img, ignore_mask_color)\r\n #image where mask pixels are nonzero\r\n masked_image = cv2.bitwise_and(img, mask)\r\n #cv2.imshow('',masked_image)\r\n return masked_image","def get_polygon(img, gradx, grady, seed):\n rays = get_rays(NRAY, RHO, RHO_SKIP)\n # minCellSize = np.pi * MINCELLRADIUS**2\n # maxCellSize = np.pi * MAXCELLRADIUS**2\n assert 0<seed[0]<img.shape[0] and 0<seed[1]<img.shape[1]\n (cr,cc) = seed # cr, cc is the coordinates of the seed\n [ac, ar] = np.meshgrid(np.array(range(img.shape[0])), np.array(range(img.shape[1])))\n cac = (ac-cc).astype(np.float32) # cac,car represent the distance of each pixel on the image to the seed\n car = (ar-cr).astype(np.float32)\n with np.errstate(all='ignore'):\n unitx = np.cos(np.arctan(np.abs(car/cac))) * np.sign(cac) # unitx,unity represent cosine value of each pixel on the image to the seed\n unity = np.cos(np.arctan(np.abs(cac/car))) * np.sign(car)\n dirslopes = gradx * unitx + grady * unity # dirslopes is the gradient map which consider the seed points as the center\n\n tab = np.zeros((RHO - RHO_SKIP, NRAY))\n gxtab = np.zeros((RHO - RHO_SKIP, NRAY))\n gytab = np.zeros((RHO - RHO_SKIP, NRAY))\n pixtab = np.zeros((RHO - RHO_SKIP, NRAY))\n for i in range(NRAY):\n for j in range(RHO-RHO_SKIP):\n pr = int(cr + rays[i][j, 0])\n pc = int(cc + rays[i][j, 1])\n tab[j, i] = dirslopes[pr, pc]\n gxtab[j, i] = gradx[pr, pc]\n gytab[j, i] = grady[pr, pc]\n pixtab[j, i] = img[pr, pc]\n\n minpath = findminpath(tab, gxtab, gytab, pixtab) # get the minpath\n\n polygon = np.zeros((NRAY, 2))\n for i in range(NRAY):\n polygon[i, 0] = cr + rays[i][minpath[i], 0]\n polygon[i, 1] = cc + rays[i][minpath[i], 1]\n #hull = ConvexHull(polygon)\n #polygon = polygon[hull.vertices]\n #print(polygon.shape[0])\n return polygon","def select_region(image):\n # Define the polygon by vertices\n rows, cols = image.shape[:2]\n bottom_left = [cols*0.05, rows*0.95]\n top_left = [cols*0.3, rows*0.55]\n bottom_right = [cols*0.95, rows*0.95]\n top_right = [cols*0.7, rows*0.55]\n # Vertices are an array of polygons (i.e array of arrays) and the data type must be integer.\n vertices = np.array([[bottom_left, top_left, top_right, bottom_right]], dtype=np.int32)\n return filter_region(image, vertices)","def createImgOverlay(sli, graph, drawing_params, notAnEmptySlice):\n \n (Y, X) = sli.shape\n \n # Creation of the superposition file (3 dimensions because RGB for the graph drawing)\n sli_ovl = np.zeros([Y, X, 3], np.uint8)\n sli_ovl[:, :, 0] = sli\n sli_ovl[:, :, 1] = sli\n sli_ovl[:, :, 2] = sli\n \n if notAnEmptySlice:\n line = drawing_params[0]\n line_color = drawing_params[1]\n line_size = drawing_params[2]\n apex_color = drawing_params[3]\n apex_size = drawing_params[4]\n node_color = drawing_params[5]\n node_size = drawing_params[6]\n body_color = drawing_params[7]\n body_size = drawing_params[8]\n \n graph = nx.convert_node_labels_to_integers(graph, first_label=0, \n ordering='default', \n label_attribute=None)\n \n # Creation of arrays from graph elements \n x_node = np.fromiter(nx.get_node_attributes(graph, 'x').values(), \n dtype=int) \n y_node = np.fromiter(nx.get_node_attributes(graph, 'y').values(), \n dtype=int) \n degrees = np.array([degree for node, degree in nx.degree(graph)], \n dtype=int) \n edges = np.array(graph.edges())\n \n # Lists of edges coordinates\n x1 = x_node[edges[:, 0]]\n y1 = y_node[edges[:, 0]]\n x2 = x_node[edges[:, 1]]\n y2 = y_node[edges[:, 1]]\n \n # Edges drawing\n if line:\n for i in range(len(x1)):\n cv2.line(sli_ovl, (x1[i], y1[i]), (x2[i], y2[i]), \n line_color, line_size)\n \n # Nodes drawing\n for i in range(len(x_node)):\n if degrees[i] == 1: # apex points\n color = apex_color\n size = apex_size\n elif degrees[i] == 2: # body/hypha points\n color = body_color\n size = body_size\n else: # branching/node points\n color = node_color\n size = node_size\n cv2.circle(sli_ovl, (x_node[i], y_node[i]), size, color, \n thickness=-1)\n\n return sli_ovl","def render(self, ctx):\n image = np.zeros((self.height, self.width, 3), np.uint8)\n for shape in ctx.shapes:\n if isinstance(shape, context.Rectangle):\n x = int(shape.width / 2)\n y = int(shape.height / 2)\n rad = np.radians(shape.rotation)\n rotation = np.array([[np.cos(rad), -np.sin(rad)],\n [np.sin(rad), np.cos(rad)]])\n translation = np.array([[shape.center.x], [shape.center.y]])\n corners = np.array([[-x, x, x, -x], [y, y, -y, -y]])\n transformed_corners = rotation.dot(corners) + translation\n transformed_corners = transformed_corners.T.astype(int)\n cv2.fillPoly(image, pts=[transformed_corners],\n color=shape.color)\n elif isinstance(shape, context.Circle):\n center = (int(shape.center.x), int(shape.center.y))\n image = cv2.circle(image, center, int(shape.radius),\n color=shape.color, thickness=shape.thickness)\n elif isinstance(shape, context.Text):\n center = (int(shape.center.x), int(shape.center.y))\n image = cv2.putText(image, shape.content, center,\n cv2.FONT_HERSHEY_SIMPLEX, shape.size,\n shape.color, 3, cv2.LINE_AA)\n elif isinstance(shape, context.Image):\n file_image = cv2.imread(shape.filepath, cv2.IMREAD_UNCHANGED)\n file_image = cv2.resize(file_image, (shape.width, shape.height))\n\n y1 = int(shape.center.y - shape.height / 2)\n y2 = int(y1 + file_image.shape[0])\n x1 = int(shape.center.x - shape.width / 2)\n x2 = int(x1 + file_image.shape[1])\n\n rgba = cv2.cvtColor(file_image, cv2.COLOR_RGB2RGBA)\n alpha_s = rgba[:, :, 3] / 255.0\n alpha_l = 1.0 - alpha_s\n\n image_save = image.copy()\n for c in range(0, 3):\n try:\n image[y1:y2, x1:x2, c] = (\n alpha_s * file_image[:, :, c] +\n alpha_l * image[y1:y2, x1:x2, c])\n except ValueError:\n image = image_save\n\n self._display_frame(image)","def _change_shape(self,x,y,w,h):\n top = y \n left = x\n right = x + w\n bottom = y + h\n return top,right,bottom,left","def make_polygon(*coords):\n global GEOMETRY_SURF, POLYGONS,col\n if len(coords) < 3:\n print(\"Warning: Invalid polygon passed, ignoring...\")\n return\n start = coords[0]\n prev = coords[0]\n for coord in coords:\n POLYGONS |= {coord}\n line = Boundary(prev[0],prev[1],coord[0],coord[1]) #add segment to WALL list\n prev = coord\n line = Boundary(prev[0], prev[1],start[0],start[1])\n #now draw poly\n pygame.draw.polygon(GEOMETRY_SURF,col[\"SHAPECOL\"], coords)\n return","def crop_image(image,list_coordinate):\n list_character = []\n lp_image = imutils.resize(image,width = 200)\n for bbox in list_coordinate:\n if bbox[0][0] == bbox[0][1] == bbox[1][0] == bbox[1][1]:\n break\n\n pts = np.array([(bbox[0][0],bbox[0][1]),\n (bbox[1][0],bbox[1][1]),\n (bbox[2][0],bbox[2][1]),\n (bbox[3][0],bbox[3][1])],dtype = \"float32\")\n \n warped = four_point_transform(lp_image,pts)\n\n # _,warped = cv2.threshold(cv2.cvtColor(warped,cv2.COLOR_BGR2GRAY),0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n # warped = cv2.resize(warped,(12,28))\n warped = resize_and_pad(warped, (28,28), padColor= 255)\n warped = warped / 255.0\n\n # warped = warped[..., None]\n list_character.append(warped)\n return list_character","def read_polygon_shapefile(filename):\n result = cpp_read_polygon_shapefile(filename)\n f_pos = Series(result[0], name=\"f_pos\")\n r_pos = Series(result[1], name=\"r_pos\")\n return (\n f_pos,\n r_pos,\n DataFrame({\"x\": result[2], \"y\": result[3]}),\n )","def spatial(self):","def roi_boundary(roi, pts_per_side=2):\n yy, xx = roi\n xx = np.linspace(xx.start, xx.stop, pts_per_side, dtype='float32')\n yy = np.linspace(yy.start, yy.stop, pts_per_side, dtype='float32')\n\n return polygon_path(xx, yy).T[:-1]","def test_drawWire(self):\n\n image_name = filename(sys._getframe().f_code.co_name)\n result_file, reference_file = get_path(image_name)\n\n ''' This function is to create an empty image with a specific dimension\n with white background, and black/white colored '''\n\n image, canvas = get_image('L',(640,480),'white')\n\n drawWire(canvas, regularPolygon(3, np.array([160, 120]), 50))\n drawWire(canvas, regularPolygon(4, np.array([480, 120]), 90))\n drawWire(canvas, regularPolygon(5, np.array([420, 360]), 60))\n drawWire(canvas, regularPolygon(6, np.array([160, 360]), 80))\n drawWire(canvas, regularPolygon(7, np.array([320, 160]), 70))\n\n \"\"\" saving the file and closing it \"\"\"\n\n image.save(result_file)\n image.close()\n\n \"\"\" validate the resultant file against the reference images\"\"\"\n\n validate(reference_file, result_file)","def convert_lane_boundaries_to_polygon(right_lane_bounds: np.ndarray, left_lane_bounds: np.ndarray) -> np.ndarray:\n assert right_lane_bounds.shape[0] == left_lane_bounds.shape[0]\n polygon = np.vstack([right_lane_bounds, left_lane_bounds[::-1]])\n polygon = np.vstack([polygon, right_lane_bounds[0]])\n return polygon","def g_corners(self):\n return (point for point in self.p)","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def generate_polygon(x,y,N):\r\n # Add the first point to the end of the list and convert to array if needed\r\n if type(x) == list:\r\n x = np.array(x + [x[0]])\r\n y = np.array(y + [y[0]])\r\n else:\r\n x = np.append(x,x[0])\r\n y = np.append(y,y[0])\r\n \r\n # Parameterize the arrays and interpolate\r\n d = [get_distance((x[i],y[i]),(x[i+1],y[i+1])) for i in range(len(x)-1)]\r\n d = np.cumsum([0]+d)\r\n t = np.linspace(0,d[-1],N)\r\n fx = interp1d(d,x)\r\n fy = interp1d(d,y)\r\n x = fx(t)\r\n y = fy(t)\r\n \r\n return x,y","def draw_final_image(self, image, warped, undist, ploty, left_fitx, right_fitx, Minv, left_rad, right_rad):\n gray = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)\n # Create an image to draw the lines on\n warp_zero = np.zeros_like(gray).astype(np.uint8)\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\n\n # Recast the x and y points into usable format for cv2.fillPoly()\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\n pts = np.hstack((pts_left, pts_right))\n\n # Draw the lane onto the warped blank image\n cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))\n\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\n newwarp = cv2.warpPerspective(color_warp, Minv, (image.shape[1], image.shape[0]))\n # Combine the result with the original image\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\n\n font = cv2.FONT_HERSHEY_SIMPLEX\n off_center = calculate_center(left_fitx, right_fitx, image.shape)\n direction_str = 'left' if off_center < 0 else 'right'\n center_str = '{:.2f} m of center {}'.format(abs(off_center), direction_str)\n cv2.putText(result, center_str, (430, 630), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\n if left_rad and right_rad:\n curvature = 0.5 * (round(right_rad / 1000, 1) + round(left_rad / 1000, 1))\n else:\n curvature = 0\n str2 = 'Radius of curvature: {} km'.format(curvature)\n cv2.putText(result, str2, (430, 670), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\n\n if self.args.is_test:\n plt.imshow(result)\n plt.show()\n\n return result","def photo(self):\n x_coords = [self.x1, self.x2, self.x3]\n y_coords = [self.y1, self.y2, self.y3]\n # draw the triangle\n fig = pyplot.figure()\n fig.add_subplot(111)\n pyplot.fill(x_coords, y_coords, 'black')\n fig.canvas.draw()\n # convert it to a numpy array\n w, h = fig.canvas.get_width_height()\n buf = numpy.fromstring(fig.canvas.tostring_argb(), dtype=numpy.uint8)\n buf.shape = (w, h, 4)\n # roll it from ARBG to RGBA\n buf = numpy.roll(buf, 3, axis=2)\n return buf","def polygonFromInteriorPoints(geom, preferredEpsg):\n (projTr, llTr) = makeTransformations(4326, preferredEpsg)\n\n geomProj = copyGeom(geom)\n geomProj.Transform(projTr)\n geomOutline = geomProj.ConvexHull()\n geomOutline.Transform(llTr)\n return geomOutline","def get_image_corners (wcs):\n return list(wcs.calc_footprint())","def create_image(self, shapes):\n img = image.IMG()\n img.draw_shapes(shapes)\n img = np.transpose(img.array(), (2, 0, 1))\n return img","def speedboost():\n image = pygame.Surface([20, 20])\n image.fill(colour.SILVER)\n pygame.draw.polygon(image, colour.YELLOW, [(0, 15), (10, 4), (20, 15)])\n pygame.draw.polygon(image, colour.SILVER, [(0, 19), (10, 9), (20, 19)])\n return image","def makePolygon(center, sides, radius, background, colorValue, colorsRGB):\n\n\tpoints = polygon(center, sides, radius)\n\tpointsList = [list(a) for a in points]\n\tp1 = np.array(pointsList)\n\timg = np.zeros((256, 256, 3), dtype='int32')\n\tif(background == \"white\"):\n\t\timg.fill(255)\n\telif(background == \"random\"):\n\t\tr = random.randint(200,245)\n\t\tb = random.randint(200,245)\n\t\tg = random.randint(200,245)\n\t\timg = np.full(img.shape, (r,b,g), dtype=np.uint8)\n\tcv2.fillPoly(img, pts =[p1], color = colorsRGB[colorValue])\n\treturn img","def produce_polygon(polygon_ordered_coordinates: List, zoom: int, plot_polygon: bool = False) -> Path:\n polygon_tile_points = []\n for item in polygon_ordered_coordinates:\n polygon_tile_points += [Utility.get_tile(*item, zoom)]\n polygon_tile_points += [polygon_tile_points[0]]\n polygon = Path(polygon_tile_points)\n if plot_polygon:\n fig = plt.figure()\n ax = fig.add_subplot(111)\n patch = patches.PathPatch(polygon, facecolor='orange', lw=2)\n ax.add_patch(patch)\n ax.set_xlim(min(polygon_tile_points, key = lambda item: item[0])[0], max(polygon_tile_points, key = lambda item: item[0])[0])\n ax.set_ylim(min(polygon_tile_points, key = lambda item: item[1])[1], max(polygon_tile_points, key = lambda item: item[1])[1])\n plt.show()\n return polygon","def poly2mask(self):\n self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)\n self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)\n img = Image.new(\"L\", (self.x_gridnum, self.y_gridnum), 0)\n\n self.perimeter = 0.0\n for ii in self.polygons:\n pp = np.array(ii) * self.CD # polygon\n polygonlen = len(pp)\n self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))\n pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize\n pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize\n vetex_list = list(pp)\n polygon = [tuple(y) for y in vetex_list]\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\n\n self.data = np.array(img)\n self.data = np.float64(self.data)\n\n self.spat_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.freq_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))","def shape(self, rootsequence, side, image, option=0):\n\n left_points = self.get_points(\n side=0,\n imgnumber=image)\n\n leftX, leftY, leftZ = self.separate_points_by_coordinate(left_points)\n\n right_points = self.get_points(\n side=1,\n imgnumber=image)\n\n rightX, rightY, rightZ = self.separate_points_by_coordinate(right_points)\n\n if option == 1:\n lalpha_shapes = self.alpha_shapes(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n alpha=5,\n # color='#A91818',\n color='#808080',\n opacity=1.0)\n\n ralpha_shapes = self.alpha_shapes(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n alpha=5,\n # color='#FF3232',\n color='#808080',\n opacity=1.0)\n\n return [lalpha_shapes, ralpha_shapes]\n\n elif option == 2:\n lpoint_cloud = self.point_cloud(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n legend='RIGHT LUNG',\n size=1,\n # color='#FF3232',\n # bordercolor='#FF3232',\n color='#999999',\n bordercolor='#999999',\n width=0.5,\n opacity=1.0)\n\n rpoint_cloud = self.point_cloud(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n legend='LEFT LUNG',\n size=1,\n # color='#701700',\n # bordercolor='#701700',\n color='#999999',\n bordercolor='#999999',\n width=0.5,\n opacity=1.0)\n\n lalpha_shapes = self.alpha_shapes(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n alpha=5,\n color='rgba(255, 0, 0, 0.1)',\n # color='#808080',\n opacity=1.0)\n\n ralpha_shapes = self.alpha_shapes(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n alpha=5,\n color='rgba(255, 0, 0, 0.1)',\n # color='#808080',\n opacity=1.0)\n\n return [lpoint_cloud, rpoint_cloud, lalpha_shapes, ralpha_shapes]\n\n else:\n lpoint_cloud = self.point_cloud(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n legend='RIGHT LUNG',\n size=1,\n # color='#FF3232',\n # bordercolor='#FF3232',\n color='#999999',\n bordercolor='#999999',\n width=0.5,\n opacity=1.0)\n\n rpoint_cloud = self.point_cloud(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n legend='LEFT LUNG',\n size=1,\n color='#999999',\n bordercolor='#999999',\n # color='#701700',\n # bordercolor='#701700',\n width=0.5,\n opacity=1.0)\n\n return [lpoint_cloud, rpoint_cloud]","def shape(self):","def shape(self):","def polygon_path(x, y=None):\n\n if y is None:\n y = x\n\n return np.vstack([\n np.vstack([x, np.full_like(x, y[0])]).T,\n np.vstack([np.full_like(y, x[-1]), y]).T[1:],\n np.vstack([x, np.full_like(x, y[-1])]).T[::-1][1:],\n np.vstack([np.full_like(y, x[0]), y]).T[::-1][1:]]).T","def _svg_to_polygons(cdata):\n polygons = []\n groups = parse(cdata['image'])\n\n #iterating this dict in a strange way, need to refactor maybe\n for g in groups:\n for path in groups[g]:\n #this list comprehension gets the region coordinates\n points = ([(p[0] * cdata['width_ratio'] + cdata['start_pos'], p[1]\n * cdata['height_ratio']) for p in path[1]])\n\n polygons.append({_convert_state_to_region(g):points})\n\n return polygons","def fit_poly(img_shape, leftx, lefty, rightx, righty):\n left_fit = np.polyfit(lefty, leftx, deg=2)\n right_fit = np.polyfit(righty, rightx, deg=2)\n # Generate x and y values for plotting\n ploty = np.linspace(0, img_shape[0]-1, img_shape[0])\n ### TO-DO: Calc both polynomials using ploty, left_fit and right_fit ###\n left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]\n right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\n \n return left_fitx, right_fitx, ploty","def __repr__(self):\n return 'Polygon({%s})' % \", \".join(str(line) for line in self.lines)","def _create_main_shape(self):\n\n a, b = gc( self.size/2,\n self._ZERO_DEGREES - self.angle,\n self._180_DEGREES + self.angle)\n self.wafer_points = zip(a,b)\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\n self.cell.add(self.wafer_polygon)","def create_general_object(self, x, y):\n return self.img[y-self.rad:y+self.rad, x-self.rad:x+self.rad]","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def decorate_scene():\n make_polygon( (100,100),(120,140),(270,70) )\n make_polygon( (300,10), (300,550), (340,452),(380,300), (330,50))\n make_polygon( (200,450), (100,450), (100,500), (200,500) )\n make_polygon( (130,320), (150,300), (140,280) )\n return","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img)\n\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n\n #filling pixels inside the polygon defined by \"vertices\" with the fill color\n cv2.fillPoly(mask, vertices, ignore_mask_color)\n\n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n\n return masked_image","def heliographic(self, *args):\n\n\t\txScl = self.im_raw.scale[0].value\n\t\tyScl = self.im_raw.scale[1].value\n\t\t\n\t\t# Check for single coordinate or ndarray object.\n\t\tif isinstance(args[0], np.ndarray):\n\t\t\t# Retrieve integer dimensions and create arrays holding\n\t\t\t# x and y coordinates of each pixel\n\t\t\txdim = np.int(np.floor(self.im_raw.dimensions[0].value))\n\t\t\tydim = np.int(np.floor(self.im_raw.dimensions[1].value))\n\t\t\ttry:\n\t\t\t\txrow = (np.arange(0, xdim) - self.X0 + args[1])*xScl\n\t\t\t\tyrow = (np.arange(0, ydim) - self.Y0 + args[2])*yScl\n\t\t\t\tself.xg, self.yg = np.meshgrid(xrow, yrow, indexing='xy')\n\t\t\t\tself.rg = np.sqrt(self.xg**2 + self.yg**2)\n\t\t\t\tx = self.xg\n\t\t\t\ty = -self.yg\n\t\t\texcept IndexError:\n\t\t\t\txrow = (np.arange(0, xdim) - self.X0)*xScl\n\t\t\t\tyrow = (np.arange(0, ydim) - self.Y0)*yScl\n\t\t\t\tself.xg, self.yg = np.meshgrid(xrow, yrow, indexing='xy')\n\t\t\t\tself.rg = np.sqrt(self.xg**2 + self.yg**2)\n\t\t\t\tx = self.xg\n\t\t\t\ty = -self.yg\n\t\telse:\n\t\t\t# Have to switch coordinate conventions because calculations\n\t\t\t# assume standard cartesian whereas python indexing is \n\t\t\t# [row, column]\n\t\t\tx = (args[1] - self.X0)*xScl/60.0\n\t\t\ty = (self.Y0 - args[0])*yScl/60.0\n\n\t\tb0_r = np.deg2rad(self.B0)\n\t\tradius = self.rsun\n\t\tRobs = 1/np.tan(np.deg2rad(radius/60))\n\n\t\txxat = np.tan(np.deg2rad(x/60))\n\t\tyyat = np.tan(np.deg2rad(y/60))\n\n\t\trat2 = (xxat**2 + yyat**2)\n\t\tphi = 0*rat2\n\t\tw_rat2 = np.where(rat2 is not 0)\n\t\tphi[w_rat2] = np.arctan2(xxat[w_rat2], yyat[w_rat2])\n\n\t\tmax_ra = np.arcsin(1.0/Robs)\n\t\tmax_rat2 = np.tan(max_ra)*np.tan(max_ra)\n\n\t\tii = np.where(rat2 > max_rat2)\n\t\tif ii[0].any() > 0:\n\t\t\trat2[ii] = max_rat2\n\t\t\t#offlimb[ii] = 1\n\n\t\t###############################################\n\t\tras2 = 0*rat2\n\t\tras2[w_rat2] = 1.0/(1.0 + 1.0/rat2[w_rat2])\n\t\td1 = (1.0 - ras2)\n\t\td2 = (1.0 - (Robs**2*ras2))\n\t\tx = ras2*Robs + np.sqrt(d1)*np.sqrt(d2)\n\t\trr = np.sqrt(rat2*Robs)\n\t\tt1 = np.sin(phi)*rr\n\t\tt2 = np.cos(phi)*rr\n\n\t\thglt = np.arcsin(t2)\n\t\thgln = np.arctan2(x, t1)\n\n\n\n\n\t\t# Only add the instance attribute if it doesn't exist.\n\t\tif isinstance(args[0], np.ndarray) and not hasattr(self, 'lonh'):\n\t\t\tself.lonh = np.rad2deg(hgln)\n\t\t\tself.lath = np.rad2deg(hglt)\n\n\t\treturn np.rad2deg(hgln), np.rad2deg(hglt)","def calculate_points(self, component):\n # find selection range on source plot\n x_start, x_end = self._get_selection_screencoords()\n if x_start > x_end:\n x_start, x_end = x_end, x_start\n\n y_end = self.source.y\n y_start = self.source.y2\n\n left_top = np.array([x_start, y_end])\n left_mid = np.array([x_start, y_start])\n right_top = np.array([x_end, y_end])\n right_mid = np.array([x_end, y_start])\n\n # Offset y because we want to avoid overlapping the trapezoid with the topmost\n # pixels of the destination plot.\n y = self.destination.y - 1\n\n left_end = np.array([self.destination.x, y])\n right_end = np.array([self.destination.x2, y])\n\n polygon = np.array((left_end, left_mid, left_top,\n right_top, right_mid, right_end))\n left_line = np.array((left_top, left_mid, left_end))\n right_line = np.array((right_end, right_mid, right_top))\n\n return left_line, right_line, polygon","def calculate_points(self, component):\n # find selection range on source plot\n x_start, x_end = self._get_selection_screencoords()\n if x_start > x_end:\n x_start, x_end = x_end, x_start\n\n y_end = self.source.y\n y_start = self.source.y2\n\n left_top = np.array([x_start, y_start])\n left_mid = np.array([x_start, y_end])\n right_top = np.array([x_end, y_start])\n right_mid = np.array([x_end, y_end])\n\n # Offset y because we want to avoid overlapping the trapezoid with the topmost\n # pixels of the destination plot.\n y = self.destination.y2 + 1\n\n left_end = np.array([self.destination.x, y])\n right_end = np.array([self.destination.x2, y])\n\n polygon = np.array((left_top, left_mid, left_end,\n right_end, right_mid, right_top))\n left_line = np.array((left_top, left_mid, left_end))\n right_line = np.array((right_end, right_mid, right_top))\n\n return left_line, right_line, polygon","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img)\n\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n\n #filling pixels inside the polygon defined by \"vertices\" with the fill color\n cv2.fillPoly(mask, vertices, ignore_mask_color)\n\n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img)\n\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n\n #filling pixels inside the polygon defined by \"vertices\" with the fill color\n cv2.fillPoly(mask, vertices, ignore_mask_color)\n\n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img)\n\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n\n #filling pixels inside the polygon defined by \"vertices\" with the fill color\n cv2.fillPoly(mask, vertices, ignore_mask_color)\n\n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def region_of_interest(img, vertices):\n #defining a blank mask to start with\n mask = np.zeros_like(img)\n\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n\n #filling pixels inside the polygon defined by \"vertices\" with the fill color\n cv2.fillPoly(mask, vertices, ignore_mask_color)\n\n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def generatePolygons(self, *args, **kwargs): \n return 'var PloneMapPolygons = [' + \\\n ''.join([\"{ 'id': '%s', 'path' : %s,'title':'%s'},\" % (object.id, object.polygon, object.Title()) \n for object in self.context.objectValues() \n if hasattr(object, 'polygon') and len(object.polygon) > 0 ])[:-1] \\\n + '];'","def get_corner(image, side):\n if side not in [\"tl\", \"tr\", \"bl\", \"br\"]:\n return 1, None\n size = (image.shape[0]) // 2, (image.shape[1]) // 2\n if side == \"tl\":\n return 0, image[size[0] :, -size[1] :]\n if side == \"tr\":\n return 0, image[size[0] :, : size[1]]\n if side == \"bl\":\n return 0, image[: -size[0], : size[1]]\n if side == \"br\":\n return 0, image[: -size[0], -size[1] :]","def get_bounding_rect(polygon):\n x1, y1, x2, y2 = float('inf'), float('inf'), float('-inf'), float('-inf')\n for x, y in polygon:\n if x < x1:\n x1 = x\n if y < y1:\n y1 = y\n if x > x2:\n x2 = x\n if y > y2:\n y2 = y\n return x1, y1, x2, y2","def region_of_interest(img, vertices):\n \n # defining a blank mask to start with\n mask = np.zeros_like(img) \n \n # defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n # filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n # returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n \n return masked_image","def create_geofence(self):\n\t\tring = ogr.Geometry(ogr.wkbLinearRing)\n\t\tring.AddPoint(*self.north_coords)\n\t\tring.AddPoint(*self.northeast_coords)\n\t\tring.AddPoint(*self.east_coords)\n\t\tring.AddPoint(*self.southeast_coords)\n\t\tring.AddPoint(*self.south_coords)\n\t\tring.AddPoint(*self.southwest_coords)\n\t\tring.AddPoint(*self.west_coords)\n\t\tring.AddPoint(*self.northwest_coords)\n\t\tring.AddPoint(*self.north_coords)\n\t\tself.polygon.AddGeometry(ring)","def flattener(image, pts, w, h):\n temp_rect = np.zeros((4,2), dtype = \"float32\")\n \n s = np.sum(pts, axis = 2)\n\n tl = pts[np.argmin(s)]\n br = pts[np.argmax(s)]\n\n diff = np.diff(pts, axis = -1)\n tr = pts[np.argmin(diff)]\n bl = pts[np.argmax(diff)]\n\n if w <= 0.8 * h: # If card is vertically oriented\n temp_rect[0] = tl\n temp_rect[1] = tr\n temp_rect[2] = br\n temp_rect[3] = bl\n\n if w >= 1.2 * h: # If card is horizontally oriented\n temp_rect[0] = bl\n temp_rect[1] = tl\n temp_rect[2] = tr\n temp_rect[3] = br\n\n if w > 0.8 * h and w < 1.2 * h: #If card is diamond oriented\n # If furthest left point is higher than furthest right point,\n # card is tilted to the left.\n if pts[1][0][1] <= pts[3][0][1]:\n # If card is titled to the left, approxPolyDP returns points\n # in this order: top right, top left, bottom left, bottom right\n temp_rect[0] = pts[1][0] # Top left\n temp_rect[1] = pts[0][0] # Top right\n temp_rect[2] = pts[3][0] # Bottom right\n temp_rect[3] = pts[2][0] # Bottom left\n\n # If furthest left point is lower than furthest right point,\n # card is tilted to the right\n if pts[1][0][1] > pts[3][0][1]:\n # If card is titled to the right, approxPolyDP returns points\n # in this order: top left, bottom left, bottom right, top right\n temp_rect[0] = pts[0][0] # Top left\n temp_rect[1] = pts[3][0] # Top right\n temp_rect[2] = pts[2][0] # Bottom right\n temp_rect[3] = pts[1][0] # Bottom left\n \n # Create destination array, calculate perspective transform matrix,\n # and warp card image\n dst = np.array([[0, 0], [MAXWIDTH - 1, 0], [MAXWIDTH - 1, MAXHEIGHT - 1], [0, MAXHEIGHT - 1]], np.float32)\n M = cv2.getPerspectiveTransform(temp_rect, dst)\n warp = cv2.warpPerspective(image, M, (MAXWIDTH, MAXHEIGHT))\n\n return warp","def draw_boxes(image, bounds, color):\n draw = ImageDraw.Draw(image)\n\n for bound in bounds:\n draw.polygon([\n bound.vertices[0].x, bound.vertices[0].y,\n bound.vertices[1].x, bound.vertices[1].y,\n bound.vertices[2].x, bound.vertices[2].y,\n bound.vertices[3].x, bound.vertices[3].y], None, color)\n # font = ImageFont.truetype(\"sans-serif.ttf\", 10)\n draw.text((bound.vertices[0].x, bound.vertices[0].y,),bound,(255,255,255),font=font)\n return image","def region_of_interest(img, vertices, debug = False):\n #defining a blank mask to start with\n mask = np.zeros_like(img) \n \n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n \n #filling pixels inside the polygon defined by \"vertices\" with the fill color \n cv2.fillPoly(mask, vertices, ignore_mask_color)\n \n #returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def getCoordinates(p):\n if p[0] == 'p': # minimum bounding rectangle for point\n return (int(p[1]), int(p[2]), int(p[1]), int(p[2]))\n elif p[0] == 'c': # minimum bounding rectangle for circle\n x = int(p[1])\n y = int(p[2])\n r = int(p[3])\n return (x - r, y - r, x + r, y + r)\n elif p[0] == 'l': # minimum bounding rectangle for line segment\n x1 = int(p[1])\n y1 = int(p[2])\n x2 = int(p[3])\n y2 = int(p[4])\n if y2 > y1:\n if x1 < x2:\n return (x1, y1, x2, y2)\n else:\n return (x2, y1, x1, y2)\n else:\n if x1 < x2:\n return (x1, y2, x2, y1)\n else:\n return (x2, y2, x1, y1)","def extent(self):\n left = self.transform[0]\n right = left + self.transform[1] * self.shape[1]\n top = self.transform[3]\n bottom = top + self.transform[5] * self.shape[0]\n return left, right, bottom, top","def makeup_polygons(\n draw: ImageDraw,\n num_cells: int,\n width: int,\n height: int,\n rgb_im: Image,\n random: bool,\n):\n voronoi, points = generate_voronoi_diagram(num_cells, width, height)\n for point, index in zip(points, voronoi.point_region):\n # Getting the region of the given point\n region = voronoi.regions[index]\n # Getting the points in arrays\n polygon = list()\n for i in region:\n # If vector is out of plot do not add\n if i != -1:\n polygon.append(voronoi.vertices[i])\n # Make tuples of the points\n polygon_tuples = list()\n for l in polygon:\n polygon_tuples.append(tuple(l))\n rgb = (0, 0, 0)\n if random:\n # Get random color\n rgb = random_color()\n else:\n # Get colors of the middle point\n rgb = get_color_of_point(point, rgb_im, width, height)\n # Draw the calculated polygon with the color of the middle point\n if polygon and polygon_tuples:\n draw.polygon(polygon_tuples, rgb)","def fill_polygon(points, im_shape):\n im_cnt = np.zeros((im_shape[0],im_shape[1],1), np.uint8)\n cv.fillPoly(im_cnt, [points], (255,255))\n\n return im_cnt","def calculate(self, image: Image, **kwargs) -> PointList:\n if image.mode != \"RGBA\":\n raise ValueError(\"Image mode is not RGBA. image.convert('RGBA') is needed.\")\n\n # Convert the image into one channel alpha since we don't care about RGB values\n image = image.getchannel(\"A\")\n bbox = image.getbbox()\n # If there is no bounding box the image is empty\n if bbox is None:\n return tuple()\n\n left_border, top_border, right_border, bottom_border = bbox\n right_border -= 1\n bottom_border -= 1\n\n def _check_corner_offset(start_x: int, start_y: int, x_direction: int, y_direction: int) -> int:\n bad = False\n offset = 0\n while not bad:\n y = start_y + (offset * y_direction)\n x = start_x\n for _ in range(offset + 1):\n alpha = image.getpixel((x, y))\n # print(f\"({x}, {y}) = {my_pixel} | \", end=\"\")\n if alpha != 0:\n bad = True\n break\n y -= y_direction\n x += x_direction\n # print(f\" - {bad}\")\n if not bad:\n offset += 1\n # print(f\"offset: {offset}\")\n return offset\n\n def _r(point: Tuple[float, float], height: int, width: int) -> Point:\n return point[0] - width / 2, (height - point[1]) - height / 2\n\n top_left_corner_offset = _check_corner_offset(left_border, top_border, 1, 1)\n top_right_corner_offset = _check_corner_offset(right_border, top_border, -1, 1)\n bottom_left_corner_offset = _check_corner_offset(left_border, bottom_border, 1, -1)\n bottom_right_corner_offset = _check_corner_offset(right_border, bottom_border, -1, -1)\n\n p1 = left_border + top_left_corner_offset, top_border\n p2 = (right_border + 1) - top_right_corner_offset, top_border\n p3 = (right_border + 1), top_border + top_right_corner_offset\n p4 = (right_border + 1), (bottom_border + 1) - bottom_right_corner_offset\n p5 = (right_border + 1) - bottom_right_corner_offset, (bottom_border + 1)\n p6 = left_border + bottom_left_corner_offset, (bottom_border + 1)\n p7 = left_border, (bottom_border + 1) - bottom_left_corner_offset\n p8 = left_border, top_border + top_left_corner_offset\n\n result = []\n\n h = image.height\n w = image.width\n\n result.append(_r(p7, h, w))\n if bottom_left_corner_offset:\n result.append(_r(p6, h, w))\n\n result.append(_r(p5, h, w))\n if bottom_right_corner_offset:\n result.append(_r(p4, h, w))\n\n result.append(_r(p3, h, w))\n if top_right_corner_offset:\n result.append(_r(p2, h, w))\n\n result.append(_r(p1, h, w))\n if top_left_corner_offset:\n result.append(_r(p8, h, w))\n\n # Remove duplicates\n return tuple(dict.fromkeys(result)) # type: ignore","def save_groudtruth(im, coords, filename):\n print 'Saving ground truth ......{0}'.format(filename)\n img_draw = Image.fromarray(cv2.cvtColor(im, cv2.COLOR_BGR2RGB))\n draw = ImageDraw.Draw(img_draw)\n for coord in coords:\n draw.polygon([(float(coord[0]), float(coord[1])), (float(coord[2]), float(coord[3])),\n (float(coord[4]), float(coord[5])), (float(coord[6]), float(coord[7]))],\n outline=\"red\", fill=\"blue\")\n img_draw = np.array(img_draw)\n img_draw = cv2.cvtColor(img_draw, cv2.COLOR_RGB2BGR)\n bname_excludepoint = filename.split('/')[-1].split('.')[0]\n image_path = '/home/yuquanjie/Documents/deep-direct-regression/result/' + bname_excludepoint + '_gt.jpg'\n cv2.imwrite(image_path, img_draw[0: img_draw.shape[0], 0: img_draw.shape[1]])","def edges(i):\n Oxy = i.copy()\n Kx = [-1, 0, 1, -2, 0, 2, -1, 0, 1]\n Ky = [-1, -2, -1, 0, 0, 0, 1, 2, 1]\n\n Ox = correlate(i, Kx)\n Oy = correlate(i,Ky)\n\n Oxy[\"pixels\"] = [ (x**2 + y**2)**(1/2) for x, y in zip(Ox[\"pixels\"], Oy[\"pixels\"])]\n\n result = round_and_clip_image(Oxy)\n return result","def get_coords_2d(obj, P):\n bbox3 = get_coords_3d(obj)\n # Rl = obj.Rl\n # height = obj.height\n # width = obj.width\n # length = obj.length\n # x = obj.x\n # y = obj.y\n # z = obj.z\n # bbox = np.array([[-length, 0, -width],\n # [-length, 0, width],\n # [ length, 0, width],\n # [ length, 0, -width],\n # [-length, -2*height, -width],\n # [-length, -2*height, width],\n # [ length, -2*height, width],\n # [ length, -2*height, -width]])/2\n # if abs(z) < 1e-6: z = np.sign(z) * 1e-6\n # M = rotationM([0, 1, 0], Rl + math.atan(x/z))\n # bbox = np.transpose(np.dot(M, np.transpose(bbox)))\n # bbox3 = bbox + np.array([x, y, z])\n bbox2 = project_pts3_to_image(bbox3, P)\n return bbox2","def image(self):\n if self.roi and len(self.roi) == 4:\n return self.calibrated_image[self.roi[0]:self.roi[1],self.roi[2]:self.roi[3]]\n else:\n return self.calibrated_image","def extent_as_polygon(self, crs=wgs84):\n from shapely.geometry import Polygon\n\n # this is not so trivial\n # for optimisation we will transform the boundaries only\n _i = np.hstack([np.arange(self.nx+1),\n np.ones(self.ny+1)*self.nx,\n np.arange(self.nx+1)[::-1],\n np.zeros(self.ny+1)]).flatten()\n _j = np.hstack([np.zeros(self.nx+1),\n np.arange(self.ny+1),\n np.ones(self.nx+1)*self.ny,\n np.arange(self.ny+1)[::-1]]).flatten()\n _i, _j = self.corner_grid.ij_to_crs(_i, _j, crs=crs)\n return Polygon(zip(_i, _j))","def extent(self):\n if self.x is not None:\n if self.y is not None:\n if self.z is not None:\n return (self.x.min(), self.x.max(),\n self.y.min(), self.y.max(),\n self.z.min(), self.z.max())\n return (self.x.min(), self.x.max(),\n self.y.min(), self.y.max())\n return (self.x.min(), self.x.max())\n\n elif self.r is not None and self.t is not None:\n if self.z is not None:\n return (self.z.min(), self.z.max(),\n self.r.min(), self.r.max(),\n self.t.min(), self.t.max())\n return (self.r.min(), self.r.max(),\n self.t.min(), self.t.max())\n\n return ()","def _rasterize_polygons(polygons, bounds = [[-100, -100], [100, 100]],\n dx = 1, dy = 1):\n try:\n from skimage import draw\n except:\n raise ImportError('The fill function requires the module '\n '\"scikit-image\" to operate. Please retry '\n 'after installing scikit-image:\\n\\n'\n '$ pip install --upgrade scikit-image')\n\n # Prepare polygon array by shifting all points into the first quadrant and\n # separating points into x and y lists\n xpts = []\n ypts = []\n for p in polygons:\n p_array = np.asarray(p)\n x = p_array[:, 0]\n y = p_array[:, 1]\n xpts.append((x-bounds[0][0])/dx - 0.5)\n ypts.append((y-bounds[0][1])/dy - 0.5)\n\n # Initialize the raster matrix we'll be writing to\n xsize = int(np.ceil((bounds[1][0]-bounds[0][0]))/dx)\n ysize = int(np.ceil((bounds[1][1]-bounds[0][1]))/dy)\n raster = np.zeros((ysize, xsize), dtype = np.bool)\n\n # TODO: Replace polygon_perimeter with the supercover version\n for n in range(len(xpts)):\n rr, cc = draw.polygon(ypts[n], xpts[n], shape = raster.shape)\n rrp, ccp = draw.polygon_perimeter(ypts[n], xpts[n],\n shape = raster.shape, clip = False)\n raster[rr, cc] = 1\n raster[rrp, ccp] = 1\n\n return raster","def region_of_interest(img, vertices):\n\n # defining a blank mask to start with\n mask = np.zeros_like(img)\n\n # defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n\n # filling pixels inside the polygon defined by \"vertices\" with the fill color\n cv2.fillPoly(mask, vertices, ignore_mask_color)\n\n # returning the image only where mask pixels are nonzero\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def pixelcode(self):\n\n maxX, maxY = self.size()\n result = bitmap((2*maxX, 2*maxY))\n for x in range(maxX):\n for y in range(maxY):\n pixel = self.get(x,y)\n result.set(2*x,2*y, pixel)\n result.set(2*x,2*y+1, not pixel)\n result.set(2*x+1,2*y, not pixel)\n result.set(2*x+1,2*y+1, pixel)\n return result"],"string":"[\n \"def draw_image(self):\\n dir_ship = self.direction\\n dir_cannon=self.cannon_dir\\n temp_image = self.base_image.copy()\\n pygame.draw.polygon(temp_image, (0,0,0), [(2,2),(2,3),(3,3),(3,2)])\\n if dir_cannon == dir_ship:\\n pygame.draw.polygon(temp_image, (60,60,60), [(4,3),(4,2), (5,3),(5,2)])\\n if (dir_ship - dir_cannon)%4 ==1:#-90° angle\\n pygame.draw.polygon(temp_image, (60,60,60), [(2,4),(3,4), (2,5),(3,5)])\\n if (dir_ship - dir_cannon)%4 ==3:#+90° angle\\n pygame.draw.polygon(temp_image, (60,60,60), [(2,1),(3,1), (2,0),(3,0)])\\n if (dir_ship - dir_cannon)%4 ==2:#180° angle\\n pygame.draw.polygon(temp_image, (60,60,60), [(1,2),(1,3), (0,2),(0,3)])\\n temp_image=pygame.transform.rotate(temp_image,dir_ship*90)\\n return temp_image\",\n \"def generatePolygons():\",\n \"def get_boundary_as_polygon(self, do_geo=True):\\n xhor, yhor = self.get_coordinates()\\n dimensions = xhor.shape\\n xbottom = xhor[0, :]\\n xright = xhor[:, dimensions[1]-1]\\n xtop = xhor[dimensions[0]-1, :][::-1]\\n xleft = xhor[:, 0][::-1]\\n\\n ybottom = yhor[0, :]\\n yright = yhor[:, dimensions[1]-1]\\n ytop = yhor[dimensions[0]-1, :][::-1]\\n yleft = yhor[:, 0][::-1]\\n\\n lon_square = np.concatenate((xbottom, xright, xtop, xleft))\\n lat_square = np.concatenate((ybottom, yright, ytop, yleft))\\n\\n return lon_square, lat_square\",\n \"def geotif_image(self, tile_bounds, image_bounds, imagepath,image_gdal):\\n i_srid=3857\\n s_srid=\\\"WGS 84 / Pseudo-Mercator\\\"\\n # i_srid=3395\\n # s_srid=\\\"WGS 84 / World Mercator\\\"\\n # 4326 Wsg84\\n # Upper Left ( -8.4375000, 77.1571625) ( 8d26'15.00\\\"W, 77d 9'25.79\\\"N)\\n # Lower Left ( -8.4375000, 35.4606700) ( 8d26'15.00\\\"W, 35d27'38.41\\\"N)\\n # Upper Right ( 80.1562500, 77.1571625) ( 80d 9'22.50\\\"E, 77d 9'25.79\\\"N)\\n # Lower Right ( 80.1562500, 35.4606700) ( 80d 9'22.50\\\"E, 35d27'38.41\\\"N)\\n # Center ( 35.8593750, 56.3089162) ( 35d51'33.75\\\"E, 56d18'32.10\\\"N)\\n # 3857 'WGS 84 / Pseudo-Mercator'\\n # Upper Left ( -939258.204,13932330.020) ( 8d26'15.00\\\"W, 77d 9'25.79\\\"N)\\n # Lower Left ( -939258.204, 4226661.916) ( 8d26'15.00\\\"W, 35d27'38.41\\\"N)\\n # Upper Right ( 8922952.934,13932330.020) ( 80d 9'22.50\\\"E, 77d 9'25.79\\\"N)\\n # Lower Right ( 8922952.934, 4226661.916) ( 80d 9'22.50\\\"E, 35d27'38.41\\\"N)\\n # Center ( 3991847.365, 9079495.968) ( 35d51'33.75\\\"E, 62d54'54.84\\\"N)\\n # 3395 'WGS 84 / World Mercator'\\n # Upper Left ( -939258.204,13932330.020) ( 8d26'15.00\\\"W, 77d14'24.81\\\"N)\\n # Lower Left ( -939258.204, 4226661.916) ( 8d26'15.00\\\"W, 35d38'33.56\\\"N)\\n # Upper Right ( 8922952.934,13932330.020) ( 80d 9'22.50\\\"E, 77d14'24.81\\\"N)\\n # Lower Right ( 8922952.934, 4226661.916) ( 80d 9'22.50\\\"E, 35d38'33.56\\\"N)\\n # Center ( 3991847.365, 9079495.968) ( 35d51'33.75\\\"E, 63d 4'14.87\\\"N)\\n bounds_west,bounds_south,bounds_east,bounds_north=tile_bounds\\n bounds_wsg84=\\\"bounds_wsg84: %f,%f,%f,%f\\\"% (bounds_west,bounds_south,bounds_east,bounds_north)\\n mercator = GlobalMercator()\\n tile_bounds=mercator.BoundsToMeters(tile_bounds)\\n mbtiles_name=\\\"\\\";\\n mbtiles_description=\\\"\\\"\\n s_TIFFTAG_DOCUMENTNAME=\\\"\\\"\\n s_TIFFTAG_IMAGEDESCRIPTION=\\\"\\\"\\n s_TIFFTAG_SOFTWARE=\\\"\\\"\\n s_TIFFTAG_DATETIME=\\\"\\\"\\n s_TIFFTAG_ARTIST=\\\"\\\"\\n s_TIFFTAG_HOSTCOMPUTER=\\\"\\\"\\n s_TIFFTAG_COPYRIGHT=\\\"\\\"\\n if self.metadata_input:\\n metadata=dict(self.metadata_input)\\n mbtiles_name=metadata.get('name','')\\n mbtiles_description=metadata.get('description','')\\n if self._metadata:\\n for metadata_list in self._metadata:\\n metadata=dict(metadata_list[0])\\n mbtiles_name=metadata.get('name',mbtiles_name)\\n mbtiles_description=metadata.get('description',mbtiles_description)\\n s_TIFFTAG_DOCUMENTNAME=metadata.get('TIFFTAG_DOCUMENTNAME',mbtiles_name)\\n s_TIFFTAG_IMAGEDESCRIPTION=metadata.get('TIFFTAG_IMAGEDESCRIPTION',mbtiles_description)\\n s_TIFFTAG_SOFTWARE=metadata.get('TIFFTAG_SOFTWARE','')\\n s_TIFFTAG_DATETIME=metadata.get('TIFFTAG_DATETIME','')\\n s_TIFFTAG_ARTIST=metadata.get('TIFFTAG_ARTIST','')\\n s_TIFFTAG_HOSTCOMPUTER=metadata.get('TIFFTAG_HOSTCOMPUTER','')\\n s_TIFFTAG_COPYRIGHT=metadata.get('TIFFTAG_COPYRIGHT','')\\n if s_TIFFTAG_DOCUMENTNAME == \\\"\\\":\\n s_TIFFTAG_DOCUMENTNAME=mbtiles_name\\n if s_TIFFTAG_IMAGEDESCRIPTION == \\\"\\\":\\n s_TIFFTAG_IMAGEDESCRIPTION=mbtiles_description\\n tiff_metadata=[]\\n if s_TIFFTAG_DOCUMENTNAME != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_DOCUMENTNAME',s_TIFFTAG_DOCUMENTNAME))\\n if s_TIFFTAG_IMAGEDESCRIPTION != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_IMAGEDESCRIPTION',s_TIFFTAG_IMAGEDESCRIPTION))\\n if s_TIFFTAG_SOFTWARE != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_SOFTWARE',s_TIFFTAG_SOFTWARE))\\n else:\\n tiff_metadata.append(('TIFFTAG_SOFTWARE',bounds_wsg84))\\n if s_TIFFTAG_DATETIME != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_DATETIME',s_TIFFTAG_DATETIME))\\n if s_TIFFTAG_ARTIST != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_ARTIST',s_TIFFTAG_ARTIST))\\n if s_TIFFTAG_HOSTCOMPUTER != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_HOSTCOMPUTER',s_TIFFTAG_HOSTCOMPUTER))\\n if s_TIFFTAG_COPYRIGHT != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_COPYRIGHT',s_TIFFTAG_COPYRIGHT))\\n # this assumes the projection is Geographic lat/lon WGS 84\\n xmin,ymin,xmax,ymax=tile_bounds\\n image_width,image_height=image_bounds\\n # Upper Left ( 20800.000, 22000.000)\\n # Lower Right ( 24000.000, 19600.000)\\n # Size is 15118, 11339\\n # (24000-20800)/15118 = 3200 = 0,21166821 [xres]\\n # (19600-22000)/11339 = 2400 = −0,211658876 [yres]\\n # geo_transform = (20800.0, 0.2116682100807, 0.0, 22000.0, 0.0, -0.21165887644413)\\n geo_transform = [xmin, (xmax-xmin)/image_width, 0, ymax, 0, (ymin-ymax)/image_height ]\\n spatial_projection = osr.SpatialReference()\\n spatial_projection.ImportFromEPSG(i_srid)\\n logger.info(_(\\\"-I-> geotif_image: Saving as GeoTiff - image[%s] compression[%s]\\\") % (imagepath,self.tiff_compression))\\n image_dataset = gdal.Open(image_gdal, gdal.GA_Update )\\n image_dataset.SetProjection(spatial_projection.ExportToWkt())\\n image_dataset.SetGeoTransform(geo_transform)\\n driver = gdal.GetDriverByName(\\\"GTiff\\\")\\n output_dataset = driver.CreateCopy(imagepath,image_dataset, 0, self.tiff_compression )\\n if tiff_metadata:\\n logger.info(_(\\\"-I-> geotif_image: tiff_metadata[%s]\\\") % tiff_metadata)\\n output_dataset.SetMetadata(dict(tiff_metadata))\\n # Once we're done, close properly the dataset\\n output_dataset = None\\n image_dataset = None\\n os.remove(image_gdal)\\n logger.info(_(\\\"-I-> geotif_image: Saved resulting image to '%s' as GeoTiff- bounds[%s]\\\") % (imagepath,tile_bounds))\",\n \"def boundary_polygon(self):\\n try:\\n return self.boundary_polygon_by_edges()\\n except Exception as exc:\\n self.log.warning('Warning, boundary_polygon() failed using edges! Trying polygon union method')\\n self.log.warning(exc,exc_info=True)\\n return self.boundary_polygon_by_union()\",\n \"def Hexagon(image):\\n return x, y\",\n \"def generate_image(self):\\n\\t\\tcenters = self.generate_centers()\\n\\t\\timg = Image.new('RGB', (self.config.image_size, self.config.image_size), color=(0,0,0))\\n\\t\\tshapes = np.random.randint(2, size=len(centers))\\n\\t\\tdrawer = ImageDraw.Draw(img)\\n\\t\\tr = int(0.05 * self.config.image_size)\\n\\t\\tR = []\\n\\t\\tfor i in range(len(centers)):\\n\\t\\t\\tcoor = (centers[i][0] - r , centers[i][1] - r, centers[i][0] + r, centers[i][1] + r)\\n\\t\\t\\tif shapes[i] < 0.5:\\n\\t\\t\\t\\tdrawer.rectangle(coor, fill=COLOR[i])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdrawer.ellipse(coor, fill=COLOR[i])\\n\\t\\t\\tR.append([centers[i], i, shapes[i]])\\n\\t\\treturn np.array(img), R\",\n \"def boundary_polygon_by_edges(self):\\n lines=self.boundary_linestrings()\\n polys=join_features.lines_to_polygons(lines,close_arc=False)\\n if len(polys)>1:\\n raise GridException(\\\"somehow there are multiple boundary polygons\\\")\\n return polys[0]\",\n \"def get_polygons(annotation):\\n print(f\\\"Loadding: {annotation}\\\")\\n tree = ET.parse(annotation)\\n root = tree.getroot()\\n polygons = {}\\n for obj in root.findall('object'):\\n name = obj.find('name').text\\n id_ = obj.find('id').text\\n polygon = []\\n for pt in obj.find('polygon').findall('pt'):\\n polygon.append([pt.find('x').text, pt.find('y').text])\\n if name in polygons:\\n x_ref= int(polygons[name]['left'][0][0])\\n x = int(polygon[0][0])\\n if x > x_ref:\\n polygons[name]['right'] = polygons[name]['left']\\n id_ = 'left'\\n else:\\n id_ = 'right'\\n else:\\n polygons[name] = {}\\n id_ = 'left'\\n polygons[name][id_] = polygon\\n for i in list(polygons.keys()):\\n if not('right' in polygons[i]):\\n print(i,' only has one polygon: ',polygons[i]['left'])\\n y = input('Do you wish to label it as \\\\'right\\\\'? (leave empy if No): ')\\n if (y):\\n polygons[i]['right'] = polygons[i]['left']\\n polygons[i].pop('left')\\n return polygons\",\n \"def get_zone_pixels(feat, input_zone_polygon, input_value_raster, band, coords=[]): #, raster_band\\n \\n \\n \\n # Open data\\n raster = gdal.Open(input_value_raster)\\n shp = ogr.Open(input_zone_polygon)\\n lyr = shp.GetLayer()\\n \\n # Get raster georeference info\\n transform = raster.GetGeoTransform()\\n xOrigin = transform[0]\\n yOrigin = transform[3]\\n pixelWidth = transform[1]\\n pixelHeight = transform[5]\\n \\n sizeX = raster.RasterXSize\\n sizeY = raster.RasterYSize\\n lrx = xOrigin + (sizeX * pixelWidth)\\n lry = yOrigin + (sizeY * pixelHeight)\\n \\n \\n \\n # Reproject vector geometry to same projection as raster\\n #sourceSR = lyr.GetSpatialRef()\\n #targetSR = osr.SpatialReference()\\n #targetSR.ImportFromWkt(raster.GetProjectionRef())\\n #coordTrans = osr.CoordinateTransformation(sourceSR,targetSR)\\n #feat = lyr.GetNextFeature()\\n #geom = feat.GetGeometryRef()\\n #geom.Transform(coordTrans)\\n \\n # Get extent of feat\\n geom = feat.GetGeometryRef()\\n if (geom.GetGeometryName() == 'MULTIPOLYGON'):\\n count = 0\\n pointsX = []; pointsY = []\\n for polygon in geom:\\n geomInner = geom.GetGeometryRef(count)\\n ring = geomInner.GetGeometryRef(0)\\n numpoints = ring.GetPointCount()\\n for p in range(numpoints):\\n lon, lat, z = ring.GetPoint(p)\\n pointsX.append(lon)\\n pointsY.append(lat)\\n count += 1\\n elif (geom.GetGeometryName() == 'POLYGON'):\\n ring = geom.GetGeometryRef(0)\\n numpoints = ring.GetPointCount()\\n pointsX = []; pointsY = []\\n for p in range(numpoints):\\n lon, lat, z = ring.GetPoint(p)\\n pointsX.append(lon)\\n pointsY.append(lat)\\n\\n else:\\n sys.exit(\\\"ERROR: Geometry needs to be either Polygon or Multipolygon\\\")\\n\\n #xmin = min(pointsX) \\n #xmax = max(pointsX)\\n #ymin = min(pointsY)\\n #ymax = max(pointsY)\\n \\n \\n if len(coords) == 0: \\n xmin = xOrigin if (min(pointsX) < xOrigin) else min(pointsX)\\n xmax = lrx if (max(pointsX) > lrx) else max(pointsX)\\n ymin = lry if (min(pointsY) < lry) else min(pointsY)\\n ymax = yOrigin if (max(pointsY) > yOrigin) else max(pointsY)\\n else:\\n xmin = coords[0] if (min(pointsX) < coords[0]) else min(pointsX)\\n xmax = coords[1] if (max(pointsX) > coords[1]) else max(pointsX)\\n ymin = coords[2] if (min(pointsY) < coords[2]) else min(pointsY)\\n ymax = coords[3] if (max(pointsY) > coords[3]) else max(pointsY)\\n \\n # Specify offset and rows and columns to read\\n xoff = int((xmin - xOrigin)/pixelWidth)\\n yoff = int((yOrigin - ymax)/pixelWidth)\\n xcount = int((xmax - xmin)/pixelWidth) #+1 !!!!!!!!!!!!!!!!!!!!! This adds a pixel to the right side\\n ycount = int((ymax - ymin)/pixelWidth) #+1 !!!!!!!!!!!!!!!!!!!!! This adds a pixel to the bottom side\\n \\n #print(xoff, yoff, xcount, ycount)\\n \\n # Create memory target raster\\n target_ds = gdal.GetDriverByName('MEM').Create('', xcount, ycount, 1, gdal.GDT_Byte)\\n target_ds.SetGeoTransform((\\n xmin, pixelWidth, 0,\\n ymax, 0, pixelHeight,\\n ))\\n\\n # Create for target raster the same projection as for the value raster\\n raster_srs = osr.SpatialReference()\\n raster_srs.ImportFromWkt(raster.GetProjectionRef())\\n target_ds.SetProjection(raster_srs.ExportToWkt())\\n\\n # Rasterize zone polygon to raster\\n gdal.RasterizeLayer(target_ds, [1], lyr, burn_values=[1])\\n\\n # Read raster as arrays\\n dataBandRaster = raster.GetRasterBand(band)\\n data = dataBandRaster.ReadAsArray(xoff, yoff, xcount, ycount).astype(np.float)\\n bandmask = target_ds.GetRasterBand(1)\\n datamask = bandmask.ReadAsArray(0, 0, xcount, ycount).astype(np.float)\\n\\n # data zone of raster\\n dataZone = np.ma.masked_array(data, np.logical_not(datamask))\\n\\n raster_srs = None\\n raster = None\\n shp = None\\n lyr = None\\n return [dataZone, [xmin,xmax,ymin,ymax]]\",\n \"def _createpoly(self):\\n return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill=\\\"\\\", outline=\\\"\\\")\",\n \"def fill_lane(self,img_shape):\\n\\n\\t\\tbinary_l = np.zeros(img_shape, dtype=np.uint8)\\n\\n\\t\\tploty = np.linspace(0, img_shape[0]-1, img_shape[0])\\n\\t\\tplotx_l = self.leftLine.fit[0]*ploty**2 + self.leftLine.fit[1]*ploty + self.leftLine.fit[2]\\n\\t\\tplotx_r = self.rightLine.fit[0]*ploty**2 + self.rightLine.fit[1]*ploty + self.rightLine.fit[2]\\n\\n\\t\\tline_points_l = np.column_stack((plotx_l,ploty))\\n\\t\\tline_points_r = np.column_stack((plotx_r,ploty))\\n\\t\\tline_points = np.concatenate((line_points_l,line_points_r[::-1],line_points_l[:1]))\\n\\n\\t\\tcv2.fillPoly(binary_l, np.int32([line_points]),color=255)\\n\\n\\t\\tpolygon = np.dstack((np.zeros(img_shape),binary_l,np.zeros(img_shape))).astype('uint8')\\n\\t\\t\\n\\t\\treturn polygon\\n\\t\\tunwarped_polygon = self.cam.unwarp(polygon)\\n\\t\\treturn unwarped_polygon\",\n \"def region_points(x, y, width, xmin, xmax):\\n right = (x, y + width / 2)\\n top = (xmax, y)\\n left = (x, y - width / 2)\\n bottom = (xmin, y)\\n return (right, top, left, bottom)\",\n \"def get_image(self):\\n image = Image.new('1', (8, 16))\\n draw = ImageDraw.Draw(image)\\n for x in xrange(8):\\n for y in xrange(16):\\n draw.point((x,y),self.get_pixel(x, y))\\n return image\",\n \"def __draw_polygon(self, event, klick):\\n global creating_polygon\\n curX = self.canvas.canvasx(event.x)\\n curY = self.canvas.canvasy(event.y)\\n if not klick and len(self.polygon_points) >= 2:\\n c_r_x, c_r_y = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\\n distanceX = curX - c_r_x\\n distanceY = curY - c_r_y\\n if pow(pow(distanceX, 2) + pow(distanceY, 2), 1 / 2) <= 15:\\n return\\n image_relative_x, image_relative_y = self.get_image_relative_coords((curX, curY))\\n self.polygon_points.extend((image_relative_x, image_relative_y))\\n self.polygon_groundstructure.append(self.canvas.create_rectangle(curX - 2, curY - 2, curX + 2, curY + 2,\\n outline='magenta', width=1,\\n activewidth=2))\\n if not creating_polygon: # start with a new polygon\\n creating_polygon = True\\n return\\n else: # draw a line between the last points\\n c_r_x1, c_r_y1 = self.get_canvas_relative_coords((self.polygon_points[-4], self.polygon_points[-3]))\\n c_r_x2, c_r_y2 = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\\n self.polygon_groundstructure.append(self.canvas.create_line([c_r_x1, c_r_y1, c_r_x2, c_r_y2],\\n fill='magenta', width=2))\",\n \"def draw_shape(self, image, shape, p, color):\\n # Get the center x, y and the size s\\n p = p['shape_attributes']\\n if shape == 'rect':\\n image = cv2.rectangle(\\n image, (p['x'], p['y']), (p['x'] + p['width'], p['y'] + p['height']), color, -1)\\n elif shape == \\\"circle\\\":\\n #image = cv2.circle(image, (p['cx'], p['cy']), np.int(p['r']), color, -1)\\n image = cv2.rectangle(image, (p['cx']-np.int32(p['r']/2.0), p['cy']-np.int32(\\n p['r']/2.0)), (p['cx'] + np.int32(p['r']), p['cy'] + np.int32(p['r'])), color, -1)\\n elif shape == \\\"point\\\":\\n #image = cv2.circle(image, (p['cx'], p['cy']), 15, color, -1)\\n image = cv2.rectangle(\\n image, (p['cx']-8, p['cy']-8), (p['cx']+16, p['cy']+16), color, -1)\\n elif shape == \\\"polygon\\\":\\n pts = np.zeros((len(p['all_points_x']), 2), np.int32)\\n for i in range(len(p['all_points_x'])):\\n pts[i] = [p['all_points_x'][i], p['all_points_y'][i]]\\n if (self.config.MODE == \\\"Combined\\\"):\\n pts = pts.reshape((-1, 1, 2))\\n elif (self.config.MODE == \\\"Separate\\\"):\\n pts = pts.reshape((1, -1, 2))\\n image = cv2.fillPoly(image, pts, color, lineType=cv2.LINE_AA)\\n\\n return image\",\n \"def _getshapepoly(self, polygon, compound=False):\\n if self._resizemode == \\\"user\\\" or compound:\\n t11, t12, t21, t22 = self._shapetrafo\\n elif self._resizemode == \\\"auto\\\":\\n l = max(1, self._pensize/5.0)\\n t11, t12, t21, t22 = l, 0, 0, l\\n elif self._resizemode == \\\"noresize\\\":\\n return polygon\\n return tuple((t11*x + t12*y, t21*x + t22*y) for (x, y) in polygon)\",\n \"def draw(self, binary, leftx, rightx):\\n\\t\\tfilled = np.zeros_like(binary)\\n\\t\\tploty = np.linspace(0, filled.shape[0] - 1, filled.shape[0])\\n\\t\\t# Recast the x and y points into usable format for cv2.fillpoly()\\n\\t\\tpts_left = np.array([np.transpose(np.vstack([leftx, ploty]))])\\n\\t\\tpts_right = np.array([np.flipud(np.transpose(np.vstack([rightx, ploty])))])\\n\\t\\tpts = np.hstack((pts_left, pts_right))\\n\\t\\t# Draw the lane onto the warped blank image\\n\\t\\tcv2.fillPoly(filled, np.int_([pts]), (0, 255, 0))\\n\\t\\treturn filled\",\n \"def bilinear(upperleft, upperright, lowerright, lowerleft, side = 'middle'):\\r\\n\\tx1, y1, x2, y2, x3, y3, x4, y4 = upperleft[0], upperleft[1], upperright[0], upperright[1], lowerright[0], lowerright[1], lowerleft[0], lowerleft[1]\\r\\n\\ty14 = (y1 + y4) / 2.\\r\\n\\ty23 = (y2 + y3) / 2.\\r\\n\\ty = (y14 + y23) / 2.\\r\\n\\tx12 = (x1 + x2) / 2.\\r\\n\\tx43 = (x4 + x3) / 2.\\r\\n\\tx = (x12 + x43) / 2.\\r\\n\\r\\n\\tif side == 'middle':\\r\\n\\t\\treturn (x, y)\\r\\n\\telif side == 'left':\\r\\n\\t\\treturn ((x1 + x4) / 2., y4)\\r\\n\\telif side == 'right':\\r\\n\\t\\treturn ((x2 + x3) / 2., y3)# get middle right coordinate\\r\\n\\telse:\\r\\n\\t\\traise Exception('No other sides!')\",\n \"def draw_boxes(image, bounds):\\n draw = ImageDraw.Draw(image)\\n if bounds[0].normalized_vertices:\\n width = image.width\\n height = image.height\\n for i in range(len(bounds)):\\n draw.polygon([\\n bounds[i].normalized_vertices[0].x * width, bounds[i].normalized_vertices[0].y * height,\\n bounds[i].normalized_vertices[1].x * width, bounds[i].normalized_vertices[1].y * height,\\n bounds[i].normalized_vertices[2].x * width, bounds[i].normalized_vertices[2].y * height,\\n bounds[i].normalized_vertices[3].x * width, bounds[i].normalized_vertices[3].y * height],\\n None, colors[i % len(colors)])\\n return image\\n else:\\n for i in range(len(bounds)):\\n draw.polygon([\\n bounds[i].vertices[0].x, bounds[i].vertices[0].y,\\n bounds[i].vertices[1].x, bounds[i].vertices[1].y,\\n bounds[i].vertices[2].x, bounds[i].vertices[2].y,\\n bounds[i].vertices[3].x, bounds[i].vertices[3].y],\\n None, colors[i % len(colors)])\\n return image\",\n \"def draw_obstacle(start, end, img):\\n # start, end, top_right, top_left = generate_obstacle_point(start, (start[0] + _OBSTACLE_SIZE, start[1] ))\\n cv2.fillPoly(img, np.array([[[start[0] - 25, start[1] - 25],\\n [start[0] + 25, start[1] - 25],\\n [start[0] + 25, start[1] + 25],\\n [start[0] - 25, start[1] + 25]]]), _RED)\\n # cv2.rectangle(img, (start[0] - 25, start[1] - 25), (start[0] + 25, start[1] + 25), (0, 255, 0), 3)\\n return img\",\n \"def polygon(self):\\n return self._polygon\",\n \"def _get_polygon(element):\\n polygon = element.find('%s/%s/%s/%s/%s' %\\n (NRML04_AREA_GEOMETRY, gml.GML_POLYGON,\\n gml.GML_EXTERIOR, gml.GML_LINEAR_RING,\\n gml.GML_POS_LIST)).text\\n\\n polygon = gml._get_polygon_from_2DLinestring(polygon)\\n\\n return polygon\",\n \"def rig_matte((height, width), vectors, dtype=np.float_):\\n img = Image.new('L', (width, height), 1)\\n ImageDraw.Draw(img).polygon(vectors, outline=0, fill=0)\\n return np.array(img, dtype=dtype)\",\n \"def to_shapely_polygon(self):\\n # load shapely lazily, which makes the dependency more optional\\n import shapely.geometry\\n return shapely.geometry.Polygon([(point[0], point[1]) for point in self.exterior])\",\n \"def shape(self):\\n return (self.xres, self.yres)\",\n \"def draw(self):\\n\\t\\tif self.image != None:\\n\\t\\t\\treturn\\n\\n\\t\\tself.image = Image.new(\\\"RGBA\\\", \\n\\t\\t\\t(self.__class__._width, self.__class__._height), (0,0,0,0))\\n\\t\\tdr = aggdraw.Draw(self.image)\\n\\n\\t\\tzIndexList = [] # list of z-indexes\\n\\t\\tgIndexList = [] # list of gene indexes\\n\\n\\t\\tgeneIdx = 0\\n\\t\\tfor gene in self.chromosome: \\n\\t\\t\\tzIndexList.append(gene[0])\\n\\t\\t\\tgIndexList.append(geneIdx)\\n\\t\\t\\tgeneIdx+=1\\n\\n\\t\\twhile len(zIndexList) > 0:\\n\\t\\t\\tzIndexMin = zIndexList.index(min(zIndexList))\\n\\t\\t\\tgeneIdx = gIndexList[zIndexMin]\\n\\t\\t\\tz = self.chromosome[geneIdx,0]\\n\\t\\t\\tcolor = self.chromosome[geneIdx,1]\\n\\t\\t\\tpoly = self.chromosome[geneIdx,2]\\n\\n\\t\\t\\tcol = color.getColor()\\n\\t\\t\\tcords = poly.getCords()\\n\\t\\t\\tbrush = aggdraw.Brush(col)\\n\\n\\t\\t\\t#dr.ellipse((x, y, x+rad, y+rad), None, brush)\\n\\t\\t\\tdr.polygon(cords, None, brush)\\n\\t\\t\\tdr.flush()\\n\\n\\t\\t\\tif 0: # Debug - draw dot in center of polygon\\n\\t\\t\\t\\tcenter = (poly.xAnchor, poly.yAnchor, poly.xAnchor+5, poly.yAnchor+5)\\n\\t\\t\\t\\tdr.ellipse(center, None, aggdraw.Brush((255,0,0,255)))\\n\\t\\t\\t\\tdr.flush()\\n\\n\\t\\t\\tzIndexList.pop(zIndexMin)\\n\\t\\t\\tgIndexList.pop(zIndexMin)\\n\\n\\t\\tself.image = self.image.convert(\\\"RGB\\\")\",\n \"def img_roi(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(self,img):\\r\\n #defining a blank mask\\r\\n mask = np.zeros_like(img) \\r\\n #checking number of image channel(color/grayscale) and applying mask\\r\\n if len(img.shape) > 2:\\r\\n ignore_mask_color = (255,255,255)\\r\\n else:\\r\\n ignore_mask_color = 255\\r\\n #filling color to pixels inside the polygon \\r\\n cv2.fillPoly(mask, self.vertices_img, ignore_mask_color)\\r\\n #image where mask pixels are nonzero\\r\\n masked_image = cv2.bitwise_and(img, mask)\\r\\n #cv2.imshow('',masked_image)\\r\\n return masked_image\",\n \"def get_polygon(img, gradx, grady, seed):\\n rays = get_rays(NRAY, RHO, RHO_SKIP)\\n # minCellSize = np.pi * MINCELLRADIUS**2\\n # maxCellSize = np.pi * MAXCELLRADIUS**2\\n assert 0<seed[0]<img.shape[0] and 0<seed[1]<img.shape[1]\\n (cr,cc) = seed # cr, cc is the coordinates of the seed\\n [ac, ar] = np.meshgrid(np.array(range(img.shape[0])), np.array(range(img.shape[1])))\\n cac = (ac-cc).astype(np.float32) # cac,car represent the distance of each pixel on the image to the seed\\n car = (ar-cr).astype(np.float32)\\n with np.errstate(all='ignore'):\\n unitx = np.cos(np.arctan(np.abs(car/cac))) * np.sign(cac) # unitx,unity represent cosine value of each pixel on the image to the seed\\n unity = np.cos(np.arctan(np.abs(cac/car))) * np.sign(car)\\n dirslopes = gradx * unitx + grady * unity # dirslopes is the gradient map which consider the seed points as the center\\n\\n tab = np.zeros((RHO - RHO_SKIP, NRAY))\\n gxtab = np.zeros((RHO - RHO_SKIP, NRAY))\\n gytab = np.zeros((RHO - RHO_SKIP, NRAY))\\n pixtab = np.zeros((RHO - RHO_SKIP, NRAY))\\n for i in range(NRAY):\\n for j in range(RHO-RHO_SKIP):\\n pr = int(cr + rays[i][j, 0])\\n pc = int(cc + rays[i][j, 1])\\n tab[j, i] = dirslopes[pr, pc]\\n gxtab[j, i] = gradx[pr, pc]\\n gytab[j, i] = grady[pr, pc]\\n pixtab[j, i] = img[pr, pc]\\n\\n minpath = findminpath(tab, gxtab, gytab, pixtab) # get the minpath\\n\\n polygon = np.zeros((NRAY, 2))\\n for i in range(NRAY):\\n polygon[i, 0] = cr + rays[i][minpath[i], 0]\\n polygon[i, 1] = cc + rays[i][minpath[i], 1]\\n #hull = ConvexHull(polygon)\\n #polygon = polygon[hull.vertices]\\n #print(polygon.shape[0])\\n return polygon\",\n \"def select_region(image):\\n # Define the polygon by vertices\\n rows, cols = image.shape[:2]\\n bottom_left = [cols*0.05, rows*0.95]\\n top_left = [cols*0.3, rows*0.55]\\n bottom_right = [cols*0.95, rows*0.95]\\n top_right = [cols*0.7, rows*0.55]\\n # Vertices are an array of polygons (i.e array of arrays) and the data type must be integer.\\n vertices = np.array([[bottom_left, top_left, top_right, bottom_right]], dtype=np.int32)\\n return filter_region(image, vertices)\",\n \"def createImgOverlay(sli, graph, drawing_params, notAnEmptySlice):\\n \\n (Y, X) = sli.shape\\n \\n # Creation of the superposition file (3 dimensions because RGB for the graph drawing)\\n sli_ovl = np.zeros([Y, X, 3], np.uint8)\\n sli_ovl[:, :, 0] = sli\\n sli_ovl[:, :, 1] = sli\\n sli_ovl[:, :, 2] = sli\\n \\n if notAnEmptySlice:\\n line = drawing_params[0]\\n line_color = drawing_params[1]\\n line_size = drawing_params[2]\\n apex_color = drawing_params[3]\\n apex_size = drawing_params[4]\\n node_color = drawing_params[5]\\n node_size = drawing_params[6]\\n body_color = drawing_params[7]\\n body_size = drawing_params[8]\\n \\n graph = nx.convert_node_labels_to_integers(graph, first_label=0, \\n ordering='default', \\n label_attribute=None)\\n \\n # Creation of arrays from graph elements \\n x_node = np.fromiter(nx.get_node_attributes(graph, 'x').values(), \\n dtype=int) \\n y_node = np.fromiter(nx.get_node_attributes(graph, 'y').values(), \\n dtype=int) \\n degrees = np.array([degree for node, degree in nx.degree(graph)], \\n dtype=int) \\n edges = np.array(graph.edges())\\n \\n # Lists of edges coordinates\\n x1 = x_node[edges[:, 0]]\\n y1 = y_node[edges[:, 0]]\\n x2 = x_node[edges[:, 1]]\\n y2 = y_node[edges[:, 1]]\\n \\n # Edges drawing\\n if line:\\n for i in range(len(x1)):\\n cv2.line(sli_ovl, (x1[i], y1[i]), (x2[i], y2[i]), \\n line_color, line_size)\\n \\n # Nodes drawing\\n for i in range(len(x_node)):\\n if degrees[i] == 1: # apex points\\n color = apex_color\\n size = apex_size\\n elif degrees[i] == 2: # body/hypha points\\n color = body_color\\n size = body_size\\n else: # branching/node points\\n color = node_color\\n size = node_size\\n cv2.circle(sli_ovl, (x_node[i], y_node[i]), size, color, \\n thickness=-1)\\n\\n return sli_ovl\",\n \"def render(self, ctx):\\n image = np.zeros((self.height, self.width, 3), np.uint8)\\n for shape in ctx.shapes:\\n if isinstance(shape, context.Rectangle):\\n x = int(shape.width / 2)\\n y = int(shape.height / 2)\\n rad = np.radians(shape.rotation)\\n rotation = np.array([[np.cos(rad), -np.sin(rad)],\\n [np.sin(rad), np.cos(rad)]])\\n translation = np.array([[shape.center.x], [shape.center.y]])\\n corners = np.array([[-x, x, x, -x], [y, y, -y, -y]])\\n transformed_corners = rotation.dot(corners) + translation\\n transformed_corners = transformed_corners.T.astype(int)\\n cv2.fillPoly(image, pts=[transformed_corners],\\n color=shape.color)\\n elif isinstance(shape, context.Circle):\\n center = (int(shape.center.x), int(shape.center.y))\\n image = cv2.circle(image, center, int(shape.radius),\\n color=shape.color, thickness=shape.thickness)\\n elif isinstance(shape, context.Text):\\n center = (int(shape.center.x), int(shape.center.y))\\n image = cv2.putText(image, shape.content, center,\\n cv2.FONT_HERSHEY_SIMPLEX, shape.size,\\n shape.color, 3, cv2.LINE_AA)\\n elif isinstance(shape, context.Image):\\n file_image = cv2.imread(shape.filepath, cv2.IMREAD_UNCHANGED)\\n file_image = cv2.resize(file_image, (shape.width, shape.height))\\n\\n y1 = int(shape.center.y - shape.height / 2)\\n y2 = int(y1 + file_image.shape[0])\\n x1 = int(shape.center.x - shape.width / 2)\\n x2 = int(x1 + file_image.shape[1])\\n\\n rgba = cv2.cvtColor(file_image, cv2.COLOR_RGB2RGBA)\\n alpha_s = rgba[:, :, 3] / 255.0\\n alpha_l = 1.0 - alpha_s\\n\\n image_save = image.copy()\\n for c in range(0, 3):\\n try:\\n image[y1:y2, x1:x2, c] = (\\n alpha_s * file_image[:, :, c] +\\n alpha_l * image[y1:y2, x1:x2, c])\\n except ValueError:\\n image = image_save\\n\\n self._display_frame(image)\",\n \"def _change_shape(self,x,y,w,h):\\n top = y \\n left = x\\n right = x + w\\n bottom = y + h\\n return top,right,bottom,left\",\n \"def make_polygon(*coords):\\n global GEOMETRY_SURF, POLYGONS,col\\n if len(coords) < 3:\\n print(\\\"Warning: Invalid polygon passed, ignoring...\\\")\\n return\\n start = coords[0]\\n prev = coords[0]\\n for coord in coords:\\n POLYGONS |= {coord}\\n line = Boundary(prev[0],prev[1],coord[0],coord[1]) #add segment to WALL list\\n prev = coord\\n line = Boundary(prev[0], prev[1],start[0],start[1])\\n #now draw poly\\n pygame.draw.polygon(GEOMETRY_SURF,col[\\\"SHAPECOL\\\"], coords)\\n return\",\n \"def crop_image(image,list_coordinate):\\n list_character = []\\n lp_image = imutils.resize(image,width = 200)\\n for bbox in list_coordinate:\\n if bbox[0][0] == bbox[0][1] == bbox[1][0] == bbox[1][1]:\\n break\\n\\n pts = np.array([(bbox[0][0],bbox[0][1]),\\n (bbox[1][0],bbox[1][1]),\\n (bbox[2][0],bbox[2][1]),\\n (bbox[3][0],bbox[3][1])],dtype = \\\"float32\\\")\\n \\n warped = four_point_transform(lp_image,pts)\\n\\n # _,warped = cv2.threshold(cv2.cvtColor(warped,cv2.COLOR_BGR2GRAY),0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\\n # warped = cv2.resize(warped,(12,28))\\n warped = resize_and_pad(warped, (28,28), padColor= 255)\\n warped = warped / 255.0\\n\\n # warped = warped[..., None]\\n list_character.append(warped)\\n return list_character\",\n \"def read_polygon_shapefile(filename):\\n result = cpp_read_polygon_shapefile(filename)\\n f_pos = Series(result[0], name=\\\"f_pos\\\")\\n r_pos = Series(result[1], name=\\\"r_pos\\\")\\n return (\\n f_pos,\\n r_pos,\\n DataFrame({\\\"x\\\": result[2], \\\"y\\\": result[3]}),\\n )\",\n \"def spatial(self):\",\n \"def roi_boundary(roi, pts_per_side=2):\\n yy, xx = roi\\n xx = np.linspace(xx.start, xx.stop, pts_per_side, dtype='float32')\\n yy = np.linspace(yy.start, yy.stop, pts_per_side, dtype='float32')\\n\\n return polygon_path(xx, yy).T[:-1]\",\n \"def test_drawWire(self):\\n\\n image_name = filename(sys._getframe().f_code.co_name)\\n result_file, reference_file = get_path(image_name)\\n\\n ''' This function is to create an empty image with a specific dimension\\n with white background, and black/white colored '''\\n\\n image, canvas = get_image('L',(640,480),'white')\\n\\n drawWire(canvas, regularPolygon(3, np.array([160, 120]), 50))\\n drawWire(canvas, regularPolygon(4, np.array([480, 120]), 90))\\n drawWire(canvas, regularPolygon(5, np.array([420, 360]), 60))\\n drawWire(canvas, regularPolygon(6, np.array([160, 360]), 80))\\n drawWire(canvas, regularPolygon(7, np.array([320, 160]), 70))\\n\\n \\\"\\\"\\\" saving the file and closing it \\\"\\\"\\\"\\n\\n image.save(result_file)\\n image.close()\\n\\n \\\"\\\"\\\" validate the resultant file against the reference images\\\"\\\"\\\"\\n\\n validate(reference_file, result_file)\",\n \"def convert_lane_boundaries_to_polygon(right_lane_bounds: np.ndarray, left_lane_bounds: np.ndarray) -> np.ndarray:\\n assert right_lane_bounds.shape[0] == left_lane_bounds.shape[0]\\n polygon = np.vstack([right_lane_bounds, left_lane_bounds[::-1]])\\n polygon = np.vstack([polygon, right_lane_bounds[0]])\\n return polygon\",\n \"def g_corners(self):\\n return (point for point in self.p)\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def generate_polygon(x,y,N):\\r\\n # Add the first point to the end of the list and convert to array if needed\\r\\n if type(x) == list:\\r\\n x = np.array(x + [x[0]])\\r\\n y = np.array(y + [y[0]])\\r\\n else:\\r\\n x = np.append(x,x[0])\\r\\n y = np.append(y,y[0])\\r\\n \\r\\n # Parameterize the arrays and interpolate\\r\\n d = [get_distance((x[i],y[i]),(x[i+1],y[i+1])) for i in range(len(x)-1)]\\r\\n d = np.cumsum([0]+d)\\r\\n t = np.linspace(0,d[-1],N)\\r\\n fx = interp1d(d,x)\\r\\n fy = interp1d(d,y)\\r\\n x = fx(t)\\r\\n y = fy(t)\\r\\n \\r\\n return x,y\",\n \"def draw_final_image(self, image, warped, undist, ploty, left_fitx, right_fitx, Minv, left_rad, right_rad):\\n gray = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)\\n # Create an image to draw the lines on\\n warp_zero = np.zeros_like(gray).astype(np.uint8)\\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\\n\\n # Recast the x and y points into usable format for cv2.fillPoly()\\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\\n pts = np.hstack((pts_left, pts_right))\\n\\n # Draw the lane onto the warped blank image\\n cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))\\n\\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\\n newwarp = cv2.warpPerspective(color_warp, Minv, (image.shape[1], image.shape[0]))\\n # Combine the result with the original image\\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\\n\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n off_center = calculate_center(left_fitx, right_fitx, image.shape)\\n direction_str = 'left' if off_center < 0 else 'right'\\n center_str = '{:.2f} m of center {}'.format(abs(off_center), direction_str)\\n cv2.putText(result, center_str, (430, 630), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\\n if left_rad and right_rad:\\n curvature = 0.5 * (round(right_rad / 1000, 1) + round(left_rad / 1000, 1))\\n else:\\n curvature = 0\\n str2 = 'Radius of curvature: {} km'.format(curvature)\\n cv2.putText(result, str2, (430, 670), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\\n\\n if self.args.is_test:\\n plt.imshow(result)\\n plt.show()\\n\\n return result\",\n \"def photo(self):\\n x_coords = [self.x1, self.x2, self.x3]\\n y_coords = [self.y1, self.y2, self.y3]\\n # draw the triangle\\n fig = pyplot.figure()\\n fig.add_subplot(111)\\n pyplot.fill(x_coords, y_coords, 'black')\\n fig.canvas.draw()\\n # convert it to a numpy array\\n w, h = fig.canvas.get_width_height()\\n buf = numpy.fromstring(fig.canvas.tostring_argb(), dtype=numpy.uint8)\\n buf.shape = (w, h, 4)\\n # roll it from ARBG to RGBA\\n buf = numpy.roll(buf, 3, axis=2)\\n return buf\",\n \"def polygonFromInteriorPoints(geom, preferredEpsg):\\n (projTr, llTr) = makeTransformations(4326, preferredEpsg)\\n\\n geomProj = copyGeom(geom)\\n geomProj.Transform(projTr)\\n geomOutline = geomProj.ConvexHull()\\n geomOutline.Transform(llTr)\\n return geomOutline\",\n \"def get_image_corners (wcs):\\n return list(wcs.calc_footprint())\",\n \"def create_image(self, shapes):\\n img = image.IMG()\\n img.draw_shapes(shapes)\\n img = np.transpose(img.array(), (2, 0, 1))\\n return img\",\n \"def speedboost():\\n image = pygame.Surface([20, 20])\\n image.fill(colour.SILVER)\\n pygame.draw.polygon(image, colour.YELLOW, [(0, 15), (10, 4), (20, 15)])\\n pygame.draw.polygon(image, colour.SILVER, [(0, 19), (10, 9), (20, 19)])\\n return image\",\n \"def makePolygon(center, sides, radius, background, colorValue, colorsRGB):\\n\\n\\tpoints = polygon(center, sides, radius)\\n\\tpointsList = [list(a) for a in points]\\n\\tp1 = np.array(pointsList)\\n\\timg = np.zeros((256, 256, 3), dtype='int32')\\n\\tif(background == \\\"white\\\"):\\n\\t\\timg.fill(255)\\n\\telif(background == \\\"random\\\"):\\n\\t\\tr = random.randint(200,245)\\n\\t\\tb = random.randint(200,245)\\n\\t\\tg = random.randint(200,245)\\n\\t\\timg = np.full(img.shape, (r,b,g), dtype=np.uint8)\\n\\tcv2.fillPoly(img, pts =[p1], color = colorsRGB[colorValue])\\n\\treturn img\",\n \"def produce_polygon(polygon_ordered_coordinates: List, zoom: int, plot_polygon: bool = False) -> Path:\\n polygon_tile_points = []\\n for item in polygon_ordered_coordinates:\\n polygon_tile_points += [Utility.get_tile(*item, zoom)]\\n polygon_tile_points += [polygon_tile_points[0]]\\n polygon = Path(polygon_tile_points)\\n if plot_polygon:\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n patch = patches.PathPatch(polygon, facecolor='orange', lw=2)\\n ax.add_patch(patch)\\n ax.set_xlim(min(polygon_tile_points, key = lambda item: item[0])[0], max(polygon_tile_points, key = lambda item: item[0])[0])\\n ax.set_ylim(min(polygon_tile_points, key = lambda item: item[1])[1], max(polygon_tile_points, key = lambda item: item[1])[1])\\n plt.show()\\n return polygon\",\n \"def poly2mask(self):\\n self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)\\n self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)\\n img = Image.new(\\\"L\\\", (self.x_gridnum, self.y_gridnum), 0)\\n\\n self.perimeter = 0.0\\n for ii in self.polygons:\\n pp = np.array(ii) * self.CD # polygon\\n polygonlen = len(pp)\\n self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))\\n pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize\\n pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize\\n vetex_list = list(pp)\\n polygon = [tuple(y) for y in vetex_list]\\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\\n\\n self.data = np.array(img)\\n self.data = np.float64(self.data)\\n\\n self.spat_part = pyfftw.empty_aligned(\\n (self.y_gridnum, self.x_gridnum), dtype=\\\"complex128\\\"\\n )\\n self.freq_part = pyfftw.empty_aligned(\\n (self.y_gridnum, self.x_gridnum), dtype=\\\"complex128\\\"\\n )\\n self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))\",\n \"def shape(self, rootsequence, side, image, option=0):\\n\\n left_points = self.get_points(\\n side=0,\\n imgnumber=image)\\n\\n leftX, leftY, leftZ = self.separate_points_by_coordinate(left_points)\\n\\n right_points = self.get_points(\\n side=1,\\n imgnumber=image)\\n\\n rightX, rightY, rightZ = self.separate_points_by_coordinate(right_points)\\n\\n if option == 1:\\n lalpha_shapes = self.alpha_shapes(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n alpha=5,\\n # color='#A91818',\\n color='#808080',\\n opacity=1.0)\\n\\n ralpha_shapes = self.alpha_shapes(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n alpha=5,\\n # color='#FF3232',\\n color='#808080',\\n opacity=1.0)\\n\\n return [lalpha_shapes, ralpha_shapes]\\n\\n elif option == 2:\\n lpoint_cloud = self.point_cloud(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n legend='RIGHT LUNG',\\n size=1,\\n # color='#FF3232',\\n # bordercolor='#FF3232',\\n color='#999999',\\n bordercolor='#999999',\\n width=0.5,\\n opacity=1.0)\\n\\n rpoint_cloud = self.point_cloud(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n legend='LEFT LUNG',\\n size=1,\\n # color='#701700',\\n # bordercolor='#701700',\\n color='#999999',\\n bordercolor='#999999',\\n width=0.5,\\n opacity=1.0)\\n\\n lalpha_shapes = self.alpha_shapes(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n alpha=5,\\n color='rgba(255, 0, 0, 0.1)',\\n # color='#808080',\\n opacity=1.0)\\n\\n ralpha_shapes = self.alpha_shapes(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n alpha=5,\\n color='rgba(255, 0, 0, 0.1)',\\n # color='#808080',\\n opacity=1.0)\\n\\n return [lpoint_cloud, rpoint_cloud, lalpha_shapes, ralpha_shapes]\\n\\n else:\\n lpoint_cloud = self.point_cloud(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n legend='RIGHT LUNG',\\n size=1,\\n # color='#FF3232',\\n # bordercolor='#FF3232',\\n color='#999999',\\n bordercolor='#999999',\\n width=0.5,\\n opacity=1.0)\\n\\n rpoint_cloud = self.point_cloud(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n legend='LEFT LUNG',\\n size=1,\\n color='#999999',\\n bordercolor='#999999',\\n # color='#701700',\\n # bordercolor='#701700',\\n width=0.5,\\n opacity=1.0)\\n\\n return [lpoint_cloud, rpoint_cloud]\",\n \"def shape(self):\",\n \"def shape(self):\",\n \"def polygon_path(x, y=None):\\n\\n if y is None:\\n y = x\\n\\n return np.vstack([\\n np.vstack([x, np.full_like(x, y[0])]).T,\\n np.vstack([np.full_like(y, x[-1]), y]).T[1:],\\n np.vstack([x, np.full_like(x, y[-1])]).T[::-1][1:],\\n np.vstack([np.full_like(y, x[0]), y]).T[::-1][1:]]).T\",\n \"def _svg_to_polygons(cdata):\\n polygons = []\\n groups = parse(cdata['image'])\\n\\n #iterating this dict in a strange way, need to refactor maybe\\n for g in groups:\\n for path in groups[g]:\\n #this list comprehension gets the region coordinates\\n points = ([(p[0] * cdata['width_ratio'] + cdata['start_pos'], p[1]\\n * cdata['height_ratio']) for p in path[1]])\\n\\n polygons.append({_convert_state_to_region(g):points})\\n\\n return polygons\",\n \"def fit_poly(img_shape, leftx, lefty, rightx, righty):\\n left_fit = np.polyfit(lefty, leftx, deg=2)\\n right_fit = np.polyfit(righty, rightx, deg=2)\\n # Generate x and y values for plotting\\n ploty = np.linspace(0, img_shape[0]-1, img_shape[0])\\n ### TO-DO: Calc both polynomials using ploty, left_fit and right_fit ###\\n left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]\\n right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\\n \\n return left_fitx, right_fitx, ploty\",\n \"def __repr__(self):\\n return 'Polygon({%s})' % \\\", \\\".join(str(line) for line in self.lines)\",\n \"def _create_main_shape(self):\\n\\n a, b = gc( self.size/2,\\n self._ZERO_DEGREES - self.angle,\\n self._180_DEGREES + self.angle)\\n self.wafer_points = zip(a,b)\\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\\n self.cell.add(self.wafer_polygon)\",\n \"def create_general_object(self, x, y):\\n return self.img[y-self.rad:y+self.rad, x-self.rad:x+self.rad]\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def decorate_scene():\\n make_polygon( (100,100),(120,140),(270,70) )\\n make_polygon( (300,10), (300,550), (340,452),(380,300), (330,50))\\n make_polygon( (200,450), (100,450), (100,500), (200,500) )\\n make_polygon( (130,320), (150,300), (140,280) )\\n return\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img)\\n\\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n\\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color\\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n\\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n\\n return masked_image\",\n \"def heliographic(self, *args):\\n\\n\\t\\txScl = self.im_raw.scale[0].value\\n\\t\\tyScl = self.im_raw.scale[1].value\\n\\t\\t\\n\\t\\t# Check for single coordinate or ndarray object.\\n\\t\\tif isinstance(args[0], np.ndarray):\\n\\t\\t\\t# Retrieve integer dimensions and create arrays holding\\n\\t\\t\\t# x and y coordinates of each pixel\\n\\t\\t\\txdim = np.int(np.floor(self.im_raw.dimensions[0].value))\\n\\t\\t\\tydim = np.int(np.floor(self.im_raw.dimensions[1].value))\\n\\t\\t\\ttry:\\n\\t\\t\\t\\txrow = (np.arange(0, xdim) - self.X0 + args[1])*xScl\\n\\t\\t\\t\\tyrow = (np.arange(0, ydim) - self.Y0 + args[2])*yScl\\n\\t\\t\\t\\tself.xg, self.yg = np.meshgrid(xrow, yrow, indexing='xy')\\n\\t\\t\\t\\tself.rg = np.sqrt(self.xg**2 + self.yg**2)\\n\\t\\t\\t\\tx = self.xg\\n\\t\\t\\t\\ty = -self.yg\\n\\t\\t\\texcept IndexError:\\n\\t\\t\\t\\txrow = (np.arange(0, xdim) - self.X0)*xScl\\n\\t\\t\\t\\tyrow = (np.arange(0, ydim) - self.Y0)*yScl\\n\\t\\t\\t\\tself.xg, self.yg = np.meshgrid(xrow, yrow, indexing='xy')\\n\\t\\t\\t\\tself.rg = np.sqrt(self.xg**2 + self.yg**2)\\n\\t\\t\\t\\tx = self.xg\\n\\t\\t\\t\\ty = -self.yg\\n\\t\\telse:\\n\\t\\t\\t# Have to switch coordinate conventions because calculations\\n\\t\\t\\t# assume standard cartesian whereas python indexing is \\n\\t\\t\\t# [row, column]\\n\\t\\t\\tx = (args[1] - self.X0)*xScl/60.0\\n\\t\\t\\ty = (self.Y0 - args[0])*yScl/60.0\\n\\n\\t\\tb0_r = np.deg2rad(self.B0)\\n\\t\\tradius = self.rsun\\n\\t\\tRobs = 1/np.tan(np.deg2rad(radius/60))\\n\\n\\t\\txxat = np.tan(np.deg2rad(x/60))\\n\\t\\tyyat = np.tan(np.deg2rad(y/60))\\n\\n\\t\\trat2 = (xxat**2 + yyat**2)\\n\\t\\tphi = 0*rat2\\n\\t\\tw_rat2 = np.where(rat2 is not 0)\\n\\t\\tphi[w_rat2] = np.arctan2(xxat[w_rat2], yyat[w_rat2])\\n\\n\\t\\tmax_ra = np.arcsin(1.0/Robs)\\n\\t\\tmax_rat2 = np.tan(max_ra)*np.tan(max_ra)\\n\\n\\t\\tii = np.where(rat2 > max_rat2)\\n\\t\\tif ii[0].any() > 0:\\n\\t\\t\\trat2[ii] = max_rat2\\n\\t\\t\\t#offlimb[ii] = 1\\n\\n\\t\\t###############################################\\n\\t\\tras2 = 0*rat2\\n\\t\\tras2[w_rat2] = 1.0/(1.0 + 1.0/rat2[w_rat2])\\n\\t\\td1 = (1.0 - ras2)\\n\\t\\td2 = (1.0 - (Robs**2*ras2))\\n\\t\\tx = ras2*Robs + np.sqrt(d1)*np.sqrt(d2)\\n\\t\\trr = np.sqrt(rat2*Robs)\\n\\t\\tt1 = np.sin(phi)*rr\\n\\t\\tt2 = np.cos(phi)*rr\\n\\n\\t\\thglt = np.arcsin(t2)\\n\\t\\thgln = np.arctan2(x, t1)\\n\\n\\n\\n\\n\\t\\t# Only add the instance attribute if it doesn't exist.\\n\\t\\tif isinstance(args[0], np.ndarray) and not hasattr(self, 'lonh'):\\n\\t\\t\\tself.lonh = np.rad2deg(hgln)\\n\\t\\t\\tself.lath = np.rad2deg(hglt)\\n\\n\\t\\treturn np.rad2deg(hgln), np.rad2deg(hglt)\",\n \"def calculate_points(self, component):\\n # find selection range on source plot\\n x_start, x_end = self._get_selection_screencoords()\\n if x_start > x_end:\\n x_start, x_end = x_end, x_start\\n\\n y_end = self.source.y\\n y_start = self.source.y2\\n\\n left_top = np.array([x_start, y_end])\\n left_mid = np.array([x_start, y_start])\\n right_top = np.array([x_end, y_end])\\n right_mid = np.array([x_end, y_start])\\n\\n # Offset y because we want to avoid overlapping the trapezoid with the topmost\\n # pixels of the destination plot.\\n y = self.destination.y - 1\\n\\n left_end = np.array([self.destination.x, y])\\n right_end = np.array([self.destination.x2, y])\\n\\n polygon = np.array((left_end, left_mid, left_top,\\n right_top, right_mid, right_end))\\n left_line = np.array((left_top, left_mid, left_end))\\n right_line = np.array((right_end, right_mid, right_top))\\n\\n return left_line, right_line, polygon\",\n \"def calculate_points(self, component):\\n # find selection range on source plot\\n x_start, x_end = self._get_selection_screencoords()\\n if x_start > x_end:\\n x_start, x_end = x_end, x_start\\n\\n y_end = self.source.y\\n y_start = self.source.y2\\n\\n left_top = np.array([x_start, y_start])\\n left_mid = np.array([x_start, y_end])\\n right_top = np.array([x_end, y_start])\\n right_mid = np.array([x_end, y_end])\\n\\n # Offset y because we want to avoid overlapping the trapezoid with the topmost\\n # pixels of the destination plot.\\n y = self.destination.y2 + 1\\n\\n left_end = np.array([self.destination.x, y])\\n right_end = np.array([self.destination.x2, y])\\n\\n polygon = np.array((left_top, left_mid, left_end,\\n right_end, right_mid, right_top))\\n left_line = np.array((left_top, left_mid, left_end))\\n right_line = np.array((right_end, right_mid, right_top))\\n\\n return left_line, right_line, polygon\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img)\\n\\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n\\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color\\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n\\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img)\\n\\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n\\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color\\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n\\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img)\\n\\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n\\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color\\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n\\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def region_of_interest(img, vertices):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img)\\n\\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n\\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color\\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n\\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def generatePolygons(self, *args, **kwargs): \\n return 'var PloneMapPolygons = [' + \\\\\\n ''.join([\\\"{ 'id': '%s', 'path' : %s,'title':'%s'},\\\" % (object.id, object.polygon, object.Title()) \\n for object in self.context.objectValues() \\n if hasattr(object, 'polygon') and len(object.polygon) > 0 ])[:-1] \\\\\\n + '];'\",\n \"def get_corner(image, side):\\n if side not in [\\\"tl\\\", \\\"tr\\\", \\\"bl\\\", \\\"br\\\"]:\\n return 1, None\\n size = (image.shape[0]) // 2, (image.shape[1]) // 2\\n if side == \\\"tl\\\":\\n return 0, image[size[0] :, -size[1] :]\\n if side == \\\"tr\\\":\\n return 0, image[size[0] :, : size[1]]\\n if side == \\\"bl\\\":\\n return 0, image[: -size[0], : size[1]]\\n if side == \\\"br\\\":\\n return 0, image[: -size[0], -size[1] :]\",\n \"def get_bounding_rect(polygon):\\n x1, y1, x2, y2 = float('inf'), float('inf'), float('-inf'), float('-inf')\\n for x, y in polygon:\\n if x < x1:\\n x1 = x\\n if y < y1:\\n y1 = y\\n if x > x2:\\n x2 = x\\n if y > y2:\\n y2 = y\\n return x1, y1, x2, y2\",\n \"def region_of_interest(img, vertices):\\n \\n # defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n # defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n # filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n # returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n \\n return masked_image\",\n \"def create_geofence(self):\\n\\t\\tring = ogr.Geometry(ogr.wkbLinearRing)\\n\\t\\tring.AddPoint(*self.north_coords)\\n\\t\\tring.AddPoint(*self.northeast_coords)\\n\\t\\tring.AddPoint(*self.east_coords)\\n\\t\\tring.AddPoint(*self.southeast_coords)\\n\\t\\tring.AddPoint(*self.south_coords)\\n\\t\\tring.AddPoint(*self.southwest_coords)\\n\\t\\tring.AddPoint(*self.west_coords)\\n\\t\\tring.AddPoint(*self.northwest_coords)\\n\\t\\tring.AddPoint(*self.north_coords)\\n\\t\\tself.polygon.AddGeometry(ring)\",\n \"def flattener(image, pts, w, h):\\n temp_rect = np.zeros((4,2), dtype = \\\"float32\\\")\\n \\n s = np.sum(pts, axis = 2)\\n\\n tl = pts[np.argmin(s)]\\n br = pts[np.argmax(s)]\\n\\n diff = np.diff(pts, axis = -1)\\n tr = pts[np.argmin(diff)]\\n bl = pts[np.argmax(diff)]\\n\\n if w <= 0.8 * h: # If card is vertically oriented\\n temp_rect[0] = tl\\n temp_rect[1] = tr\\n temp_rect[2] = br\\n temp_rect[3] = bl\\n\\n if w >= 1.2 * h: # If card is horizontally oriented\\n temp_rect[0] = bl\\n temp_rect[1] = tl\\n temp_rect[2] = tr\\n temp_rect[3] = br\\n\\n if w > 0.8 * h and w < 1.2 * h: #If card is diamond oriented\\n # If furthest left point is higher than furthest right point,\\n # card is tilted to the left.\\n if pts[1][0][1] <= pts[3][0][1]:\\n # If card is titled to the left, approxPolyDP returns points\\n # in this order: top right, top left, bottom left, bottom right\\n temp_rect[0] = pts[1][0] # Top left\\n temp_rect[1] = pts[0][0] # Top right\\n temp_rect[2] = pts[3][0] # Bottom right\\n temp_rect[3] = pts[2][0] # Bottom left\\n\\n # If furthest left point is lower than furthest right point,\\n # card is tilted to the right\\n if pts[1][0][1] > pts[3][0][1]:\\n # If card is titled to the right, approxPolyDP returns points\\n # in this order: top left, bottom left, bottom right, top right\\n temp_rect[0] = pts[0][0] # Top left\\n temp_rect[1] = pts[3][0] # Top right\\n temp_rect[2] = pts[2][0] # Bottom right\\n temp_rect[3] = pts[1][0] # Bottom left\\n \\n # Create destination array, calculate perspective transform matrix,\\n # and warp card image\\n dst = np.array([[0, 0], [MAXWIDTH - 1, 0], [MAXWIDTH - 1, MAXHEIGHT - 1], [0, MAXHEIGHT - 1]], np.float32)\\n M = cv2.getPerspectiveTransform(temp_rect, dst)\\n warp = cv2.warpPerspective(image, M, (MAXWIDTH, MAXHEIGHT))\\n\\n return warp\",\n \"def draw_boxes(image, bounds, color):\\n draw = ImageDraw.Draw(image)\\n\\n for bound in bounds:\\n draw.polygon([\\n bound.vertices[0].x, bound.vertices[0].y,\\n bound.vertices[1].x, bound.vertices[1].y,\\n bound.vertices[2].x, bound.vertices[2].y,\\n bound.vertices[3].x, bound.vertices[3].y], None, color)\\n # font = ImageFont.truetype(\\\"sans-serif.ttf\\\", 10)\\n draw.text((bound.vertices[0].x, bound.vertices[0].y,),bound,(255,255,255),font=font)\\n return image\",\n \"def region_of_interest(img, vertices, debug = False):\\n #defining a blank mask to start with\\n mask = np.zeros_like(img) \\n \\n #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n \\n #filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color \\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n \\n #returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def getCoordinates(p):\\n if p[0] == 'p': # minimum bounding rectangle for point\\n return (int(p[1]), int(p[2]), int(p[1]), int(p[2]))\\n elif p[0] == 'c': # minimum bounding rectangle for circle\\n x = int(p[1])\\n y = int(p[2])\\n r = int(p[3])\\n return (x - r, y - r, x + r, y + r)\\n elif p[0] == 'l': # minimum bounding rectangle for line segment\\n x1 = int(p[1])\\n y1 = int(p[2])\\n x2 = int(p[3])\\n y2 = int(p[4])\\n if y2 > y1:\\n if x1 < x2:\\n return (x1, y1, x2, y2)\\n else:\\n return (x2, y1, x1, y2)\\n else:\\n if x1 < x2:\\n return (x1, y2, x2, y1)\\n else:\\n return (x2, y2, x1, y1)\",\n \"def extent(self):\\n left = self.transform[0]\\n right = left + self.transform[1] * self.shape[1]\\n top = self.transform[3]\\n bottom = top + self.transform[5] * self.shape[0]\\n return left, right, bottom, top\",\n \"def makeup_polygons(\\n draw: ImageDraw,\\n num_cells: int,\\n width: int,\\n height: int,\\n rgb_im: Image,\\n random: bool,\\n):\\n voronoi, points = generate_voronoi_diagram(num_cells, width, height)\\n for point, index in zip(points, voronoi.point_region):\\n # Getting the region of the given point\\n region = voronoi.regions[index]\\n # Getting the points in arrays\\n polygon = list()\\n for i in region:\\n # If vector is out of plot do not add\\n if i != -1:\\n polygon.append(voronoi.vertices[i])\\n # Make tuples of the points\\n polygon_tuples = list()\\n for l in polygon:\\n polygon_tuples.append(tuple(l))\\n rgb = (0, 0, 0)\\n if random:\\n # Get random color\\n rgb = random_color()\\n else:\\n # Get colors of the middle point\\n rgb = get_color_of_point(point, rgb_im, width, height)\\n # Draw the calculated polygon with the color of the middle point\\n if polygon and polygon_tuples:\\n draw.polygon(polygon_tuples, rgb)\",\n \"def fill_polygon(points, im_shape):\\n im_cnt = np.zeros((im_shape[0],im_shape[1],1), np.uint8)\\n cv.fillPoly(im_cnt, [points], (255,255))\\n\\n return im_cnt\",\n \"def calculate(self, image: Image, **kwargs) -> PointList:\\n if image.mode != \\\"RGBA\\\":\\n raise ValueError(\\\"Image mode is not RGBA. image.convert('RGBA') is needed.\\\")\\n\\n # Convert the image into one channel alpha since we don't care about RGB values\\n image = image.getchannel(\\\"A\\\")\\n bbox = image.getbbox()\\n # If there is no bounding box the image is empty\\n if bbox is None:\\n return tuple()\\n\\n left_border, top_border, right_border, bottom_border = bbox\\n right_border -= 1\\n bottom_border -= 1\\n\\n def _check_corner_offset(start_x: int, start_y: int, x_direction: int, y_direction: int) -> int:\\n bad = False\\n offset = 0\\n while not bad:\\n y = start_y + (offset * y_direction)\\n x = start_x\\n for _ in range(offset + 1):\\n alpha = image.getpixel((x, y))\\n # print(f\\\"({x}, {y}) = {my_pixel} | \\\", end=\\\"\\\")\\n if alpha != 0:\\n bad = True\\n break\\n y -= y_direction\\n x += x_direction\\n # print(f\\\" - {bad}\\\")\\n if not bad:\\n offset += 1\\n # print(f\\\"offset: {offset}\\\")\\n return offset\\n\\n def _r(point: Tuple[float, float], height: int, width: int) -> Point:\\n return point[0] - width / 2, (height - point[1]) - height / 2\\n\\n top_left_corner_offset = _check_corner_offset(left_border, top_border, 1, 1)\\n top_right_corner_offset = _check_corner_offset(right_border, top_border, -1, 1)\\n bottom_left_corner_offset = _check_corner_offset(left_border, bottom_border, 1, -1)\\n bottom_right_corner_offset = _check_corner_offset(right_border, bottom_border, -1, -1)\\n\\n p1 = left_border + top_left_corner_offset, top_border\\n p2 = (right_border + 1) - top_right_corner_offset, top_border\\n p3 = (right_border + 1), top_border + top_right_corner_offset\\n p4 = (right_border + 1), (bottom_border + 1) - bottom_right_corner_offset\\n p5 = (right_border + 1) - bottom_right_corner_offset, (bottom_border + 1)\\n p6 = left_border + bottom_left_corner_offset, (bottom_border + 1)\\n p7 = left_border, (bottom_border + 1) - bottom_left_corner_offset\\n p8 = left_border, top_border + top_left_corner_offset\\n\\n result = []\\n\\n h = image.height\\n w = image.width\\n\\n result.append(_r(p7, h, w))\\n if bottom_left_corner_offset:\\n result.append(_r(p6, h, w))\\n\\n result.append(_r(p5, h, w))\\n if bottom_right_corner_offset:\\n result.append(_r(p4, h, w))\\n\\n result.append(_r(p3, h, w))\\n if top_right_corner_offset:\\n result.append(_r(p2, h, w))\\n\\n result.append(_r(p1, h, w))\\n if top_left_corner_offset:\\n result.append(_r(p8, h, w))\\n\\n # Remove duplicates\\n return tuple(dict.fromkeys(result)) # type: ignore\",\n \"def save_groudtruth(im, coords, filename):\\n print 'Saving ground truth ......{0}'.format(filename)\\n img_draw = Image.fromarray(cv2.cvtColor(im, cv2.COLOR_BGR2RGB))\\n draw = ImageDraw.Draw(img_draw)\\n for coord in coords:\\n draw.polygon([(float(coord[0]), float(coord[1])), (float(coord[2]), float(coord[3])),\\n (float(coord[4]), float(coord[5])), (float(coord[6]), float(coord[7]))],\\n outline=\\\"red\\\", fill=\\\"blue\\\")\\n img_draw = np.array(img_draw)\\n img_draw = cv2.cvtColor(img_draw, cv2.COLOR_RGB2BGR)\\n bname_excludepoint = filename.split('/')[-1].split('.')[0]\\n image_path = '/home/yuquanjie/Documents/deep-direct-regression/result/' + bname_excludepoint + '_gt.jpg'\\n cv2.imwrite(image_path, img_draw[0: img_draw.shape[0], 0: img_draw.shape[1]])\",\n \"def edges(i):\\n Oxy = i.copy()\\n Kx = [-1, 0, 1, -2, 0, 2, -1, 0, 1]\\n Ky = [-1, -2, -1, 0, 0, 0, 1, 2, 1]\\n\\n Ox = correlate(i, Kx)\\n Oy = correlate(i,Ky)\\n\\n Oxy[\\\"pixels\\\"] = [ (x**2 + y**2)**(1/2) for x, y in zip(Ox[\\\"pixels\\\"], Oy[\\\"pixels\\\"])]\\n\\n result = round_and_clip_image(Oxy)\\n return result\",\n \"def get_coords_2d(obj, P):\\n bbox3 = get_coords_3d(obj)\\n # Rl = obj.Rl\\n # height = obj.height\\n # width = obj.width\\n # length = obj.length\\n # x = obj.x\\n # y = obj.y\\n # z = obj.z\\n # bbox = np.array([[-length, 0, -width],\\n # [-length, 0, width],\\n # [ length, 0, width],\\n # [ length, 0, -width],\\n # [-length, -2*height, -width],\\n # [-length, -2*height, width],\\n # [ length, -2*height, width],\\n # [ length, -2*height, -width]])/2\\n # if abs(z) < 1e-6: z = np.sign(z) * 1e-6\\n # M = rotationM([0, 1, 0], Rl + math.atan(x/z))\\n # bbox = np.transpose(np.dot(M, np.transpose(bbox)))\\n # bbox3 = bbox + np.array([x, y, z])\\n bbox2 = project_pts3_to_image(bbox3, P)\\n return bbox2\",\n \"def image(self):\\n if self.roi and len(self.roi) == 4:\\n return self.calibrated_image[self.roi[0]:self.roi[1],self.roi[2]:self.roi[3]]\\n else:\\n return self.calibrated_image\",\n \"def extent_as_polygon(self, crs=wgs84):\\n from shapely.geometry import Polygon\\n\\n # this is not so trivial\\n # for optimisation we will transform the boundaries only\\n _i = np.hstack([np.arange(self.nx+1),\\n np.ones(self.ny+1)*self.nx,\\n np.arange(self.nx+1)[::-1],\\n np.zeros(self.ny+1)]).flatten()\\n _j = np.hstack([np.zeros(self.nx+1),\\n np.arange(self.ny+1),\\n np.ones(self.nx+1)*self.ny,\\n np.arange(self.ny+1)[::-1]]).flatten()\\n _i, _j = self.corner_grid.ij_to_crs(_i, _j, crs=crs)\\n return Polygon(zip(_i, _j))\",\n \"def extent(self):\\n if self.x is not None:\\n if self.y is not None:\\n if self.z is not None:\\n return (self.x.min(), self.x.max(),\\n self.y.min(), self.y.max(),\\n self.z.min(), self.z.max())\\n return (self.x.min(), self.x.max(),\\n self.y.min(), self.y.max())\\n return (self.x.min(), self.x.max())\\n\\n elif self.r is not None and self.t is not None:\\n if self.z is not None:\\n return (self.z.min(), self.z.max(),\\n self.r.min(), self.r.max(),\\n self.t.min(), self.t.max())\\n return (self.r.min(), self.r.max(),\\n self.t.min(), self.t.max())\\n\\n return ()\",\n \"def _rasterize_polygons(polygons, bounds = [[-100, -100], [100, 100]],\\n dx = 1, dy = 1):\\n try:\\n from skimage import draw\\n except:\\n raise ImportError('The fill function requires the module '\\n '\\\"scikit-image\\\" to operate. Please retry '\\n 'after installing scikit-image:\\\\n\\\\n'\\n '$ pip install --upgrade scikit-image')\\n\\n # Prepare polygon array by shifting all points into the first quadrant and\\n # separating points into x and y lists\\n xpts = []\\n ypts = []\\n for p in polygons:\\n p_array = np.asarray(p)\\n x = p_array[:, 0]\\n y = p_array[:, 1]\\n xpts.append((x-bounds[0][0])/dx - 0.5)\\n ypts.append((y-bounds[0][1])/dy - 0.5)\\n\\n # Initialize the raster matrix we'll be writing to\\n xsize = int(np.ceil((bounds[1][0]-bounds[0][0]))/dx)\\n ysize = int(np.ceil((bounds[1][1]-bounds[0][1]))/dy)\\n raster = np.zeros((ysize, xsize), dtype = np.bool)\\n\\n # TODO: Replace polygon_perimeter with the supercover version\\n for n in range(len(xpts)):\\n rr, cc = draw.polygon(ypts[n], xpts[n], shape = raster.shape)\\n rrp, ccp = draw.polygon_perimeter(ypts[n], xpts[n],\\n shape = raster.shape, clip = False)\\n raster[rr, cc] = 1\\n raster[rrp, ccp] = 1\\n\\n return raster\",\n \"def region_of_interest(img, vertices):\\n\\n # defining a blank mask to start with\\n mask = np.zeros_like(img)\\n\\n # defining a 3 channel or 1 channel color to fill the mask with depending on the input image\\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n\\n # filling pixels inside the polygon defined by \\\"vertices\\\" with the fill color\\n cv2.fillPoly(mask, vertices, ignore_mask_color)\\n\\n # returning the image only where mask pixels are nonzero\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def pixelcode(self):\\n\\n maxX, maxY = self.size()\\n result = bitmap((2*maxX, 2*maxY))\\n for x in range(maxX):\\n for y in range(maxY):\\n pixel = self.get(x,y)\\n result.set(2*x,2*y, pixel)\\n result.set(2*x,2*y+1, not pixel)\\n result.set(2*x+1,2*y, not pixel)\\n result.set(2*x+1,2*y+1, pixel)\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65409863","0.6449552","0.62613237","0.61531603","0.61507094","0.6134605","0.5918344","0.5892853","0.58924294","0.58919007","0.58887494","0.58701646","0.58659583","0.5839686","0.58155435","0.5813019","0.581092","0.5798064","0.57906735","0.5779135","0.57643324","0.5759361","0.5755348","0.57522845","0.5746816","0.5746685","0.5742059","0.57363904","0.5733292","0.569904","0.5636603","0.56299454","0.5617504","0.56149054","0.56110495","0.560854","0.5605754","0.5601306","0.5597947","0.55921","0.5560618","0.55585796","0.553396","0.5533003","0.55329454","0.55248326","0.5520416","0.5519425","0.55166125","0.55081195","0.55057013","0.54991835","0.5497664","0.5497011","0.5488007","0.5488007","0.54869425","0.54842347","0.54824734","0.5475866","0.5469764","0.5464792","0.54641753","0.54641753","0.54641753","0.54641753","0.54641753","0.54641753","0.54641753","0.544563","0.5434619","0.54271895","0.5421472","0.5413693","0.5412726","0.5412726","0.5412726","0.5412726","0.5405546","0.5401315","0.54009575","0.5394452","0.53836745","0.5379847","0.5372836","0.5372466","0.53710955","0.5370658","0.53625166","0.5358267","0.5358238","0.53567386","0.53561354","0.53475076","0.5347352","0.53459805","0.5343897","0.5341019","0.5336728","0.53279567"],"string":"[\n \"0.65409863\",\n \"0.6449552\",\n \"0.62613237\",\n \"0.61531603\",\n \"0.61507094\",\n \"0.6134605\",\n \"0.5918344\",\n \"0.5892853\",\n \"0.58924294\",\n \"0.58919007\",\n \"0.58887494\",\n \"0.58701646\",\n \"0.58659583\",\n \"0.5839686\",\n \"0.58155435\",\n \"0.5813019\",\n \"0.581092\",\n \"0.5798064\",\n \"0.57906735\",\n \"0.5779135\",\n \"0.57643324\",\n \"0.5759361\",\n \"0.5755348\",\n \"0.57522845\",\n \"0.5746816\",\n \"0.5746685\",\n \"0.5742059\",\n \"0.57363904\",\n \"0.5733292\",\n \"0.569904\",\n \"0.5636603\",\n \"0.56299454\",\n \"0.5617504\",\n \"0.56149054\",\n \"0.56110495\",\n \"0.560854\",\n \"0.5605754\",\n \"0.5601306\",\n \"0.5597947\",\n \"0.55921\",\n \"0.5560618\",\n \"0.55585796\",\n \"0.553396\",\n \"0.5533003\",\n \"0.55329454\",\n \"0.55248326\",\n \"0.5520416\",\n \"0.5519425\",\n \"0.55166125\",\n \"0.55081195\",\n \"0.55057013\",\n \"0.54991835\",\n \"0.5497664\",\n \"0.5497011\",\n \"0.5488007\",\n \"0.5488007\",\n \"0.54869425\",\n \"0.54842347\",\n \"0.54824734\",\n \"0.5475866\",\n \"0.5469764\",\n \"0.5464792\",\n \"0.54641753\",\n \"0.54641753\",\n \"0.54641753\",\n \"0.54641753\",\n \"0.54641753\",\n \"0.54641753\",\n \"0.54641753\",\n \"0.544563\",\n \"0.5434619\",\n \"0.54271895\",\n \"0.5421472\",\n \"0.5413693\",\n \"0.5412726\",\n \"0.5412726\",\n \"0.5412726\",\n \"0.5412726\",\n \"0.5405546\",\n \"0.5401315\",\n \"0.54009575\",\n \"0.5394452\",\n \"0.53836745\",\n \"0.5379847\",\n \"0.5372836\",\n \"0.5372466\",\n \"0.53710955\",\n \"0.5370658\",\n \"0.53625166\",\n \"0.5358267\",\n \"0.5358238\",\n \"0.53567386\",\n \"0.53561354\",\n \"0.53475076\",\n \"0.5347352\",\n \"0.53459805\",\n \"0.5343897\",\n \"0.5341019\",\n \"0.5336728\",\n \"0.53279567\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7396713"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14788,"cells":{"query":{"kind":"string","value":"Convert parameters from X,Y plane to Image Plane Points"},"document":{"kind":"string","value":"def coordinates_to_imgpts(x, y):\n pts = np.array([np.flipud(np.transpose(np.vstack([x, y])))])\n return pts"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def project_points_plane(points, plane):\n return [project_point_plane(point, plane) for point in points]","def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\n # preliminary stuff\n if origin != None: x = x - origin\n a,b,c,d = plane\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\n px, py, pz = new_x\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\n px, py, pz = px/bot, py/bot, pz/bot\n p0 = [px,py,pz]\n # do rotation\n z_hat = [a,b,c]\n y_hat = cross(z_hat, p0)\n x_hat = cross(y_hat, z_hat)\n if type(x)==type(arr) or type(x)==type([]):\n xp, yp, zp = [], [], []\n for i in range(len(x)):\n xp.append(dot([x[i],y[i],z[i]], x_hat))\n yp.append(dot([x[i],y[i],z[i]], y_hat))\n zp.append(dot([x[i],y[i],z[i]], z_hat))\n else:\n xp = dot([x,y,z], x_hat)\n yp = dot([x,y,z], y_hat)\n zp = dot([x,y,z], z_hat)\n return xp, yp, zp","def project_point_plane(point, plane):\n base, normal = plane\n normal = normalize_vector(normal)\n vector = subtract_vectors(point, base)\n snormal = scale_vector(normal, dot_vectors(vector, normal))\n return subtract_vectors(point, snormal)","def create_plane(self):\n\n # First we calculate our point increment for both the x and y values\n inc_x = (self.xmax - self.xmin)/(self.xlen - 1)\n inc_y = (self.ymax - self.ymin)/(self.ylen - 1)\n\n # This for-loop will add every x-value with every y-value, saving the values column wise\n # i.e. (-10,-10), (-10,-9), (-10.-8),...,(-10,n) for n = our y-values.\n # store these combinations into a list, and add that to our plane. \n # The nested loop will then traverse again and will get the combinations for the next x-value.\n # The loop will continue until all x-values and y-value combinations are added to our plane.\n for y in range(0, self.ylen + 1):\n temp_list = []\n for x in range(0, self.xlen + 1):\n temp_list.append(self.f((self.xmin + x*inc_x) + (self.ymin + y*inc_y)*1j))\n self.plane.append(temp_list)","def project_onto_plane(vect):\n x, y, z = vect\n \n return (x, y, 0.)","def pointToWorld( nImageX, nImageY, rDepth, rMaxX = 320, rMaxY = 240, rFieldOfViewX = 60, rFieldOfViewY = 40 ):\n # convert to [-0.5,0.5]\n rCenteredX = ( nImageX / rMaxX ) - 0.5;\n rCenteredY = ( nImageY / rMaxY ) - 0.5;","def vecteur_image(T,x,y):\n a,b,c,d = T[0][0],T[0][1],T[1][0],T[1][1]\n xx = a*x + b*y\n yy = c*x + d*y\n return xx,yy","def _fit_plane_to_point_cloud(\n points_xyz: NDArrayFloat,\n) -> Tuple[float, float, float, float]:\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\n points_xyz - center_xyz\n )\n vh = out[2]\n\n # Get the unitary normal vector\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\n d: float = -np.dot([a, b, c], center_xyz)\n return (a, b, c, d)","def two_plane_obj_points(grid_size, dx):\r\n objp_xy = np.zeros((grid_size[0]*grid_size[1], 3), np.float32)\r\n objp_yz = np.zeros((grid_size[1]*grid_size[2], 3), np.float32)\r\n objp_xy[:,:2] = np.mgrid[0:grid_size[0], 0:grid_size[1]].T.reshape(-1, 2)\r\n objp_yz[:,1:3] = np.mgrid[0:grid_size[1], 0:grid_size[2]].T.reshape(-1, 2)\r\n\r\n return objp_xy*dx, objp_yz*dx","def invert_points_on_plane(pnts, plane):\n ptol = Settings.ptol\n vu = plane.vu.ijk\n vv = plane.vv.ijk\n p0 = plane.p0.xyz\n vu2 = dot(vu, vu)\n vv2 = dot(vv, vv)\n\n pnts = array(pnts, dtype=float64)\n npts = pnts.shape[0]\n params = zeros((npts, 2), dtype=float64)\n for i in range(0, npts):\n pi = pnts[i]\n u = dot(pi - p0, vu) / vu2\n v = dot(pi - p0, vv) / vv2\n if abs(u) <= ptol:\n u = 0.\n if abs(v) <= ptol:\n v = 0.\n params[i, :] = [u, v]\n\n return params","def plane(self):\n return plane(self.N, self.o)","def converte_coord(valor):\n\n pts1 = ([0,0],[24,0],[24,44],[0,44])\n pts1 = np.asarray(pts1, dtype = np.float32)\n pts2 = np.float32([[0,0],[100,0], [100,100], [0,100]])\n\n M = cv.getPerspectiveTransform(pts1,pts2)\n img2 = cv.warpPerspective(valor,M,(100,100))\n return img2","def point_and_plane_pose(plane_point, plane_orientation, points=None, xyz=None):\n vector = plane_orientation\n vector = vector / np.linalg.norm(vector)\n a = vector[0]\n b = vector[1]\n c = vector[2]\n\n d = -a * plane_point[0] - b * plane_point[1] - c * plane_point[2]\n\n if xyz is not None:\n xyz = np.asarray(xyz)\n if points.shape[0] != 3:\n logger.error(\n \"Wrong points shape. [3, N] expected, \" + str(points.shape) + \" given.\"\n )\n elif points is not None:\n points = np.asarray(points)\n if points.shape[1] != 3:\n logger.error(\n \"Wrong points shape. [N, 3] expected, \" + str(points.shape) + \" given.\"\n )\n xyz = points.T\n else:\n logger.error(\"points or xyz must be declared\")\n\n x, y, z = xyz\n z_out = (a * x + b * y + c * z + d) / (a ** 2 + b ** 2 + c ** 2) ** 0.5\n\n return z_out","def plane(self):\r\n from lsst.analysis import utils\r\n return utils.fitplane(self.points, self.z)","def proj_to_plane(norm, d, pts):\n a = norm[0]\n b = norm[1]\n c = norm[2]\n\n p = []\n\n for i in range(len(pts)):\n x_p = pts[i][0]\n y_p = pts[i][1]\n z_p = pts[i][2]\n\n if a != 0:\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\n\n elif b != 0:\n x_0 = x_p \n y_0 = c * c * y_p - b * (d + c)\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\n\n else:\n x_0 = x_p\n y_0 = y_p\n z_0 = - d * 1.0 / c\n\n p.append([x_0, y_0, z_0])\n \n return p","def proj_to_plane(norm, d, pts):\n a = norm[0]\n b = norm[1]\n c = norm[2]\n\n p = []\n\n for i in range(len(pts)):\n x_p = pts[i][0]\n y_p = pts[i][1]\n z_p = pts[i][2]\n\n if a != 0:\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\n\n elif b != 0:\n x_0 = x_p \n y_0 = c * c * y_p - b * (d + c)\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\n\n else:\n x_0 = x_p\n y_0 = y_p\n z_0 = - d * 1.0 / c\n\n p.append([x_0, y_0, z_0])\n \n return p","def invert_point_on_plane(point, plane):\n _, _, proj = project_point_to_plane(point, plane)\n\n u, v = proj[0][1]\n return u, v","def GetParametricCoords(self):\n ...","def topo_plane_paramEval(self, param):\n # Create an empty numpy array with the same number as pixels as the real data.\n self.topo_plane_fit_data = np.zeros((self.y_res, self.x_res))\n for y in range(0, self.y_res): # Iterate over the y-axis pixels.\n for x in range(0, self.x_res): # Iterate over the x-axis pixels.\n self.topo_plane_fit_data[y, x] = param[0]*x + param[1]*y + param[2] # Generate plane value.\n return self.topo_plane_fit_data # Return entire array.","def _prepare_plane(self):\n verticies = [\n # main plane - note that the mainplane is scaled so the mat_plane\n # matrix will it transform to the correct coordinates\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n\n # coord plane\n 0, 0,\n 0, -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], 0,\n 0, 0,\n\n # axes\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\n 0, 0, 0, -self.o_wh[1], #y\n ]\n\n colors = [\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n .9, .9, .9, 9.0, # plot box\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n 0.0, 0.0, 0.0, 1.0, #lines\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n ]\n\n self._fonts = []\n for u in range(1, self._unit_count[0]+1):\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]+0.02)\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]-0.02)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\n (-self.o_wh[1]+(self.i_border[3])*0.5)\n ])\n for u in range(0, self._unit_count[1]):\n verticies.append(0.02)\n verticies.append(-self._unit_w[1]*u)\n verticies.append(-0.02)\n verticies.append(-self._unit_w[1]*u)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\n (0.025)*self._scaling[0],\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\n ])\n\n self._draw_plane_indicies = (0, 12)\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\n\n # convert data into valid data format\n verticies = numpy.array(verticies, dtype=numpy.float32)\n colors = numpy.array(colors, dtype=numpy.float32)\n\n self._plane_vao = util.VAO()\n self._plane_vbo = util.VBO(2)\n\n with self._plane_vao:\n # plane verticies\n with self._plane_vbo.get(0):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(0)\n\n # place vertex colors\n with self._plane_vbo.get(1):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(1)","def project_to_image_plane(self, point_in_world, timestamp):\n\n camera_info = CameraInfo()\n\n fx = self.config['camera_info']['focal_length_x']\n fy = self.config['camera_info']['focal_length_y']\n\n camera_info.width = self.config['camera_info']['image_width']\n camera_info.height = self.config['camera_info']['image_height']\n\n #print(\"fx {}, fy {}\".format(fx, fy))\n\n camera_info.K = np.array([[fx, 0, camera_info.width / 2],\n [0, fy, camera_info.height / 2],\n [0, 0, 1.]], dtype=np.float32)\n camera_info.P = np.array([[fx, 0, camera_info.width / 2, 0],\n [0, fy, camera_info.height / 2, 0],\n [0, 0, 1., 0]])\n camera_info.R = np.array([[1., 0, 0],\n [0, 1., 0],\n [0, 0, 1.]], dtype=np.float32)\n\n camera = PinholeCameraModel()\n camera.fromCameraInfo(camera_info)\n\n #print(\"point_in_world = {}\".format(str(point_in_world)))\n #print(\"camera projection matrix \", camera.P)\n\n # get transform between pose of camera and world frame\n trans = None\n point_in_camera_space = None\n point_in_image = None\n bbox_points_camera_image = []\n\n euler_transforms = (\n math.radians(90), # roll along X to force Y axis 'up'\n math.radians(-90 + -.75), # pitch along Y to force X axis towards 'right', with slight adjustment for camera's 'yaw'\n math.radians(-9) # another roll to orient the camera slightly 'upwards', (camera's 'pitch')\n )\n euler_axes = 'sxyx'\n\n try:\n self.listener.waitForTransform(\"/base_link\",\n \"/world\", timestamp, rospy.Duration(0.1))\n (trans, rot) = self.listener.lookupTransform(\"/base_link\",\n \"/world\", timestamp)\n\n camera_orientation_adj = tf.transformations.quaternion_from_euler(*euler_transforms, axes=euler_axes)\n\n trans_matrix = self.listener.fromTranslationRotation(trans, rot)\n camera_orientation_adj = self.listener.fromTranslationRotation((0, 0, 0), camera_orientation_adj)\n\n #print(\"trans {}, rot {}\".format(trans, rot))\n #print(\"transform matrix {}\".format(trans_matrix))\n\n point = np.array([point_in_world.x, point_in_world.y, point_in_world.z, 1.0])\n\n # this point should match what you'd see from being inside the vehicle looking straight ahead.\n point_in_camera_space = trans_matrix.dot(point)\n\n #print(\"point in camera frame {}\".format(point_in_camera_space))\n\n final_trans_matrix = camera_orientation_adj.dot(trans_matrix)\n\n # this point is from the view point of the camera (oriented along the camera's rotation quaternion)\n point_in_camera_space = final_trans_matrix.dot(point)\n\n #print(\"point in camera frame adj {}\".format(point_in_camera_space))\n\n bbox_points = [(point_in_camera_space[0] - 0.5, point_in_camera_space[1] - 1.1, point_in_camera_space[2], 1.0),\n (point_in_camera_space[0] + 0.5, point_in_camera_space[1] + 1.1, point_in_camera_space[2], 1.0),\n (point_in_camera_space[0] - 0.5, point_in_camera_space[1] - 1.1, point_in_camera_space[2], 1.0),\n (point_in_camera_space[0] + 0.5, point_in_camera_space[1] + 1.1, point_in_camera_space[2], 1.0)]\n\n # these points represent the bounding box within the camera's image\n for p in bbox_points:\n bbox_points_camera_image.append(camera.project3dToPixel(p))\n\n # print(\"point in image {}\".format(bbox_points_camera_image))\n\n except (tf.Exception, tf.LookupException, tf.ConnectivityException):\n rospy.logerr(\"Failed to find camera to map transform\")\n\n return bbox_points_camera_image","def xyplane(draw, r, x, shift = np.array([1000, 1000, 0, 0]), scale = 300):\n extent = 2.8\n pln = np.array(\n [\n [x,-extent,0],\n [x,extent,0],\n [x,extent,extent*2],\n [x,-extent,extent*2]\n ]\n )\n pln = np.dot(pln,np.transpose(r))\n pln = pln * scale + shift[:3]\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))","def project_plane_to_2d(xyz_arr, img, center, dist_thresh):\n\tplane_img = np.zeros(img.size)\n\tplane_img[xyz_arr[:, 2] > dist_thresh + center[2]] = 1\n\n\tplane_img = np.uint8(np.reshape(plane_img, (424, 512)) * 255) # reshape to match depth data and convert to uint8\n\tplane_img = np.uint8(\n\t\t(np.ones((424, 512)) * 255) - plane_img) # invert img so pixel value corresponds to NOT ground plane\n\tret, plane_img = cv2.threshold(plane_img, 0, 255,\n\t\t\t\t\t\t\t\t cv2.THRESH_BINARY) # filter points that are probaly not ground plane\n\tplane_img = cv2.subtract(img, plane_img)\n\treturn plane_img","def uvmap(self, p):\n # bottom left corner of the plane\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\n dif_vector = p - p00\n u = np.dot(dif_vector, self.n0) / self.sx\n v = np.dot(dif_vector, self.n1) / self.sy\n return u, v","def load_plane(image):\n pixels = image.getPrimaryPixels()\n return pixels.getPlane(0, 0, 0)","def verify_plane_endpoints(self):\n return [self.x0 + self.nx * self.dx, self.y0 + self.ny * self.dy, self.z0 + self.nz * self.dz]","def rotate_to_xz_plane(self, point):\n if len(point) == 2:\n x, z = point\n else:\n x, y, z = point\n if y != 0.0:\n x = np.sqrt(x**2 + y**2)\n return abs(x), z","def fit_to_plane(pts):\n # Compute x_mean, y_mean, z_mean\n \n n = len(pts)\n \n x_total = 0\n y_total = 0\n z_total = 0\n\n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_mean = x_total * 1.0 / n\n y_mean = y_total * 1.0 / n\n z_mean = z_total * 1.0 / n\n\n # Compute the p[i] = [x[i]-x_mean,y[i]-y.mean,z[i]-z.mean]\n p = []\n for i in range(n):\n p1 = pts[i][0] - x_mean\n p2 = pts[i][1] - y_mean\n p3 = pts[i][2] - z_mean\n p.append([p1, p2, p3])\n \n # Compute the matrix A\n a1 = 0\n a2 = 0\n a3 = 0\n a4 = 0\n a5 = 0\n a6 = 0\n for i in range(n):\n a1 += p[i][0] * p[i][0]\n a2 += p[i][0] * p[i][1]\n a3 += p[i][0] * p[i][2]\n a4 += p[i][1] * p[i][1]\n a5 += p[i][1] * p[i][2]\n a6 += p[i][2] * p[i][2]\n\n A = np.array([[a1, a2, a3], [a2, a4, a5], [a3, a5, a6]])\n\n # Compute the smallest eigen value and accordingly eigen vector of A\n w, v = np.linalg.eigh(A)\n\n # The minimal eigenvalue is w[0]\n eig = w[0]\n\n # The norm is eigenvector v[:,0]\n norm = v[:,0].tolist()\n d = -norm[0] * x_mean - norm[1] * y_mean - norm[2] * z_mean\n\n return norm, d","def fit_to_plane(pts):\n # Compute x_mean, y_mean, z_mean\n \n n = len(pts)\n \n x_total = 0\n y_total = 0\n z_total = 0\n\n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_mean = x_total * 1.0 / n\n y_mean = y_total * 1.0 / n\n z_mean = z_total * 1.0 / n\n\n # Compute the p[i] = [x[i]-x_mean,y[i]-y.mean,z[i]-z.mean]\n p = []\n for i in range(n):\n p1 = pts[i][0] - x_mean\n p2 = pts[i][1] - y_mean\n p3 = pts[i][2] - z_mean\n p.append([p1, p2, p3])\n \n # Compute the matrix A\n a1 = 0\n a2 = 0\n a3 = 0\n a4 = 0\n a5 = 0\n a6 = 0\n for i in range(n):\n a1 += p[i][0] * p[i][0]\n a2 += p[i][0] * p[i][1]\n a3 += p[i][0] * p[i][2]\n a4 += p[i][1] * p[i][1]\n a5 += p[i][1] * p[i][2]\n a6 += p[i][2] * p[i][2]\n\n A = np.array([[a1, a2, a3], [a2, a4, a5], [a3, a5, a6]])\n\n # Compute the smallest eigen value and accordingly eigen vector of A\n w, v = np.linalg.eigh(A)\n\n # The minimal eigenvalue is w[0]\n eig = w[0]\n\n # The norm is eigenvector v[:,0]\n norm = v[:,0].tolist()\n d = -norm[0] * x_mean - norm[1] * y_mean - norm[2] * z_mean\n\n return norm, d","def fit_plane_to_point_cloud(pc: np.ndarray) -> Tuple[Any, Any, Any, Any]:\n center = pc.sum(axis=0) / pc.shape[0]\n u, s, vh = np.linalg.svd(pc - center)\n\n # Get the unitary normal vector\n u_norm = vh[2, :]\n d = -np.dot(u_norm, center)\n a, b, c = u_norm\n return a, b, c, d","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts) \n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def fourPointTransform(image, points):\r\n\r\n topLeft, topRight, bottomLeft, bottomRight = sortFourPoints(points)\r\n\r\n # Determine the maximum width\r\n topWidth = np.sqrt(((topRight[0] - topLeft[0]) ** 2) + ((topRight[1] - topLeft[1]) ** 2))\r\n bottomWidth = np.sqrt(((bottomRight[0] - bottomLeft[0]) ** 2) + ((bottomRight[1] - bottomLeft[1]) ** 2))\r\n width = max(int(topWidth), int(bottomWidth))\r\n\r\n # Determine the maximum height\r\n leftHeight = np.sqrt(((topLeft[0] - bottomLeft[0]) ** 2) + ((topLeft[1] - bottomLeft[1]) ** 2))\r\n rightHeight = np.sqrt(((topRight[0] - bottomRight[0]) ** 2) + ((topRight[1] - bottomRight[1]) ** 2))\r\n height = max(int(leftHeight), int(rightHeight))\r\n\r\n source = np.array([topLeft, topRight, bottomRight, bottomLeft], dtype=\"float32\")\r\n\r\n destination = np.array([[0, 0],\r\n [width - 1, 0],\r\n [width - 1, height - 1],\r\n [0, height - 1]], dtype=\"float32\")\r\n\r\n transformMatrix = cv2.getPerspectiveTransform(source, destination)\r\n\r\n return cv2.warpPerspective(image, transformMatrix, (width, height))","def homogenous_transformation(x,y):\n y_start = 0.3\n y_stop = 1\n src = np.float32([[0.45,y_start],[0.55, y_start],[0.1,y_stop],[0.9, y_stop]])\n dst = np.float32([[0.45, y_start],[0.55, y_start],[0.45, y_stop],[0.55,y_stop]])\n M_inv = cv2.getPerspectiveTransform(dst,src)\n \n ones = np.ones((1,len(y)))\n coordinates = np.vstack((x, y, ones))\n trans = np.matmul(M_inv, coordinates)\n \n x_vals = trans[0,:]/trans[2,:]\n y_vals = trans[1,:]/trans[2,:]\n return x_vals, y_vals","def plane(self):\n return Plane(Point(0, self.evaluations.exposedWing.edges[2].point1.y, 0), Vector(0, 1, 0),\n hidden=True)","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts)\n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def get_plane(self, scalar, plane, pval):\n\n if plane == 'yz' or plane == 'zy':\n # z along rows, y along columns\n return scalar[:, pval, :]\n elif plane == 'xz' or plane == 'zx':\n # x along columns, z along rows\n return scalar[:, :, pval]\n elif plane == 'xy' or plane == 'yx':\n # x along rows, y along columns\n return scalar[pval, :, :]","def test_CoordinatePlane(self):\n origin = np.random.randn(3)\n normal = np.random.randn(3)\n up_vector = np.random.randn(3)\n plane = shapes_nd.Plane(origin, normal)\n cplane = shapes_3d.CoordinatePlane(origin, normal, up_vector)\n \n np.testing.assert_almost_equal(cplane.dim, plane.dim)\n np.testing.assert_almost_equal(cplane.origin, plane.origin)\n np.testing.assert_almost_equal(cplane.normal, plane.normal)\n \n p3 = [0, 1, 0]\n c, d = cplane.project_point(p3, ret_dist=True)\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))\n p3 = np.random.randn(5, 3)\n c, d = cplane.project_point(p3, ret_dist=True)\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))","def project_onto_plane(self,z):\n U=self.U\n Q=self.Q_p\n #print(((z-Q[-2,:,[2]])/P[-2,:,[2]]).T)\n #print(P[-2])\n return ((z-Q[-2,:,[2]])/U[-2,:,[2]]).T*U[-2]+Q[-2]","def point_to_parameter(self, pt):\n uv = ShapeAnalysis_Surface(self.surface()).ValueOfUV(\n gp_Pnt(pt[0], pt[1], pt[2]), 1e-9\n )\n return np.array(uv.Coord())","def four_point_transform(image, pts):\n\n\tmax_x, max_y = np.max(pts[:, 0]).astype(np.int32), np.max(pts[:, 1]).astype(np.int32)\n\n\tdst = np.array([\n\t\t[0, 0],\n\t\t[image.shape[1] - 1, 0],\n\t\t[image.shape[1] - 1, image.shape[0] - 1],\n\t\t[0, image.shape[0] - 1]], dtype=\"float32\")\n\n\twarped = cv2.warpPerspective(image, cv2.getPerspectiveTransform(dst, pts), (max_x, max_y))\n\n\treturn warped","def plane_from_multiple_points(pnts: Iterable[Point]) -> Plane:\n n = len(pnts)\n x = [pnt.x for pnt in pnts]\n y = [pnt.y for pnt in pnts]\n z = [pnt.z for pnt in pnts]\n pntc = Point(sum(x)/n, sum(y)/n, sum(z)/n)\n x = [pnt.x-pntc.x for pnt in pnts]\n y = [pnt.y-pntc.y for pnt in pnts]\n z = [pnt.z-pntc.z for pnt in pnts]\n sxx = sum([x[i]**2 for i in range(n)])\n sxy = sum([x[i]*y[i] for i in range(n)])\n sxz = sum([x[i]*z[i] for i in range(n)])\n syy = sum([y[i]**2 for i in range(n)])\n syz = sum([y[i]*z[i] for i in range(n)])\n d = sxx*syy-sxy**2\n a = (syz*sxy-sxz*syy)/d\n b = (sxy*sxz-sxx*syz)/d\n nrm = Vector(a, b, 1.0)\n return Plane(pntc, nrm)","def projectPoint(self,p):\n a,b,c = self.a, self.b, self.c\n x,y = p\n return numpy.array( [ b*(x*b-y*a) - c*a, a*(y*a-x*b) - c*b ] )","def transform_perspective(self, pt_x, pt_y):\n linear_y = pt_y * self.perspective_point_y / self.height\n\n diff_x = pt_x - self.perspective_point_x\n diff_y = self.perspective_point_y - linear_y\n factor_y = diff_y / self.perspective_point_y\n # factor_y = factor_y * factor_y\n factor_y = pow(factor_y, 2) # pow = mise au carre\n\n transfor_x = self.perspective_point_x + diff_x * factor_y\n transfor_y = self.perspective_point_y - factor_y * self.perspective_point_y\n\n return int(transfor_x), int(transfor_y)","def mirror_point_to_plane(point, plane):\n assert isinstance(plane, cg3d_plane.CGPlane)\n pn, norm = plane.get_point_and_normal()\n norm.normalize()\n return point - 2.0 * ((point - pn) * norm) * norm","def _point_scale2img(points, _H, _W):\n # with tf.variable_scope(\"_point_scale2img\", reuse=False):\n points = points * tf.constant([_H - 1, _W - 1], \"float32\")\n return points","def PlaneSubtraction(data, direction='xy', xdim=20, ydim=20):\n img = 1*data\n dy, dx = img.shape\n x = np.linspace(0, xdim, dx)\n y = np.linspace(0, ydim, dy)\n DX, DY = np.meshgrid(x, y)\n PX = []\n PY = []\n\n for i, j in zip(np.arange(dy), np.arange(dx)):\n lx = img[i]\n ly = img[:, j]\n maskx = np.isnan(lx)\n masky = np.isnan(ly)\n\n if len(lx[maskx]) < len(lx):\n s = np.polyfit(x[~maskx], lx[~maskx], 1)\n PX.append(s)\n\n if len(ly[masky]) < len(ly):\n s = np.polyfit(y[~masky], ly[~masky], 1)\n PY.append(s)\n\n px = np.nanmean(PX, axis=0)\n py = np.nanmean(PY, axis=0)\n print(\"x - slope: %.2e, y - slope: %.2e\" % (px[0], py[0]))\n print(\"calculate planes\")\n xplane = np.polyval(px, DX)\n yplane = np.polyval(py, DY)\n\n if direction == 'x':\n print('x plane subtraction')\n correction = xplane\n elif direction == 'y':\n print('y plane subtraction')\n correction = yplane\n else:\n print('x-y plane subtraction')\n correction = xplane + yplane\n\n corrected = data - correction\n corrected -= np.nanmin(corrected)\n return corrected","def plot_plane(unit_normal, x_array, y_array, fore):\n # print'unit normal = ', unit_normal\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\n # print 'plane numbers\\n', z\n return z","def xyFromROI(aROIPoints):\n pt1 = aROIPoints[0]\n pt2 = aROIPoints[1]\n x0, y0 = pt1\n x1, y1 = pt2\n return x0, y0, x1, y1","def _generate_random_points_in_plane(nvect, dparam, npts, eps=0.0):\n np.random.seed(12345)\n a, b, c = nvect / np.linalg.norm(nvect)\n x, y = np.random.rand(npts), np.random.rand(npts)\n z = (dparam - a * x - b * y) / c\n if eps > 0:\n z += np.random.normal(loc=0., scale=eps, size=npts)\n return np.column_stack((x, y, z))","def GetPlane(plane):\r\n pass","def get_plane_of_points(\n self,\n normal_vector=\"z\",\n planar_coordinate=None,\n ):\n # Get results vectors\n if (normal_vector == \"z\"):\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\n else:\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\n\n # Create a df of these\n if normal_vector == \"z\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": y_flat,\n \"x3\": z_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"x\":\n df = pd.DataFrame(\n {\n \"x1\": y_flat,\n \"x2\": z_flat,\n \"x3\": x_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"y\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": z_flat,\n \"x3\": y_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n\n # Subset to plane\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\n if planar_coordinate is not None:\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\n\n # Drop duplicates\n # TODO is this still needed now that we setup a grid for just this plane?\n df = df.drop_duplicates()\n\n # Sort values of df to make sure plotting is acceptable\n df = df.sort_values([\"x2\", \"x1\"]).reset_index(drop=True)\n\n return df","def photons(self, depth=1):\n self.dx[:,:self.W-1] = self.z[:,1:] - self.z[:,:self.W-1]\n self.dy[:self.H-1,:] = self.z[1:,:] - self.z[:self.H-1,:]\n px = self.xv - self.dx*depth\n py = self.yv - self.dy*depth\n return px,py","def obtain_points(self):\n # Swapaxes makes the output a column rather than a row\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"GridCoordinates\"][\"CoordinateX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"GridCoordinates\"][\"CoordinateY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"GridCoordinates\"][\"CoordinateZ\"][\" data\"][:, :, :])]), 0, 1)","def get_transformable_plane(self, x_range = None, y_range = None):\n plane_config = dict(self.plane_config)\n shift_val = ORIGIN\n if x_range is not None:\n x_min, x_max = x_range\n plane_config[\"x_radius\"] = x_max - x_min\n shift_val += (x_max+x_min)*RIGHT/2.\n if y_range is not None:\n y_min, y_max = y_range\n plane_config[\"y_radius\"] = y_max - y_min\n shift_val += (y_max+y_min)*UP/2.\n plane = ComplexPlane(**plane_config)\n plane.shift(shift_val)\n if self.use_multicolored_plane:\n self.paint_plane(plane)\n return plane","def _convert_image_to_coordinates(self, vect) -> np.ndarray:\n xdim = vect.shape[0]\n ydim = vect.shape[1]\n\n # stride is used during averaging and length adjustment\n stride_x, stride_y = self._averaging, self._averaging\n\n # create empty vector of necessary shape\n # every \"pixel\" has 2 coordinates\n pos = np.empty((2 * xdim * ydim, 2), dtype=np.float32)\n\n # create coordinate spacing for x-y\n # double the num of elements by doubling x sampling\n xspace = np.linspace(0, stride_x*xdim, 2 * xdim, endpoint=False)\n yspace = np.linspace(0, stride_y*ydim, ydim, endpoint=False)\n xv, yv = np.meshgrid(xspace, yspace)\n\n # assign coordinates (pos) to all pixels\n pos[:, 0] = xv.flatten()\n pos[:, 1] = yv.flatten()\n\n # pixel midpoints are the first x-values of positions\n midpt = np.zeros((xdim * ydim, 2), dtype=np.float32)\n midpt[:, 0] = pos[0::2, 0]+(stride_x-1)/2\n midpt[:, 1] = pos[0::2, 1]+(stride_y-1)/2\n\n # rotate coordinates about midpoint to represent angle and length\n pos[0::2, 0] = midpt[:, 0] - (stride_x / 2) * (self._length/2) * \\\n vect.reshape((xdim*ydim, 2))[:, 0]\n pos[0::2, 1] = midpt[:, 1] - (stride_y / 2) * (self._length/2) * \\\n vect.reshape((xdim*ydim, 2))[:, 1]\n pos[1::2, 0] = midpt[:, 0] + (stride_x / 2) * (self._length/2) * \\\n vect.reshape((xdim*ydim, 2))[:, 0]\n pos[1::2, 1] = midpt[:, 1] + (stride_y / 2) * (self._length/2) * \\\n vect.reshape((xdim*ydim, 2))[:, 1]\n\n return pos","def pixel2coords(self, x, y):\n xoff, a, b, yoff, d, e = self.geotransform()\n\n xp = a * x + b * y + xoff\n yp = d * x + e * y + yoff\n return (xp, yp)","def pixel2coord(self, x, y):\n # NEED TO CHANGE TO USE INVERSE TRANSFORM COEFFS\n # partly taken from Sean Gillies \"affine.py\"\n a,b,c,d,e,f = self.coordspace_transform\n det = a*e - b*d\n idet = 1 / float(det)\n ra = e * idet\n rb = -b * idet\n rd = -d * idet\n re = a * idet\n newx = (x*ra + y*rb + (-c*ra - f*rb) )\n newy = (x*rd + y*re + (-c*rd - f*re) )\n return newx,newy","def get_2d_points(image, rotation_vector, translation_vector, camera_matrix, val):\n point_3d = []\n dist_coeffs = np.zeros((4,1))\n rear_size = val[0]\n rear_depth = val[1]\n point_3d.append((-rear_size, -rear_size, rear_depth))\n point_3d.append((-rear_size, rear_size, rear_depth))\n point_3d.append((rear_size, rear_size, rear_depth))\n point_3d.append((rear_size, -rear_size, rear_depth))\n point_3d.append((-rear_size, -rear_size, rear_depth))\n \n front_size = val[2]\n front_depth = val[3]\n point_3d.append((-front_size, -front_size, front_depth))\n point_3d.append((-front_size, front_size, front_depth))\n point_3d.append((front_size, front_size, front_depth))\n point_3d.append((front_size, -front_size, front_depth))\n point_3d.append((-front_size, -front_size, front_depth))\n point_3d = np.array(point_3d, dtype=np.float).reshape(-1, 3)\n \n # Map to 2D image points\n (point_2d, _) = cv2.projectPoints(point_3d,rotation_vector,translation_vector,camera_matrix,dist_coeffs)\n point_2d = np.int32(point_2d.reshape(-1, 2))\n return point_2d","def projective_transform(self, x):\n\n x = np.asarray(x)\n # Assume no intensity column\n x0, y0, z0 = x\n\n # Camera coors to pixel coors\n u = ((x0 / z0) * self.f) + (self.sensor_size[0] // 2)\n v = ((y0 / z0) * self.f) + (self.sensor_size[1] // 2)\n\n u_min = np.min(u)\n v_min = np.min(v)\n\n n = len(u)\n u_list = []\n v_list = []\n if self.error_on_oob:\n for i in range(n):\n if (u[i] >= u_min and u[i] <= self.sensor_size[0] and v[i] >= v_min and v[i] <= self.sensor_size[1]):\n u_list.append(u[i])\n v_list.append(v[i])\n else:\n raise OutOfSensorBoundsError(\"Projected coordinate was outside the sensor\")\n else:\n for i in range(n):\n u_list.append(u[i])\n v_list.append(v[i])\n\n u = np.asarray(u_list)\n v = np.asarray(v_list)\n\n return np.vstack((u, v))","def four_point_transform(self, image, pts):\n rect = []\n for j in range(4):\n rect.append([pts[j * 2], pts[j * 2 + 1]])\n\n rect = np.array(rect, dtype=\"float32\")\n (tl, tr, br, bl) = rect\n # compute the width of the new image, which will be the\n # maximum distance between bottom-right and bottom-left\n # x-coordiates or the top-right and top-left x-coordinates\n widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))\n widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))\n maxWidth = max(int(widthA), int(widthB))\n # compute the height of the new image, which will be the\n # maximum distance between the top-right and bottom-right\n # y-coordinates or the top-left and bottom-left y-coordinates\n heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))\n heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))\n maxHeight = max(int(heightA), int(heightB))\n # now that we have the dimensions of the new image, construct\n # the set of destination points to obtain a \"birds eye view\",\n # (i.e. top-down view) of the image, again specifying points\n # in the top-left, top-right, bottom-right, and bottom-left\n # order\n dst = np.array([\n [0, 0],\n [maxWidth - 1, 0],\n [maxWidth - 1, maxHeight - 1],\n [0, maxHeight - 1]], dtype=\"float32\")\n # compute the perspective transform matrix and then apply it\n M = cv2.getPerspectiveTransform(rect, dst)\n warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))\n # return the warped image\n return warped","def proyZm1(u, v, t1):\n den = u ** 2 + v ** 2 + 4\n x = u - t1 * (u - 4 * u / den)\n y = v - t1 * (v - 4 * v / den)\n z = -1 - t1 * (-2 + 8 / den)\n return (x, y, z)","def transform_point(p,R,t):\r\n x = R[0][0]*p[0]+R[0][1]*p[1]+t[0]\r\n y = R[1][0]*p[0]+R[1][1]*p[1]+t[1]\r\n return [x,y]","def _image_to_point_space(pixel_coordinates: np.array, boundary_radius: int, resolution: int) -> np.array:\n pix_origin = np.array([resolution / 2, resolution / 2])\n return np.array((pixel_coordinates - pix_origin) * (2 * boundary_radius) / resolution)","def project(points, camera_params, theta):\n \"\"\"\n Function takes input of 3d_points, transformations and Convert 3-D points to 2-D by projecting onto images. \n Input:\n points: 3D points in world frame\n camera_params: parameters of camera corrosponding to the point\n theta: Needed For PAL camera to specify the sub camera index for the points\n Output:\n points_proj: 2D reprojected points for 3D points \n\n \"\"\"\n # Convert the 3D points to Camera Frame by rotaion followes by translation\n points_proj1 = rotate(points[:,0:3], camera_params[:, :3])\n points_proj1 += camera_params[:, 3:6]\n # FOR PAL: Converting into the Sub-camera Frame by respective rotation\n thetas = theta * np.pi / 3 \n points_proj = np.copy(points_proj1)\n points_proj[:,0] = points_proj1[:,0]*np.cos(thetas) - points_proj1[:,2]*np.sin(thetas)\n points_proj[:,2] = points_proj1[:,0]*np.sin(thetas) + points_proj1[:,2]*np.cos(thetas)\n # Avoiding Zero error\n for i in range(len(points_proj)):\n if(points_proj[i,2]==0):\n points_proj[i,0] = 0\n points_proj[i,1] = 0\n points_proj[i,2] = 1\n # 2D projection\n points_proj = points_proj[:, :2] / points_proj[:, 2, np.newaxis]\n f = camera_params[:, 6]\n k1 = camera_params[:, 7]\n k2 = camera_params[:, 8]\n n = np.sum(points_proj**2, axis=1)\n r = 1 + k1 * n + k2 * n**2\n points_proj *= (r * f)[:, np.newaxis]\n return points_proj","def project_points(X, K, R, T, distortion_flag=False, distortion_params=None):\n # Project points from 3d world coordinates to 2d image coordinates\n\n #get projection matrix\n pmatrix = projection_matrix(R, T, K)\n\n #add 4th component to points\n ones = np.ones([1,len(X[0])])\n xones=np.row_stack((X,ones))\n\n #calculate pixel coordinates\n X_camera = pmatrix.dot(xones)\n\n return X_camera","def derive(params):\n x, y, dx, dy = params\n r = (x ** 2 + y ** 2) ** 0.5\n return np.array([dx, dy, -G * M * x / (r ** 3), -G * M * y / (r ** 3)])","def pose_2d_pts(self,image):\n '''\n image- rgb image \n return:-\n pts - list of 2d pose landmarks as img coords\n image- rgb image on which the 2d pose landmarks are drawn\n ''' \n pts=[]\n imgRGB=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\n results=pose.process(imgRGB)\n if results.pose_landmarks:\n mpDraw.draw_landmarks(image,results.pose_landmarks,mpPose.POSE_CONNECTIONS)\n for id,lm in enumerate(results.pose_landmarks.landmark):\n h,w,c=image.shape\n imgx,imgy=int(lm.x*w),int(lm.y*h)\n \n pts.append((imgx,imgy)) \n return pts,image","def get_points(self):\r\n return self.nx*self.ny*self.nz","def project_3d_points_to_plane(points, p1, p2 ,p3, numpoints):\n p1 = np.asarray(p1)\n p2 = np.asarray(p2)\n p3 = np.asarray(p3)\n\n # get vectors in plane\n v1 = p3 - p1\n v2 = p2 - p1\n\n # compute cross product\n cp = np.cross(v1, v2)\n a, b, c = cp # normal to plane is ax + by + cz\n\n # evaluate d\n d = np.dot(cp, p3)\n\n # thus, normal is given by\n plane = vtk.vtkPlane()\n origin = p1\n normal = normalize(np.array([a,b,c]))\n plane.SetOrigin(p1)\n plane.SetNormal(normal)\n\n if numpoints == 1:\n proj = [0,0,0]\n plane.ProjectPoint(points, origin, normal, proj)\n return proj\n else:\n projected_pts = np.zeros((numpoints, 3), dtype=float)\n\n for i in range(numpoints):\n proj = [0,0,0]\n plane.ProjectPoint(points[i], origin, normal, proj)\n projected_pts[i] = proj\n\n return projected_pts","def camera_pixels_to_camera_coords(left_pt, right_pt, nparrays=False):\n assert len(left_pt) == len(right_pt) == 2\n disparity = np.linalg.norm( np.array(left_pt) - np.array(right_pt) )\n (xx,yy,zz) = STEREO_MODEL.projectPixelTo3d( (left_pt[0],left_pt[1]), disparity )\n if nparrays:\n return np.array([xx,yy,zz])\n else:\n return [xx,yy,zz]","def planes_3d(self, quantity, xplane, yplane):\n xplane = int(xplane)\n yplane = int(yplane)\n # Get the scalar values\n # Get the data on the plane with a fixed x value. These means we'll\n # have changing (y, z) points\n xdata = self.get_plane(quantity, 'yz', xplane)\n # z first cuz we want y to be changing before z to correspond with the\n # way numpy flattens arrays. Note this means y points will be in the\n # 2nd column\n xplanepoints = np.array(list(itertools.product(self.Z, self.Y)))\n xdata = xdata.flatten()\n xplanexval = np.array(list(itertools.repeat(x[xplane], len(xdata))))\n xplanedata = np.zeros((xplanepoints.shape[0], 4))\n xplanedata[:, 0] = xplanexval\n xplanedata[:, 1] = xplanepoints[:, 1]\n xplanedata[:, 2] = xplanepoints[:, 0]\n xplanedata[:, 3] = xdata\n # Same procedure for fixed y plane\n ydata = self.get_plane(quantity, 'xz', yplane)\n yplanepoints = np.array(list(itertools.product(z, x)))\n ydata = ydata.flatten()\n yplaneyval = np.array(list(itertools.repeat(y[yplane], len(ydata))))\n yplanedata = np.zeros((yplanepoints.shape[0], 4))\n yplanedata[:, 0] = yplanepoints[:, 1]\n yplanedata[:, 1] = yplaneyval\n yplanedata[:, 2] = yplanepoints[:, 0]\n yplanedata[:, 3] = ydata\n labels = ('X [um]', 'Y [um]', 'Z [um]', quantity)\n # Now stack them vertically and plot!\n all_data = np.vstack((xplanedata, yplanedata))\n self.scatter3d(all_data[:, 0], all_data[:, 1], all_data[:, 2],\n all_data[:, 3], labels, 'planes_3d')","def projectToImage(pts_3D, P):\n pts_3D = np.reshape(pts_3D, (-1, 3))\n pts_3D = np.transpose(pts_3D)\n pts_3D = np.vstack([pts_3D, 1])\n pts_2D = np.matmul(P, pts_3D)\n pts_2D = pts_2D[:2]/pts_2D[-1]\n pts_2D = np.transpose(pts_2D)\n return pts_2D","def get_point_coords_wrt_image(boxes, point_coords):\n # with tf.variable_scope(\"get_point_coords_wrt_image\", reuse=False):\n boxes = tf.stop_gradient(boxes)\n point_coords = tf.stop_gradient(point_coords)\n h = boxes[:, None, 2] - boxes[:, None, 0]\n w = boxes[:, None, 3] - boxes[:, None, 1]\n y1 = boxes[:, None, 0]\n x1 = boxes[:, None, 1]\n scale = tf.stack([h, w], axis=-1)\n trans = tf.stack([y1, x1], axis=-1)\n point_coords = point_coords * scale\n point_coords = point_coords + trans\n return point_coords","def create_point_cloud(self):\n pixels = []\n colors = []\n my_pixels = []\n for j in range(self.height):\n for i in range(self.width):\n depth = self.depth[j, i]\n pixels.append(\n [i * depth, j * depth, depth]\n )\n my_pixels.append(\n [i, j, 1]\n )\n # make rgb with flip()\n colors.append(np.flip(self.bgr[j, i, :]))\n # colors.append(self.bgr[j, i, :])\n self.my_pixels = my_pixels\n pixels = np.array(pixels)\n\n # project pixels to camera space\n self.xyz_points = self.intrinsics_inv @ np.transpose(pixels)\n self.color_points = colors\n\n # now add 1s to the points for homogenous coordinates\n num_points = self.get_num_xyz_points()\n ones = np.ones((1, num_points))\n self.xyzw_points = np.concatenate((self.xyz_points, ones), axis=0)\n\n self.scene = None\n self.camera_pose = None\n self.nm = None\n self.nl = None\n self.nc = None\n self.create_mesh()","def get_point(self, params):\n spm = self.spm\n cpoint = self.current_point\n x = params.get('X',cpoint[0])\n y = params.get('Y',cpoint[1])\n z = params.get('Z',cpoint[2])\n a = cpoint[3]\n b = cpoint[4]\n if 'E' in params:\n a = params.get('E',cpoint[3])\n elif 'A' in params:\n a = params.get('A',cpoint[3])\n elif 'B' in params:\n b = params.get('B',cpoint[4])\n point = [x,y,z,a,b]\n return point","def plane_from_points(a, b, c):\n ab = subtract_vectors(b, a)\n ac = subtract_vectors(c, a)\n n = normalize_vector(cross_vectors(ab, ac))\n return a, n","def make_coordinates(image, line_params):\n slope, intercept = line_params\n y1 = image.shape[0]\n y2 = int(y1 * (3/5))\n x1 = int((y1 - intercept)/ slope)\n x2 = int((y2 - intercept)/ slope)\n return np.array([x1, y1, x2, y2])","def project(points, camera_params):\n # print(camera_params.shape)\n points_proj = rotate(points, camera_params[:, :3])\n points_proj += camera_params[:, 3:6]\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\n f = 2360*np.ones(camera_params.shape[0])\n # np.ones()\n # n = np.sum(points_proj**2, axis=1)\n r = 1\n points_proj *= (r * f)[:, np.newaxis]\n return points_proj","def get_perspective_transform(points_src: Tensor, points_dst: Tensor) -> Tensor:\n KORNIA_CHECK_SHAPE(points_src, [\"B\", \"4\", \"2\"])\n KORNIA_CHECK_SHAPE(points_dst, [\"B\", \"4\", \"2\"])\n KORNIA_CHECK(points_src.shape == points_dst.shape, \"Source data shape must match Destination data shape.\")\n KORNIA_CHECK(points_src.dtype == points_dst.dtype, \"Source data type must match Destination data type.\")\n\n # we build matrix A by using only 4 point correspondence. The linear\n # system is solved with the least square method, so here\n # we could even pass more correspondence\n\n # create the lhs tensor with shape # Bx8x8\n B: int = points_src.shape[0] # batch_size\n\n A = torch.empty(B, 8, 8, device=points_src.device, dtype=points_src.dtype)\n\n # we need to perform in batch\n _zeros = zeros(B, device=points_src.device, dtype=points_src.dtype)\n _ones = torch.ones(B, device=points_src.device, dtype=points_src.dtype)\n\n for i in range(4):\n x1, y1 = points_src[..., i, 0], points_src[..., i, 1] # Bx4\n x2, y2 = points_dst[..., i, 0], points_dst[..., i, 1] # Bx4\n\n A[:, 2 * i] = stack([x1, y1, _ones, _zeros, _zeros, _zeros, -x1 * x2, -y1 * x2], -1)\n A[:, 2 * i + 1] = stack([_zeros, _zeros, _zeros, x1, y1, _ones, -x1 * y2, -y1 * y2], -1)\n\n # the rhs tensor\n b = points_dst.view(-1, 8, 1)\n\n # solve the system Ax = b\n X: Tensor = _torch_solve_cast(A, b)\n\n # create variable to return the Bx3x3 transform\n M = torch.empty(B, 9, device=points_src.device, dtype=points_src.dtype)\n M[..., :8] = X[..., 0] # Bx8\n M[..., -1].fill_(1)\n\n return M.view(-1, 3, 3) # Bx3x3","def pos2im_coordinates(x, z):\n # x_lim = [-0.85, 0.86]\n # z_lim = [-1.22, 0.47]\n x_lim = [-0.365, 0.365]\n z_lim = [-0.95, -0.24]\n\n pix_x = int(127 * (x_lim[1] - x) / (x_lim[1] - x_lim[0]))\n pix_z = int(127 * (z_lim[1] - z) / (z_lim[1] - z_lim[0]))\n return pix_x, pix_z","def kinect_transform(self, x, y, z):\n xposition = x\n yposition = y\n zposition = z\n\n return zposition, xposition, yposition","def four_point_transform(image, pts):\n rect = order_points(pts)\n width_first = np.sqrt(\n ((rect[2][0] - rect[3][0]) ** 2) + ((rect[2][1] - rect[3][1]) ** 2)\n )\n width_second = np.sqrt(\n ((rect[1][0] - rect[0][0]) ** 2) + ((rect[1][1] - rect[0][1]) ** 2)\n )\n max_width = max(int(width_first), int(width_second))\n height_first = np.sqrt(\n ((rect[1][0] - rect[2][0]) ** 2) + ((rect[1][1] - rect[2][1]) ** 2)\n )\n height_second = np.sqrt(\n ((rect[0][0] - rect[3][0]) ** 2) + ((rect[0][1] - rect[3][1]) ** 2)\n )\n max_height = max(int(height_first), int(height_second))\n dst = np.array(\n [\n [0, 0],\n [max_width - 1, 0],\n [max_width - 1, max_height - 1],\n [0, max_height - 1],\n ],\n dtype=\"float32\",\n )\n view_transform = cv2.getPerspectiveTransform(rect, dst)\n warped = cv2.warpPerspective(image, view_transform, (max_width, max_height))\n return warped","def fit_plane_to_points(points: np.ndarray, eps: float=1.0e-5):\n # Compute plane origin and subract it from the points array.\n plane_origin = np.mean(points, axis=0)\n x = points - plane_origin\n\n # Dot product to yield a 3x3 array.\n moment = np.dot(x.T, x)\n\n # Extract single values from SVD computation to get normal.\n plane_normal = np.linalg.svd(moment)[0][:,-1]\n small = np.where(np.abs(plane_normal) < eps)\n plane_normal[small] = 0.0\n plane_normal /= np.linalg.norm(plane_normal)\n if (plane_normal[-1] < 0.0):\n plane_normal *= -1.0\n\n return (plane_normal, plane_origin)","def to_compas(self):\n return Point(self.x, self.y, self.z)","def project(points, camera_params):\n points_proj = rotate(points, camera_params[:, :3])\n points_proj += camera_params[:, 3:6]\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\n f = camera_params[:, 6]\n k1 = camera_params[:, 7]\n k2 = camera_params[:, 8]\n n = np.sum(points_proj ** 2, axis=1)\n r = 1 + k1 * n + k2 * n ** 2\n points_proj *= (r * f)[:, np.newaxis]\n return points_proj","def xzplane(draw, r, y, shift = np.array([1000, 1000, 0, 0]), scale = 300):\n extent = 2.8\n pln = np.array(\n [\n [-extent,y,0],\n [extent,y,0],\n [extent,y,extent*2],\n [-extent,y,extent*2]\n ]\n )\n pln = np.dot(pln, np.transpose(r))\n pln = pln * scale + shift[:3]\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))","def get_projection_point(self, point, plane, test=False):\n return point_on_plane_projection(point, plane, test=test)","def _transform_point(self, x, y):\n return (x, y)","def camera_to_pixel(self, X):\n raise NotImplementedError","def secondorder(self):\n f = self.img\n x = self.x\n y = self.y\n self.x2 = sum(f*x**2)/sum(f) - self.x1**2\n self.y2 = sum(f*y**2)/sum(f) - self.y1**2\n self.xy = sum(f*x*y)/sum(f) - self.x1*self.y1","def calculate_points(self):\n\n v0 = np.vstack(np.sign(self.distance_from_plane[:, 0] *\n self.distance_from_plane[:, 1]))\n v1 = np.vstack(np.sign(self.distance_from_plane[:, 1] *\n self.distance_from_plane[:, 2]))\n v2 = np.vstack(np.sign(self.distance_from_plane[:, 2] *\n self.distance_from_plane[:, 0]))\n\n goes_through = np.concatenate([v0, v1, v2], 1)\n self.num_points = (np.sum(goes_through == 0) * 2 +\n np.sum(goes_through == -1))\n\n self.slice_points = np.zeros((self.num_points, 3))\n curr_point = 0\n\n for i in range(len(goes_through)):\n for x in range(len(goes_through[i])):\n if goes_through[i][x] == -1:\n # The line goes through the plane\n # There is a point which lies in the plane, which is r\n # amounts of vector V away from point P0\n p0 = self.obj.vectors[i][x]\n if x == 0 or x == 1:\n V = self.obj.vectors[i][x]-self.obj.vectors[i][x+1]\n else:\n V = self.obj.vectors[i][x]-self.obj.vectors[i][0]\n d = (np.dot((self.plane_origin-p0), self.plane_normal) /\n (np.dot(V, self.plane_normal)))\n P = p0 + d*V\n self.slice_points[curr_point] = P\n curr_point += 1\n\n if goes_through[i][x] == 0:\n if x == 0 or x == 1:\n self.slice_points[curr_point] = self.obj.vectors[i][x]\n self.slice_points[curr_point+1] = self.obj.vectors[i][x+1]\n else:\n self.slice_points[curr_point] = self.obj.vectors[i][x]\n self.slice_points[curr_point+1] = self.obj.vectors[i][0]\n\n self.slice_points = np.round(self.slice_points, decimals=5)\n self.slice_points = np.unique(self.slice_points, axis=0)\n \n return None","def head_pose_points(image, rotation_vector, translation_vector, camera_matrix):\n rear_size = 1\n rear_depth = 0\n front_size = image.shape[1]\n front_depth = front_size*2\n val = [rear_size, rear_depth, front_size, front_depth]\n point_2d = get_2d_points(image, rotation_vector, translation_vector, camera_matrix, val)\n y = (point_2d[5] + point_2d[8])//2\n x = point_2d[2]\n \n return (x, y)","def convert_coords(x, y, conversion):\n if conversion == \"cartesian\" :\n # convert to cartesian plane coordinates \n x_new = x - (width/2)\n y_new = (height/2) + y \n\n elif conversion == \"pygame\":\n # only needed to place images in pygame\n x_new = x + (width/2)\n y_new = (height/2) - y\n \n return x_new, y_new","def pixel_to_coords(self, x, y):\n rx, ry = self.size\n nx = (x / rx - 0.5) * self.scale + self.center[0]\n ny = ((ry - y) / ry - 0.5) * self.scale + self.center[1]\n nz = self.center[2]\n return [nx, ny, nz]","def get_plane(self, quantity, plane, pval):\n\n self.log.info('Retrieving plane for %s', quantity)\n scalar = self.get_scalar_quantity(quantity)\n if plane == 'yz' or plane == 'zy':\n # z along rows, y along columns\n return scalar[:, pval, :]\n elif plane == 'xz' or plane == 'zx':\n # x along columns, z along rows\n return scalar[:, :, pval]\n elif plane == 'xy' or plane == 'yx':\n # x along rows, y along columns\n return scalar[pval, :, :]","def project(points, camera_params):\n points_proj = rotate(points, camera_params[:, :3])\n points_proj += camera_params[:, 3:6]\n points_proj = points_proj[:, :2] / points_proj[:, 2, np.newaxis]\n f = camera_params[:, 6]\n k1 = camera_params[:, 7]\n k2 = camera_params[:, 8]\n n = np.sum(points_proj ** 2, axis=1)\n r = 1 + k1 * n + k2 * n ** 2\n points_proj *= (r * f)[:, np.newaxis]\n return points_proj","def roi2point(self, msg):\n p = Vector([0,0,0])\n if self.camerainfo.width > 0:\n p.x = 0.5 - (msg.x_offset+(msg.width/2.0))/self.camerainfo.width\n if self.camerainfo.height > 0:\n p.z = 0.5 - (msg.y_offset+(msg.height/2.0))/self.camerainfo.height\n return p","def pyr_point_translator(x, y, org_l, dest_l):\n dest_x = (2.0 ** (org_l - dest_l)) * x\n dest_y = (2.0 ** (org_l - dest_l)) * y\n return np.array([dest_x, dest_y]).transpose()","def convert_depth_frame_to_pointcloud(depth_image, camera_intrinsics ):\r\n\t\r\n\t[height, width] = depth_image.shape\r\n\r\n\tnx = np.linspace(0, width-1, width)\r\n\tny = np.linspace(0, height-1, height)\r\n\tu, v = np.meshgrid(nx, ny)\r\n\tx = (u.flatten() - camera_intrinsics.ppx)/camera_intrinsics.fx\r\n\ty = (v.flatten() - camera_intrinsics.ppy)/camera_intrinsics.fy\r\n\r\n\tz = depth_image.flatten() / 1000;\r\n\tx = np.multiply(x,z)\r\n\ty = np.multiply(y,z)\r\n\r\n\tx = x[np.nonzero(z)]\r\n\ty = y[np.nonzero(z)]\r\n\tz = z[np.nonzero(z)]\r\n\r\n\treturn x, y, z","def perspective_transform():\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\n M = cv2.getPerspectiveTransform(src, dst)\n Minv = cv2.getPerspectiveTransform(dst, src)\n\n return M, Minv"],"string":"[\n \"def project_points_plane(points, plane):\\n return [project_point_plane(point, plane) for point in points]\",\n \"def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\\n # preliminary stuff\\n if origin != None: x = x - origin\\n a,b,c,d = plane\\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\\n px, py, pz = new_x\\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\\n px, py, pz = px/bot, py/bot, pz/bot\\n p0 = [px,py,pz]\\n # do rotation\\n z_hat = [a,b,c]\\n y_hat = cross(z_hat, p0)\\n x_hat = cross(y_hat, z_hat)\\n if type(x)==type(arr) or type(x)==type([]):\\n xp, yp, zp = [], [], []\\n for i in range(len(x)):\\n xp.append(dot([x[i],y[i],z[i]], x_hat))\\n yp.append(dot([x[i],y[i],z[i]], y_hat))\\n zp.append(dot([x[i],y[i],z[i]], z_hat))\\n else:\\n xp = dot([x,y,z], x_hat)\\n yp = dot([x,y,z], y_hat)\\n zp = dot([x,y,z], z_hat)\\n return xp, yp, zp\",\n \"def project_point_plane(point, plane):\\n base, normal = plane\\n normal = normalize_vector(normal)\\n vector = subtract_vectors(point, base)\\n snormal = scale_vector(normal, dot_vectors(vector, normal))\\n return subtract_vectors(point, snormal)\",\n \"def create_plane(self):\\n\\n # First we calculate our point increment for both the x and y values\\n inc_x = (self.xmax - self.xmin)/(self.xlen - 1)\\n inc_y = (self.ymax - self.ymin)/(self.ylen - 1)\\n\\n # This for-loop will add every x-value with every y-value, saving the values column wise\\n # i.e. (-10,-10), (-10,-9), (-10.-8),...,(-10,n) for n = our y-values.\\n # store these combinations into a list, and add that to our plane. \\n # The nested loop will then traverse again and will get the combinations for the next x-value.\\n # The loop will continue until all x-values and y-value combinations are added to our plane.\\n for y in range(0, self.ylen + 1):\\n temp_list = []\\n for x in range(0, self.xlen + 1):\\n temp_list.append(self.f((self.xmin + x*inc_x) + (self.ymin + y*inc_y)*1j))\\n self.plane.append(temp_list)\",\n \"def project_onto_plane(vect):\\n x, y, z = vect\\n \\n return (x, y, 0.)\",\n \"def pointToWorld( nImageX, nImageY, rDepth, rMaxX = 320, rMaxY = 240, rFieldOfViewX = 60, rFieldOfViewY = 40 ):\\n # convert to [-0.5,0.5]\\n rCenteredX = ( nImageX / rMaxX ) - 0.5;\\n rCenteredY = ( nImageY / rMaxY ) - 0.5;\",\n \"def vecteur_image(T,x,y):\\n a,b,c,d = T[0][0],T[0][1],T[1][0],T[1][1]\\n xx = a*x + b*y\\n yy = c*x + d*y\\n return xx,yy\",\n \"def _fit_plane_to_point_cloud(\\n points_xyz: NDArrayFloat,\\n) -> Tuple[float, float, float, float]:\\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\\n points_xyz - center_xyz\\n )\\n vh = out[2]\\n\\n # Get the unitary normal vector\\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\\n d: float = -np.dot([a, b, c], center_xyz)\\n return (a, b, c, d)\",\n \"def two_plane_obj_points(grid_size, dx):\\r\\n objp_xy = np.zeros((grid_size[0]*grid_size[1], 3), np.float32)\\r\\n objp_yz = np.zeros((grid_size[1]*grid_size[2], 3), np.float32)\\r\\n objp_xy[:,:2] = np.mgrid[0:grid_size[0], 0:grid_size[1]].T.reshape(-1, 2)\\r\\n objp_yz[:,1:3] = np.mgrid[0:grid_size[1], 0:grid_size[2]].T.reshape(-1, 2)\\r\\n\\r\\n return objp_xy*dx, objp_yz*dx\",\n \"def invert_points_on_plane(pnts, plane):\\n ptol = Settings.ptol\\n vu = plane.vu.ijk\\n vv = plane.vv.ijk\\n p0 = plane.p0.xyz\\n vu2 = dot(vu, vu)\\n vv2 = dot(vv, vv)\\n\\n pnts = array(pnts, dtype=float64)\\n npts = pnts.shape[0]\\n params = zeros((npts, 2), dtype=float64)\\n for i in range(0, npts):\\n pi = pnts[i]\\n u = dot(pi - p0, vu) / vu2\\n v = dot(pi - p0, vv) / vv2\\n if abs(u) <= ptol:\\n u = 0.\\n if abs(v) <= ptol:\\n v = 0.\\n params[i, :] = [u, v]\\n\\n return params\",\n \"def plane(self):\\n return plane(self.N, self.o)\",\n \"def converte_coord(valor):\\n\\n pts1 = ([0,0],[24,0],[24,44],[0,44])\\n pts1 = np.asarray(pts1, dtype = np.float32)\\n pts2 = np.float32([[0,0],[100,0], [100,100], [0,100]])\\n\\n M = cv.getPerspectiveTransform(pts1,pts2)\\n img2 = cv.warpPerspective(valor,M,(100,100))\\n return img2\",\n \"def point_and_plane_pose(plane_point, plane_orientation, points=None, xyz=None):\\n vector = plane_orientation\\n vector = vector / np.linalg.norm(vector)\\n a = vector[0]\\n b = vector[1]\\n c = vector[2]\\n\\n d = -a * plane_point[0] - b * plane_point[1] - c * plane_point[2]\\n\\n if xyz is not None:\\n xyz = np.asarray(xyz)\\n if points.shape[0] != 3:\\n logger.error(\\n \\\"Wrong points shape. [3, N] expected, \\\" + str(points.shape) + \\\" given.\\\"\\n )\\n elif points is not None:\\n points = np.asarray(points)\\n if points.shape[1] != 3:\\n logger.error(\\n \\\"Wrong points shape. [N, 3] expected, \\\" + str(points.shape) + \\\" given.\\\"\\n )\\n xyz = points.T\\n else:\\n logger.error(\\\"points or xyz must be declared\\\")\\n\\n x, y, z = xyz\\n z_out = (a * x + b * y + c * z + d) / (a ** 2 + b ** 2 + c ** 2) ** 0.5\\n\\n return z_out\",\n \"def plane(self):\\r\\n from lsst.analysis import utils\\r\\n return utils.fitplane(self.points, self.z)\",\n \"def proj_to_plane(norm, d, pts):\\n a = norm[0]\\n b = norm[1]\\n c = norm[2]\\n\\n p = []\\n\\n for i in range(len(pts)):\\n x_p = pts[i][0]\\n y_p = pts[i][1]\\n z_p = pts[i][2]\\n\\n if a != 0:\\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\\n\\n elif b != 0:\\n x_0 = x_p \\n y_0 = c * c * y_p - b * (d + c)\\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\\n\\n else:\\n x_0 = x_p\\n y_0 = y_p\\n z_0 = - d * 1.0 / c\\n\\n p.append([x_0, y_0, z_0])\\n \\n return p\",\n \"def proj_to_plane(norm, d, pts):\\n a = norm[0]\\n b = norm[1]\\n c = norm[2]\\n\\n p = []\\n\\n for i in range(len(pts)):\\n x_p = pts[i][0]\\n y_p = pts[i][1]\\n z_p = pts[i][2]\\n\\n if a != 0:\\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\\n\\n elif b != 0:\\n x_0 = x_p \\n y_0 = c * c * y_p - b * (d + c)\\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\\n\\n else:\\n x_0 = x_p\\n y_0 = y_p\\n z_0 = - d * 1.0 / c\\n\\n p.append([x_0, y_0, z_0])\\n \\n return p\",\n \"def invert_point_on_plane(point, plane):\\n _, _, proj = project_point_to_plane(point, plane)\\n\\n u, v = proj[0][1]\\n return u, v\",\n \"def GetParametricCoords(self):\\n ...\",\n \"def topo_plane_paramEval(self, param):\\n # Create an empty numpy array with the same number as pixels as the real data.\\n self.topo_plane_fit_data = np.zeros((self.y_res, self.x_res))\\n for y in range(0, self.y_res): # Iterate over the y-axis pixels.\\n for x in range(0, self.x_res): # Iterate over the x-axis pixels.\\n self.topo_plane_fit_data[y, x] = param[0]*x + param[1]*y + param[2] # Generate plane value.\\n return self.topo_plane_fit_data # Return entire array.\",\n \"def _prepare_plane(self):\\n verticies = [\\n # main plane - note that the mainplane is scaled so the mat_plane\\n # matrix will it transform to the correct coordinates\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n\\n # coord plane\\n 0, 0,\\n 0, -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], 0,\\n 0, 0,\\n\\n # axes\\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\\n 0, 0, 0, -self.o_wh[1], #y\\n ]\\n\\n colors = [\\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n .9, .9, .9, 9.0, # plot box\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n 0.0, 0.0, 0.0, 1.0, #lines\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n ]\\n\\n self._fonts = []\\n for u in range(1, self._unit_count[0]+1):\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]+0.02)\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]-0.02)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\\n (-self.o_wh[1]+(self.i_border[3])*0.5)\\n ])\\n for u in range(0, self._unit_count[1]):\\n verticies.append(0.02)\\n verticies.append(-self._unit_w[1]*u)\\n verticies.append(-0.02)\\n verticies.append(-self._unit_w[1]*u)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\\n (0.025)*self._scaling[0],\\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\\n ])\\n\\n self._draw_plane_indicies = (0, 12)\\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\\n\\n # convert data into valid data format\\n verticies = numpy.array(verticies, dtype=numpy.float32)\\n colors = numpy.array(colors, dtype=numpy.float32)\\n\\n self._plane_vao = util.VAO()\\n self._plane_vbo = util.VBO(2)\\n\\n with self._plane_vao:\\n # plane verticies\\n with self._plane_vbo.get(0):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(0)\\n\\n # place vertex colors\\n with self._plane_vbo.get(1):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(1)\",\n \"def project_to_image_plane(self, point_in_world, timestamp):\\n\\n camera_info = CameraInfo()\\n\\n fx = self.config['camera_info']['focal_length_x']\\n fy = self.config['camera_info']['focal_length_y']\\n\\n camera_info.width = self.config['camera_info']['image_width']\\n camera_info.height = self.config['camera_info']['image_height']\\n\\n #print(\\\"fx {}, fy {}\\\".format(fx, fy))\\n\\n camera_info.K = np.array([[fx, 0, camera_info.width / 2],\\n [0, fy, camera_info.height / 2],\\n [0, 0, 1.]], dtype=np.float32)\\n camera_info.P = np.array([[fx, 0, camera_info.width / 2, 0],\\n [0, fy, camera_info.height / 2, 0],\\n [0, 0, 1., 0]])\\n camera_info.R = np.array([[1., 0, 0],\\n [0, 1., 0],\\n [0, 0, 1.]], dtype=np.float32)\\n\\n camera = PinholeCameraModel()\\n camera.fromCameraInfo(camera_info)\\n\\n #print(\\\"point_in_world = {}\\\".format(str(point_in_world)))\\n #print(\\\"camera projection matrix \\\", camera.P)\\n\\n # get transform between pose of camera and world frame\\n trans = None\\n point_in_camera_space = None\\n point_in_image = None\\n bbox_points_camera_image = []\\n\\n euler_transforms = (\\n math.radians(90), # roll along X to force Y axis 'up'\\n math.radians(-90 + -.75), # pitch along Y to force X axis towards 'right', with slight adjustment for camera's 'yaw'\\n math.radians(-9) # another roll to orient the camera slightly 'upwards', (camera's 'pitch')\\n )\\n euler_axes = 'sxyx'\\n\\n try:\\n self.listener.waitForTransform(\\\"/base_link\\\",\\n \\\"/world\\\", timestamp, rospy.Duration(0.1))\\n (trans, rot) = self.listener.lookupTransform(\\\"/base_link\\\",\\n \\\"/world\\\", timestamp)\\n\\n camera_orientation_adj = tf.transformations.quaternion_from_euler(*euler_transforms, axes=euler_axes)\\n\\n trans_matrix = self.listener.fromTranslationRotation(trans, rot)\\n camera_orientation_adj = self.listener.fromTranslationRotation((0, 0, 0), camera_orientation_adj)\\n\\n #print(\\\"trans {}, rot {}\\\".format(trans, rot))\\n #print(\\\"transform matrix {}\\\".format(trans_matrix))\\n\\n point = np.array([point_in_world.x, point_in_world.y, point_in_world.z, 1.0])\\n\\n # this point should match what you'd see from being inside the vehicle looking straight ahead.\\n point_in_camera_space = trans_matrix.dot(point)\\n\\n #print(\\\"point in camera frame {}\\\".format(point_in_camera_space))\\n\\n final_trans_matrix = camera_orientation_adj.dot(trans_matrix)\\n\\n # this point is from the view point of the camera (oriented along the camera's rotation quaternion)\\n point_in_camera_space = final_trans_matrix.dot(point)\\n\\n #print(\\\"point in camera frame adj {}\\\".format(point_in_camera_space))\\n\\n bbox_points = [(point_in_camera_space[0] - 0.5, point_in_camera_space[1] - 1.1, point_in_camera_space[2], 1.0),\\n (point_in_camera_space[0] + 0.5, point_in_camera_space[1] + 1.1, point_in_camera_space[2], 1.0),\\n (point_in_camera_space[0] - 0.5, point_in_camera_space[1] - 1.1, point_in_camera_space[2], 1.0),\\n (point_in_camera_space[0] + 0.5, point_in_camera_space[1] + 1.1, point_in_camera_space[2], 1.0)]\\n\\n # these points represent the bounding box within the camera's image\\n for p in bbox_points:\\n bbox_points_camera_image.append(camera.project3dToPixel(p))\\n\\n # print(\\\"point in image {}\\\".format(bbox_points_camera_image))\\n\\n except (tf.Exception, tf.LookupException, tf.ConnectivityException):\\n rospy.logerr(\\\"Failed to find camera to map transform\\\")\\n\\n return bbox_points_camera_image\",\n \"def xyplane(draw, r, x, shift = np.array([1000, 1000, 0, 0]), scale = 300):\\n extent = 2.8\\n pln = np.array(\\n [\\n [x,-extent,0],\\n [x,extent,0],\\n [x,extent,extent*2],\\n [x,-extent,extent*2]\\n ]\\n )\\n pln = np.dot(pln,np.transpose(r))\\n pln = pln * scale + shift[:3]\\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))\",\n \"def project_plane_to_2d(xyz_arr, img, center, dist_thresh):\\n\\tplane_img = np.zeros(img.size)\\n\\tplane_img[xyz_arr[:, 2] > dist_thresh + center[2]] = 1\\n\\n\\tplane_img = np.uint8(np.reshape(plane_img, (424, 512)) * 255) # reshape to match depth data and convert to uint8\\n\\tplane_img = np.uint8(\\n\\t\\t(np.ones((424, 512)) * 255) - plane_img) # invert img so pixel value corresponds to NOT ground plane\\n\\tret, plane_img = cv2.threshold(plane_img, 0, 255,\\n\\t\\t\\t\\t\\t\\t\\t\\t cv2.THRESH_BINARY) # filter points that are probaly not ground plane\\n\\tplane_img = cv2.subtract(img, plane_img)\\n\\treturn plane_img\",\n \"def uvmap(self, p):\\n # bottom left corner of the plane\\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\\n dif_vector = p - p00\\n u = np.dot(dif_vector, self.n0) / self.sx\\n v = np.dot(dif_vector, self.n1) / self.sy\\n return u, v\",\n \"def load_plane(image):\\n pixels = image.getPrimaryPixels()\\n return pixels.getPlane(0, 0, 0)\",\n \"def verify_plane_endpoints(self):\\n return [self.x0 + self.nx * self.dx, self.y0 + self.ny * self.dy, self.z0 + self.nz * self.dz]\",\n \"def rotate_to_xz_plane(self, point):\\n if len(point) == 2:\\n x, z = point\\n else:\\n x, y, z = point\\n if y != 0.0:\\n x = np.sqrt(x**2 + y**2)\\n return abs(x), z\",\n \"def fit_to_plane(pts):\\n # Compute x_mean, y_mean, z_mean\\n \\n n = len(pts)\\n \\n x_total = 0\\n y_total = 0\\n z_total = 0\\n\\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_mean = x_total * 1.0 / n\\n y_mean = y_total * 1.0 / n\\n z_mean = z_total * 1.0 / n\\n\\n # Compute the p[i] = [x[i]-x_mean,y[i]-y.mean,z[i]-z.mean]\\n p = []\\n for i in range(n):\\n p1 = pts[i][0] - x_mean\\n p2 = pts[i][1] - y_mean\\n p3 = pts[i][2] - z_mean\\n p.append([p1, p2, p3])\\n \\n # Compute the matrix A\\n a1 = 0\\n a2 = 0\\n a3 = 0\\n a4 = 0\\n a5 = 0\\n a6 = 0\\n for i in range(n):\\n a1 += p[i][0] * p[i][0]\\n a2 += p[i][0] * p[i][1]\\n a3 += p[i][0] * p[i][2]\\n a4 += p[i][1] * p[i][1]\\n a5 += p[i][1] * p[i][2]\\n a6 += p[i][2] * p[i][2]\\n\\n A = np.array([[a1, a2, a3], [a2, a4, a5], [a3, a5, a6]])\\n\\n # Compute the smallest eigen value and accordingly eigen vector of A\\n w, v = np.linalg.eigh(A)\\n\\n # The minimal eigenvalue is w[0]\\n eig = w[0]\\n\\n # The norm is eigenvector v[:,0]\\n norm = v[:,0].tolist()\\n d = -norm[0] * x_mean - norm[1] * y_mean - norm[2] * z_mean\\n\\n return norm, d\",\n \"def fit_to_plane(pts):\\n # Compute x_mean, y_mean, z_mean\\n \\n n = len(pts)\\n \\n x_total = 0\\n y_total = 0\\n z_total = 0\\n\\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_mean = x_total * 1.0 / n\\n y_mean = y_total * 1.0 / n\\n z_mean = z_total * 1.0 / n\\n\\n # Compute the p[i] = [x[i]-x_mean,y[i]-y.mean,z[i]-z.mean]\\n p = []\\n for i in range(n):\\n p1 = pts[i][0] - x_mean\\n p2 = pts[i][1] - y_mean\\n p3 = pts[i][2] - z_mean\\n p.append([p1, p2, p3])\\n \\n # Compute the matrix A\\n a1 = 0\\n a2 = 0\\n a3 = 0\\n a4 = 0\\n a5 = 0\\n a6 = 0\\n for i in range(n):\\n a1 += p[i][0] * p[i][0]\\n a2 += p[i][0] * p[i][1]\\n a3 += p[i][0] * p[i][2]\\n a4 += p[i][1] * p[i][1]\\n a5 += p[i][1] * p[i][2]\\n a6 += p[i][2] * p[i][2]\\n\\n A = np.array([[a1, a2, a3], [a2, a4, a5], [a3, a5, a6]])\\n\\n # Compute the smallest eigen value and accordingly eigen vector of A\\n w, v = np.linalg.eigh(A)\\n\\n # The minimal eigenvalue is w[0]\\n eig = w[0]\\n\\n # The norm is eigenvector v[:,0]\\n norm = v[:,0].tolist()\\n d = -norm[0] * x_mean - norm[1] * y_mean - norm[2] * z_mean\\n\\n return norm, d\",\n \"def fit_plane_to_point_cloud(pc: np.ndarray) -> Tuple[Any, Any, Any, Any]:\\n center = pc.sum(axis=0) / pc.shape[0]\\n u, s, vh = np.linalg.svd(pc - center)\\n\\n # Get the unitary normal vector\\n u_norm = vh[2, :]\\n d = -np.dot(u_norm, center)\\n a, b, c = u_norm\\n return a, b, c, d\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts) \\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def fourPointTransform(image, points):\\r\\n\\r\\n topLeft, topRight, bottomLeft, bottomRight = sortFourPoints(points)\\r\\n\\r\\n # Determine the maximum width\\r\\n topWidth = np.sqrt(((topRight[0] - topLeft[0]) ** 2) + ((topRight[1] - topLeft[1]) ** 2))\\r\\n bottomWidth = np.sqrt(((bottomRight[0] - bottomLeft[0]) ** 2) + ((bottomRight[1] - bottomLeft[1]) ** 2))\\r\\n width = max(int(topWidth), int(bottomWidth))\\r\\n\\r\\n # Determine the maximum height\\r\\n leftHeight = np.sqrt(((topLeft[0] - bottomLeft[0]) ** 2) + ((topLeft[1] - bottomLeft[1]) ** 2))\\r\\n rightHeight = np.sqrt(((topRight[0] - bottomRight[0]) ** 2) + ((topRight[1] - bottomRight[1]) ** 2))\\r\\n height = max(int(leftHeight), int(rightHeight))\\r\\n\\r\\n source = np.array([topLeft, topRight, bottomRight, bottomLeft], dtype=\\\"float32\\\")\\r\\n\\r\\n destination = np.array([[0, 0],\\r\\n [width - 1, 0],\\r\\n [width - 1, height - 1],\\r\\n [0, height - 1]], dtype=\\\"float32\\\")\\r\\n\\r\\n transformMatrix = cv2.getPerspectiveTransform(source, destination)\\r\\n\\r\\n return cv2.warpPerspective(image, transformMatrix, (width, height))\",\n \"def homogenous_transformation(x,y):\\n y_start = 0.3\\n y_stop = 1\\n src = np.float32([[0.45,y_start],[0.55, y_start],[0.1,y_stop],[0.9, y_stop]])\\n dst = np.float32([[0.45, y_start],[0.55, y_start],[0.45, y_stop],[0.55,y_stop]])\\n M_inv = cv2.getPerspectiveTransform(dst,src)\\n \\n ones = np.ones((1,len(y)))\\n coordinates = np.vstack((x, y, ones))\\n trans = np.matmul(M_inv, coordinates)\\n \\n x_vals = trans[0,:]/trans[2,:]\\n y_vals = trans[1,:]/trans[2,:]\\n return x_vals, y_vals\",\n \"def plane(self):\\n return Plane(Point(0, self.evaluations.exposedWing.edges[2].point1.y, 0), Vector(0, 1, 0),\\n hidden=True)\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts)\\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def get_plane(self, scalar, plane, pval):\\n\\n if plane == 'yz' or plane == 'zy':\\n # z along rows, y along columns\\n return scalar[:, pval, :]\\n elif plane == 'xz' or plane == 'zx':\\n # x along columns, z along rows\\n return scalar[:, :, pval]\\n elif plane == 'xy' or plane == 'yx':\\n # x along rows, y along columns\\n return scalar[pval, :, :]\",\n \"def test_CoordinatePlane(self):\\n origin = np.random.randn(3)\\n normal = np.random.randn(3)\\n up_vector = np.random.randn(3)\\n plane = shapes_nd.Plane(origin, normal)\\n cplane = shapes_3d.CoordinatePlane(origin, normal, up_vector)\\n \\n np.testing.assert_almost_equal(cplane.dim, plane.dim)\\n np.testing.assert_almost_equal(cplane.origin, plane.origin)\\n np.testing.assert_almost_equal(cplane.normal, plane.normal)\\n \\n p3 = [0, 1, 0]\\n c, d = cplane.project_point(p3, ret_dist=True)\\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))\\n p3 = np.random.randn(5, 3)\\n c, d = cplane.project_point(p3, ret_dist=True)\\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))\",\n \"def project_onto_plane(self,z):\\n U=self.U\\n Q=self.Q_p\\n #print(((z-Q[-2,:,[2]])/P[-2,:,[2]]).T)\\n #print(P[-2])\\n return ((z-Q[-2,:,[2]])/U[-2,:,[2]]).T*U[-2]+Q[-2]\",\n \"def point_to_parameter(self, pt):\\n uv = ShapeAnalysis_Surface(self.surface()).ValueOfUV(\\n gp_Pnt(pt[0], pt[1], pt[2]), 1e-9\\n )\\n return np.array(uv.Coord())\",\n \"def four_point_transform(image, pts):\\n\\n\\tmax_x, max_y = np.max(pts[:, 0]).astype(np.int32), np.max(pts[:, 1]).astype(np.int32)\\n\\n\\tdst = np.array([\\n\\t\\t[0, 0],\\n\\t\\t[image.shape[1] - 1, 0],\\n\\t\\t[image.shape[1] - 1, image.shape[0] - 1],\\n\\t\\t[0, image.shape[0] - 1]], dtype=\\\"float32\\\")\\n\\n\\twarped = cv2.warpPerspective(image, cv2.getPerspectiveTransform(dst, pts), (max_x, max_y))\\n\\n\\treturn warped\",\n \"def plane_from_multiple_points(pnts: Iterable[Point]) -> Plane:\\n n = len(pnts)\\n x = [pnt.x for pnt in pnts]\\n y = [pnt.y for pnt in pnts]\\n z = [pnt.z for pnt in pnts]\\n pntc = Point(sum(x)/n, sum(y)/n, sum(z)/n)\\n x = [pnt.x-pntc.x for pnt in pnts]\\n y = [pnt.y-pntc.y for pnt in pnts]\\n z = [pnt.z-pntc.z for pnt in pnts]\\n sxx = sum([x[i]**2 for i in range(n)])\\n sxy = sum([x[i]*y[i] for i in range(n)])\\n sxz = sum([x[i]*z[i] for i in range(n)])\\n syy = sum([y[i]**2 for i in range(n)])\\n syz = sum([y[i]*z[i] for i in range(n)])\\n d = sxx*syy-sxy**2\\n a = (syz*sxy-sxz*syy)/d\\n b = (sxy*sxz-sxx*syz)/d\\n nrm = Vector(a, b, 1.0)\\n return Plane(pntc, nrm)\",\n \"def projectPoint(self,p):\\n a,b,c = self.a, self.b, self.c\\n x,y = p\\n return numpy.array( [ b*(x*b-y*a) - c*a, a*(y*a-x*b) - c*b ] )\",\n \"def transform_perspective(self, pt_x, pt_y):\\n linear_y = pt_y * self.perspective_point_y / self.height\\n\\n diff_x = pt_x - self.perspective_point_x\\n diff_y = self.perspective_point_y - linear_y\\n factor_y = diff_y / self.perspective_point_y\\n # factor_y = factor_y * factor_y\\n factor_y = pow(factor_y, 2) # pow = mise au carre\\n\\n transfor_x = self.perspective_point_x + diff_x * factor_y\\n transfor_y = self.perspective_point_y - factor_y * self.perspective_point_y\\n\\n return int(transfor_x), int(transfor_y)\",\n \"def mirror_point_to_plane(point, plane):\\n assert isinstance(plane, cg3d_plane.CGPlane)\\n pn, norm = plane.get_point_and_normal()\\n norm.normalize()\\n return point - 2.0 * ((point - pn) * norm) * norm\",\n \"def _point_scale2img(points, _H, _W):\\n # with tf.variable_scope(\\\"_point_scale2img\\\", reuse=False):\\n points = points * tf.constant([_H - 1, _W - 1], \\\"float32\\\")\\n return points\",\n \"def PlaneSubtraction(data, direction='xy', xdim=20, ydim=20):\\n img = 1*data\\n dy, dx = img.shape\\n x = np.linspace(0, xdim, dx)\\n y = np.linspace(0, ydim, dy)\\n DX, DY = np.meshgrid(x, y)\\n PX = []\\n PY = []\\n\\n for i, j in zip(np.arange(dy), np.arange(dx)):\\n lx = img[i]\\n ly = img[:, j]\\n maskx = np.isnan(lx)\\n masky = np.isnan(ly)\\n\\n if len(lx[maskx]) < len(lx):\\n s = np.polyfit(x[~maskx], lx[~maskx], 1)\\n PX.append(s)\\n\\n if len(ly[masky]) < len(ly):\\n s = np.polyfit(y[~masky], ly[~masky], 1)\\n PY.append(s)\\n\\n px = np.nanmean(PX, axis=0)\\n py = np.nanmean(PY, axis=0)\\n print(\\\"x - slope: %.2e, y - slope: %.2e\\\" % (px[0], py[0]))\\n print(\\\"calculate planes\\\")\\n xplane = np.polyval(px, DX)\\n yplane = np.polyval(py, DY)\\n\\n if direction == 'x':\\n print('x plane subtraction')\\n correction = xplane\\n elif direction == 'y':\\n print('y plane subtraction')\\n correction = yplane\\n else:\\n print('x-y plane subtraction')\\n correction = xplane + yplane\\n\\n corrected = data - correction\\n corrected -= np.nanmin(corrected)\\n return corrected\",\n \"def plot_plane(unit_normal, x_array, y_array, fore):\\n # print'unit normal = ', unit_normal\\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\\n # print 'plane numbers\\\\n', z\\n return z\",\n \"def xyFromROI(aROIPoints):\\n pt1 = aROIPoints[0]\\n pt2 = aROIPoints[1]\\n x0, y0 = pt1\\n x1, y1 = pt2\\n return x0, y0, x1, y1\",\n \"def _generate_random_points_in_plane(nvect, dparam, npts, eps=0.0):\\n np.random.seed(12345)\\n a, b, c = nvect / np.linalg.norm(nvect)\\n x, y = np.random.rand(npts), np.random.rand(npts)\\n z = (dparam - a * x - b * y) / c\\n if eps > 0:\\n z += np.random.normal(loc=0., scale=eps, size=npts)\\n return np.column_stack((x, y, z))\",\n \"def GetPlane(plane):\\r\\n pass\",\n \"def get_plane_of_points(\\n self,\\n normal_vector=\\\"z\\\",\\n planar_coordinate=None,\\n ):\\n # Get results vectors\\n if (normal_vector == \\\"z\\\"):\\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\\n else:\\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\\n\\n # Create a df of these\\n if normal_vector == \\\"z\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": y_flat,\\n \\\"x3\\\": z_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"x\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": y_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": x_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"y\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": y_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n\\n # Subset to plane\\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\\n if planar_coordinate is not None:\\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\\n\\n # Drop duplicates\\n # TODO is this still needed now that we setup a grid for just this plane?\\n df = df.drop_duplicates()\\n\\n # Sort values of df to make sure plotting is acceptable\\n df = df.sort_values([\\\"x2\\\", \\\"x1\\\"]).reset_index(drop=True)\\n\\n return df\",\n \"def photons(self, depth=1):\\n self.dx[:,:self.W-1] = self.z[:,1:] - self.z[:,:self.W-1]\\n self.dy[:self.H-1,:] = self.z[1:,:] - self.z[:self.H-1,:]\\n px = self.xv - self.dx*depth\\n py = self.yv - self.dy*depth\\n return px,py\",\n \"def obtain_points(self):\\n # Swapaxes makes the output a column rather than a row\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"GridCoordinates\\\"][\\\"CoordinateX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"GridCoordinates\\\"][\\\"CoordinateY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"GridCoordinates\\\"][\\\"CoordinateZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def get_transformable_plane(self, x_range = None, y_range = None):\\n plane_config = dict(self.plane_config)\\n shift_val = ORIGIN\\n if x_range is not None:\\n x_min, x_max = x_range\\n plane_config[\\\"x_radius\\\"] = x_max - x_min\\n shift_val += (x_max+x_min)*RIGHT/2.\\n if y_range is not None:\\n y_min, y_max = y_range\\n plane_config[\\\"y_radius\\\"] = y_max - y_min\\n shift_val += (y_max+y_min)*UP/2.\\n plane = ComplexPlane(**plane_config)\\n plane.shift(shift_val)\\n if self.use_multicolored_plane:\\n self.paint_plane(plane)\\n return plane\",\n \"def _convert_image_to_coordinates(self, vect) -> np.ndarray:\\n xdim = vect.shape[0]\\n ydim = vect.shape[1]\\n\\n # stride is used during averaging and length adjustment\\n stride_x, stride_y = self._averaging, self._averaging\\n\\n # create empty vector of necessary shape\\n # every \\\"pixel\\\" has 2 coordinates\\n pos = np.empty((2 * xdim * ydim, 2), dtype=np.float32)\\n\\n # create coordinate spacing for x-y\\n # double the num of elements by doubling x sampling\\n xspace = np.linspace(0, stride_x*xdim, 2 * xdim, endpoint=False)\\n yspace = np.linspace(0, stride_y*ydim, ydim, endpoint=False)\\n xv, yv = np.meshgrid(xspace, yspace)\\n\\n # assign coordinates (pos) to all pixels\\n pos[:, 0] = xv.flatten()\\n pos[:, 1] = yv.flatten()\\n\\n # pixel midpoints are the first x-values of positions\\n midpt = np.zeros((xdim * ydim, 2), dtype=np.float32)\\n midpt[:, 0] = pos[0::2, 0]+(stride_x-1)/2\\n midpt[:, 1] = pos[0::2, 1]+(stride_y-1)/2\\n\\n # rotate coordinates about midpoint to represent angle and length\\n pos[0::2, 0] = midpt[:, 0] - (stride_x / 2) * (self._length/2) * \\\\\\n vect.reshape((xdim*ydim, 2))[:, 0]\\n pos[0::2, 1] = midpt[:, 1] - (stride_y / 2) * (self._length/2) * \\\\\\n vect.reshape((xdim*ydim, 2))[:, 1]\\n pos[1::2, 0] = midpt[:, 0] + (stride_x / 2) * (self._length/2) * \\\\\\n vect.reshape((xdim*ydim, 2))[:, 0]\\n pos[1::2, 1] = midpt[:, 1] + (stride_y / 2) * (self._length/2) * \\\\\\n vect.reshape((xdim*ydim, 2))[:, 1]\\n\\n return pos\",\n \"def pixel2coords(self, x, y):\\n xoff, a, b, yoff, d, e = self.geotransform()\\n\\n xp = a * x + b * y + xoff\\n yp = d * x + e * y + yoff\\n return (xp, yp)\",\n \"def pixel2coord(self, x, y):\\n # NEED TO CHANGE TO USE INVERSE TRANSFORM COEFFS\\n # partly taken from Sean Gillies \\\"affine.py\\\"\\n a,b,c,d,e,f = self.coordspace_transform\\n det = a*e - b*d\\n idet = 1 / float(det)\\n ra = e * idet\\n rb = -b * idet\\n rd = -d * idet\\n re = a * idet\\n newx = (x*ra + y*rb + (-c*ra - f*rb) )\\n newy = (x*rd + y*re + (-c*rd - f*re) )\\n return newx,newy\",\n \"def get_2d_points(image, rotation_vector, translation_vector, camera_matrix, val):\\n point_3d = []\\n dist_coeffs = np.zeros((4,1))\\n rear_size = val[0]\\n rear_depth = val[1]\\n point_3d.append((-rear_size, -rear_size, rear_depth))\\n point_3d.append((-rear_size, rear_size, rear_depth))\\n point_3d.append((rear_size, rear_size, rear_depth))\\n point_3d.append((rear_size, -rear_size, rear_depth))\\n point_3d.append((-rear_size, -rear_size, rear_depth))\\n \\n front_size = val[2]\\n front_depth = val[3]\\n point_3d.append((-front_size, -front_size, front_depth))\\n point_3d.append((-front_size, front_size, front_depth))\\n point_3d.append((front_size, front_size, front_depth))\\n point_3d.append((front_size, -front_size, front_depth))\\n point_3d.append((-front_size, -front_size, front_depth))\\n point_3d = np.array(point_3d, dtype=np.float).reshape(-1, 3)\\n \\n # Map to 2D image points\\n (point_2d, _) = cv2.projectPoints(point_3d,rotation_vector,translation_vector,camera_matrix,dist_coeffs)\\n point_2d = np.int32(point_2d.reshape(-1, 2))\\n return point_2d\",\n \"def projective_transform(self, x):\\n\\n x = np.asarray(x)\\n # Assume no intensity column\\n x0, y0, z0 = x\\n\\n # Camera coors to pixel coors\\n u = ((x0 / z0) * self.f) + (self.sensor_size[0] // 2)\\n v = ((y0 / z0) * self.f) + (self.sensor_size[1] // 2)\\n\\n u_min = np.min(u)\\n v_min = np.min(v)\\n\\n n = len(u)\\n u_list = []\\n v_list = []\\n if self.error_on_oob:\\n for i in range(n):\\n if (u[i] >= u_min and u[i] <= self.sensor_size[0] and v[i] >= v_min and v[i] <= self.sensor_size[1]):\\n u_list.append(u[i])\\n v_list.append(v[i])\\n else:\\n raise OutOfSensorBoundsError(\\\"Projected coordinate was outside the sensor\\\")\\n else:\\n for i in range(n):\\n u_list.append(u[i])\\n v_list.append(v[i])\\n\\n u = np.asarray(u_list)\\n v = np.asarray(v_list)\\n\\n return np.vstack((u, v))\",\n \"def four_point_transform(self, image, pts):\\n rect = []\\n for j in range(4):\\n rect.append([pts[j * 2], pts[j * 2 + 1]])\\n\\n rect = np.array(rect, dtype=\\\"float32\\\")\\n (tl, tr, br, bl) = rect\\n # compute the width of the new image, which will be the\\n # maximum distance between bottom-right and bottom-left\\n # x-coordiates or the top-right and top-left x-coordinates\\n widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))\\n widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))\\n maxWidth = max(int(widthA), int(widthB))\\n # compute the height of the new image, which will be the\\n # maximum distance between the top-right and bottom-right\\n # y-coordinates or the top-left and bottom-left y-coordinates\\n heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))\\n heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))\\n maxHeight = max(int(heightA), int(heightB))\\n # now that we have the dimensions of the new image, construct\\n # the set of destination points to obtain a \\\"birds eye view\\\",\\n # (i.e. top-down view) of the image, again specifying points\\n # in the top-left, top-right, bottom-right, and bottom-left\\n # order\\n dst = np.array([\\n [0, 0],\\n [maxWidth - 1, 0],\\n [maxWidth - 1, maxHeight - 1],\\n [0, maxHeight - 1]], dtype=\\\"float32\\\")\\n # compute the perspective transform matrix and then apply it\\n M = cv2.getPerspectiveTransform(rect, dst)\\n warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))\\n # return the warped image\\n return warped\",\n \"def proyZm1(u, v, t1):\\n den = u ** 2 + v ** 2 + 4\\n x = u - t1 * (u - 4 * u / den)\\n y = v - t1 * (v - 4 * v / den)\\n z = -1 - t1 * (-2 + 8 / den)\\n return (x, y, z)\",\n \"def transform_point(p,R,t):\\r\\n x = R[0][0]*p[0]+R[0][1]*p[1]+t[0]\\r\\n y = R[1][0]*p[0]+R[1][1]*p[1]+t[1]\\r\\n return [x,y]\",\n \"def _image_to_point_space(pixel_coordinates: np.array, boundary_radius: int, resolution: int) -> np.array:\\n pix_origin = np.array([resolution / 2, resolution / 2])\\n return np.array((pixel_coordinates - pix_origin) * (2 * boundary_radius) / resolution)\",\n \"def project(points, camera_params, theta):\\n \\\"\\\"\\\"\\n Function takes input of 3d_points, transformations and Convert 3-D points to 2-D by projecting onto images. \\n Input:\\n points: 3D points in world frame\\n camera_params: parameters of camera corrosponding to the point\\n theta: Needed For PAL camera to specify the sub camera index for the points\\n Output:\\n points_proj: 2D reprojected points for 3D points \\n\\n \\\"\\\"\\\"\\n # Convert the 3D points to Camera Frame by rotaion followes by translation\\n points_proj1 = rotate(points[:,0:3], camera_params[:, :3])\\n points_proj1 += camera_params[:, 3:6]\\n # FOR PAL: Converting into the Sub-camera Frame by respective rotation\\n thetas = theta * np.pi / 3 \\n points_proj = np.copy(points_proj1)\\n points_proj[:,0] = points_proj1[:,0]*np.cos(thetas) - points_proj1[:,2]*np.sin(thetas)\\n points_proj[:,2] = points_proj1[:,0]*np.sin(thetas) + points_proj1[:,2]*np.cos(thetas)\\n # Avoiding Zero error\\n for i in range(len(points_proj)):\\n if(points_proj[i,2]==0):\\n points_proj[i,0] = 0\\n points_proj[i,1] = 0\\n points_proj[i,2] = 1\\n # 2D projection\\n points_proj = points_proj[:, :2] / points_proj[:, 2, np.newaxis]\\n f = camera_params[:, 6]\\n k1 = camera_params[:, 7]\\n k2 = camera_params[:, 8]\\n n = np.sum(points_proj**2, axis=1)\\n r = 1 + k1 * n + k2 * n**2\\n points_proj *= (r * f)[:, np.newaxis]\\n return points_proj\",\n \"def project_points(X, K, R, T, distortion_flag=False, distortion_params=None):\\n # Project points from 3d world coordinates to 2d image coordinates\\n\\n #get projection matrix\\n pmatrix = projection_matrix(R, T, K)\\n\\n #add 4th component to points\\n ones = np.ones([1,len(X[0])])\\n xones=np.row_stack((X,ones))\\n\\n #calculate pixel coordinates\\n X_camera = pmatrix.dot(xones)\\n\\n return X_camera\",\n \"def derive(params):\\n x, y, dx, dy = params\\n r = (x ** 2 + y ** 2) ** 0.5\\n return np.array([dx, dy, -G * M * x / (r ** 3), -G * M * y / (r ** 3)])\",\n \"def pose_2d_pts(self,image):\\n '''\\n image- rgb image \\n return:-\\n pts - list of 2d pose landmarks as img coords\\n image- rgb image on which the 2d pose landmarks are drawn\\n ''' \\n pts=[]\\n imgRGB=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\\n results=pose.process(imgRGB)\\n if results.pose_landmarks:\\n mpDraw.draw_landmarks(image,results.pose_landmarks,mpPose.POSE_CONNECTIONS)\\n for id,lm in enumerate(results.pose_landmarks.landmark):\\n h,w,c=image.shape\\n imgx,imgy=int(lm.x*w),int(lm.y*h)\\n \\n pts.append((imgx,imgy)) \\n return pts,image\",\n \"def get_points(self):\\r\\n return self.nx*self.ny*self.nz\",\n \"def project_3d_points_to_plane(points, p1, p2 ,p3, numpoints):\\n p1 = np.asarray(p1)\\n p2 = np.asarray(p2)\\n p3 = np.asarray(p3)\\n\\n # get vectors in plane\\n v1 = p3 - p1\\n v2 = p2 - p1\\n\\n # compute cross product\\n cp = np.cross(v1, v2)\\n a, b, c = cp # normal to plane is ax + by + cz\\n\\n # evaluate d\\n d = np.dot(cp, p3)\\n\\n # thus, normal is given by\\n plane = vtk.vtkPlane()\\n origin = p1\\n normal = normalize(np.array([a,b,c]))\\n plane.SetOrigin(p1)\\n plane.SetNormal(normal)\\n\\n if numpoints == 1:\\n proj = [0,0,0]\\n plane.ProjectPoint(points, origin, normal, proj)\\n return proj\\n else:\\n projected_pts = np.zeros((numpoints, 3), dtype=float)\\n\\n for i in range(numpoints):\\n proj = [0,0,0]\\n plane.ProjectPoint(points[i], origin, normal, proj)\\n projected_pts[i] = proj\\n\\n return projected_pts\",\n \"def camera_pixels_to_camera_coords(left_pt, right_pt, nparrays=False):\\n assert len(left_pt) == len(right_pt) == 2\\n disparity = np.linalg.norm( np.array(left_pt) - np.array(right_pt) )\\n (xx,yy,zz) = STEREO_MODEL.projectPixelTo3d( (left_pt[0],left_pt[1]), disparity )\\n if nparrays:\\n return np.array([xx,yy,zz])\\n else:\\n return [xx,yy,zz]\",\n \"def planes_3d(self, quantity, xplane, yplane):\\n xplane = int(xplane)\\n yplane = int(yplane)\\n # Get the scalar values\\n # Get the data on the plane with a fixed x value. These means we'll\\n # have changing (y, z) points\\n xdata = self.get_plane(quantity, 'yz', xplane)\\n # z first cuz we want y to be changing before z to correspond with the\\n # way numpy flattens arrays. Note this means y points will be in the\\n # 2nd column\\n xplanepoints = np.array(list(itertools.product(self.Z, self.Y)))\\n xdata = xdata.flatten()\\n xplanexval = np.array(list(itertools.repeat(x[xplane], len(xdata))))\\n xplanedata = np.zeros((xplanepoints.shape[0], 4))\\n xplanedata[:, 0] = xplanexval\\n xplanedata[:, 1] = xplanepoints[:, 1]\\n xplanedata[:, 2] = xplanepoints[:, 0]\\n xplanedata[:, 3] = xdata\\n # Same procedure for fixed y plane\\n ydata = self.get_plane(quantity, 'xz', yplane)\\n yplanepoints = np.array(list(itertools.product(z, x)))\\n ydata = ydata.flatten()\\n yplaneyval = np.array(list(itertools.repeat(y[yplane], len(ydata))))\\n yplanedata = np.zeros((yplanepoints.shape[0], 4))\\n yplanedata[:, 0] = yplanepoints[:, 1]\\n yplanedata[:, 1] = yplaneyval\\n yplanedata[:, 2] = yplanepoints[:, 0]\\n yplanedata[:, 3] = ydata\\n labels = ('X [um]', 'Y [um]', 'Z [um]', quantity)\\n # Now stack them vertically and plot!\\n all_data = np.vstack((xplanedata, yplanedata))\\n self.scatter3d(all_data[:, 0], all_data[:, 1], all_data[:, 2],\\n all_data[:, 3], labels, 'planes_3d')\",\n \"def projectToImage(pts_3D, P):\\n pts_3D = np.reshape(pts_3D, (-1, 3))\\n pts_3D = np.transpose(pts_3D)\\n pts_3D = np.vstack([pts_3D, 1])\\n pts_2D = np.matmul(P, pts_3D)\\n pts_2D = pts_2D[:2]/pts_2D[-1]\\n pts_2D = np.transpose(pts_2D)\\n return pts_2D\",\n \"def get_point_coords_wrt_image(boxes, point_coords):\\n # with tf.variable_scope(\\\"get_point_coords_wrt_image\\\", reuse=False):\\n boxes = tf.stop_gradient(boxes)\\n point_coords = tf.stop_gradient(point_coords)\\n h = boxes[:, None, 2] - boxes[:, None, 0]\\n w = boxes[:, None, 3] - boxes[:, None, 1]\\n y1 = boxes[:, None, 0]\\n x1 = boxes[:, None, 1]\\n scale = tf.stack([h, w], axis=-1)\\n trans = tf.stack([y1, x1], axis=-1)\\n point_coords = point_coords * scale\\n point_coords = point_coords + trans\\n return point_coords\",\n \"def create_point_cloud(self):\\n pixels = []\\n colors = []\\n my_pixels = []\\n for j in range(self.height):\\n for i in range(self.width):\\n depth = self.depth[j, i]\\n pixels.append(\\n [i * depth, j * depth, depth]\\n )\\n my_pixels.append(\\n [i, j, 1]\\n )\\n # make rgb with flip()\\n colors.append(np.flip(self.bgr[j, i, :]))\\n # colors.append(self.bgr[j, i, :])\\n self.my_pixels = my_pixels\\n pixels = np.array(pixels)\\n\\n # project pixels to camera space\\n self.xyz_points = self.intrinsics_inv @ np.transpose(pixels)\\n self.color_points = colors\\n\\n # now add 1s to the points for homogenous coordinates\\n num_points = self.get_num_xyz_points()\\n ones = np.ones((1, num_points))\\n self.xyzw_points = np.concatenate((self.xyz_points, ones), axis=0)\\n\\n self.scene = None\\n self.camera_pose = None\\n self.nm = None\\n self.nl = None\\n self.nc = None\\n self.create_mesh()\",\n \"def get_point(self, params):\\n spm = self.spm\\n cpoint = self.current_point\\n x = params.get('X',cpoint[0])\\n y = params.get('Y',cpoint[1])\\n z = params.get('Z',cpoint[2])\\n a = cpoint[3]\\n b = cpoint[4]\\n if 'E' in params:\\n a = params.get('E',cpoint[3])\\n elif 'A' in params:\\n a = params.get('A',cpoint[3])\\n elif 'B' in params:\\n b = params.get('B',cpoint[4])\\n point = [x,y,z,a,b]\\n return point\",\n \"def plane_from_points(a, b, c):\\n ab = subtract_vectors(b, a)\\n ac = subtract_vectors(c, a)\\n n = normalize_vector(cross_vectors(ab, ac))\\n return a, n\",\n \"def make_coordinates(image, line_params):\\n slope, intercept = line_params\\n y1 = image.shape[0]\\n y2 = int(y1 * (3/5))\\n x1 = int((y1 - intercept)/ slope)\\n x2 = int((y2 - intercept)/ slope)\\n return np.array([x1, y1, x2, y2])\",\n \"def project(points, camera_params):\\n # print(camera_params.shape)\\n points_proj = rotate(points, camera_params[:, :3])\\n points_proj += camera_params[:, 3:6]\\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\\n f = 2360*np.ones(camera_params.shape[0])\\n # np.ones()\\n # n = np.sum(points_proj**2, axis=1)\\n r = 1\\n points_proj *= (r * f)[:, np.newaxis]\\n return points_proj\",\n \"def get_perspective_transform(points_src: Tensor, points_dst: Tensor) -> Tensor:\\n KORNIA_CHECK_SHAPE(points_src, [\\\"B\\\", \\\"4\\\", \\\"2\\\"])\\n KORNIA_CHECK_SHAPE(points_dst, [\\\"B\\\", \\\"4\\\", \\\"2\\\"])\\n KORNIA_CHECK(points_src.shape == points_dst.shape, \\\"Source data shape must match Destination data shape.\\\")\\n KORNIA_CHECK(points_src.dtype == points_dst.dtype, \\\"Source data type must match Destination data type.\\\")\\n\\n # we build matrix A by using only 4 point correspondence. The linear\\n # system is solved with the least square method, so here\\n # we could even pass more correspondence\\n\\n # create the lhs tensor with shape # Bx8x8\\n B: int = points_src.shape[0] # batch_size\\n\\n A = torch.empty(B, 8, 8, device=points_src.device, dtype=points_src.dtype)\\n\\n # we need to perform in batch\\n _zeros = zeros(B, device=points_src.device, dtype=points_src.dtype)\\n _ones = torch.ones(B, device=points_src.device, dtype=points_src.dtype)\\n\\n for i in range(4):\\n x1, y1 = points_src[..., i, 0], points_src[..., i, 1] # Bx4\\n x2, y2 = points_dst[..., i, 0], points_dst[..., i, 1] # Bx4\\n\\n A[:, 2 * i] = stack([x1, y1, _ones, _zeros, _zeros, _zeros, -x1 * x2, -y1 * x2], -1)\\n A[:, 2 * i + 1] = stack([_zeros, _zeros, _zeros, x1, y1, _ones, -x1 * y2, -y1 * y2], -1)\\n\\n # the rhs tensor\\n b = points_dst.view(-1, 8, 1)\\n\\n # solve the system Ax = b\\n X: Tensor = _torch_solve_cast(A, b)\\n\\n # create variable to return the Bx3x3 transform\\n M = torch.empty(B, 9, device=points_src.device, dtype=points_src.dtype)\\n M[..., :8] = X[..., 0] # Bx8\\n M[..., -1].fill_(1)\\n\\n return M.view(-1, 3, 3) # Bx3x3\",\n \"def pos2im_coordinates(x, z):\\n # x_lim = [-0.85, 0.86]\\n # z_lim = [-1.22, 0.47]\\n x_lim = [-0.365, 0.365]\\n z_lim = [-0.95, -0.24]\\n\\n pix_x = int(127 * (x_lim[1] - x) / (x_lim[1] - x_lim[0]))\\n pix_z = int(127 * (z_lim[1] - z) / (z_lim[1] - z_lim[0]))\\n return pix_x, pix_z\",\n \"def kinect_transform(self, x, y, z):\\n xposition = x\\n yposition = y\\n zposition = z\\n\\n return zposition, xposition, yposition\",\n \"def four_point_transform(image, pts):\\n rect = order_points(pts)\\n width_first = np.sqrt(\\n ((rect[2][0] - rect[3][0]) ** 2) + ((rect[2][1] - rect[3][1]) ** 2)\\n )\\n width_second = np.sqrt(\\n ((rect[1][0] - rect[0][0]) ** 2) + ((rect[1][1] - rect[0][1]) ** 2)\\n )\\n max_width = max(int(width_first), int(width_second))\\n height_first = np.sqrt(\\n ((rect[1][0] - rect[2][0]) ** 2) + ((rect[1][1] - rect[2][1]) ** 2)\\n )\\n height_second = np.sqrt(\\n ((rect[0][0] - rect[3][0]) ** 2) + ((rect[0][1] - rect[3][1]) ** 2)\\n )\\n max_height = max(int(height_first), int(height_second))\\n dst = np.array(\\n [\\n [0, 0],\\n [max_width - 1, 0],\\n [max_width - 1, max_height - 1],\\n [0, max_height - 1],\\n ],\\n dtype=\\\"float32\\\",\\n )\\n view_transform = cv2.getPerspectiveTransform(rect, dst)\\n warped = cv2.warpPerspective(image, view_transform, (max_width, max_height))\\n return warped\",\n \"def fit_plane_to_points(points: np.ndarray, eps: float=1.0e-5):\\n # Compute plane origin and subract it from the points array.\\n plane_origin = np.mean(points, axis=0)\\n x = points - plane_origin\\n\\n # Dot product to yield a 3x3 array.\\n moment = np.dot(x.T, x)\\n\\n # Extract single values from SVD computation to get normal.\\n plane_normal = np.linalg.svd(moment)[0][:,-1]\\n small = np.where(np.abs(plane_normal) < eps)\\n plane_normal[small] = 0.0\\n plane_normal /= np.linalg.norm(plane_normal)\\n if (plane_normal[-1] < 0.0):\\n plane_normal *= -1.0\\n\\n return (plane_normal, plane_origin)\",\n \"def to_compas(self):\\n return Point(self.x, self.y, self.z)\",\n \"def project(points, camera_params):\\n points_proj = rotate(points, camera_params[:, :3])\\n points_proj += camera_params[:, 3:6]\\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\\n f = camera_params[:, 6]\\n k1 = camera_params[:, 7]\\n k2 = camera_params[:, 8]\\n n = np.sum(points_proj ** 2, axis=1)\\n r = 1 + k1 * n + k2 * n ** 2\\n points_proj *= (r * f)[:, np.newaxis]\\n return points_proj\",\n \"def xzplane(draw, r, y, shift = np.array([1000, 1000, 0, 0]), scale = 300):\\n extent = 2.8\\n pln = np.array(\\n [\\n [-extent,y,0],\\n [extent,y,0],\\n [extent,y,extent*2],\\n [-extent,y,extent*2]\\n ]\\n )\\n pln = np.dot(pln, np.transpose(r))\\n pln = pln * scale + shift[:3]\\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))\",\n \"def get_projection_point(self, point, plane, test=False):\\n return point_on_plane_projection(point, plane, test=test)\",\n \"def _transform_point(self, x, y):\\n return (x, y)\",\n \"def camera_to_pixel(self, X):\\n raise NotImplementedError\",\n \"def secondorder(self):\\n f = self.img\\n x = self.x\\n y = self.y\\n self.x2 = sum(f*x**2)/sum(f) - self.x1**2\\n self.y2 = sum(f*y**2)/sum(f) - self.y1**2\\n self.xy = sum(f*x*y)/sum(f) - self.x1*self.y1\",\n \"def calculate_points(self):\\n\\n v0 = np.vstack(np.sign(self.distance_from_plane[:, 0] *\\n self.distance_from_plane[:, 1]))\\n v1 = np.vstack(np.sign(self.distance_from_plane[:, 1] *\\n self.distance_from_plane[:, 2]))\\n v2 = np.vstack(np.sign(self.distance_from_plane[:, 2] *\\n self.distance_from_plane[:, 0]))\\n\\n goes_through = np.concatenate([v0, v1, v2], 1)\\n self.num_points = (np.sum(goes_through == 0) * 2 +\\n np.sum(goes_through == -1))\\n\\n self.slice_points = np.zeros((self.num_points, 3))\\n curr_point = 0\\n\\n for i in range(len(goes_through)):\\n for x in range(len(goes_through[i])):\\n if goes_through[i][x] == -1:\\n # The line goes through the plane\\n # There is a point which lies in the plane, which is r\\n # amounts of vector V away from point P0\\n p0 = self.obj.vectors[i][x]\\n if x == 0 or x == 1:\\n V = self.obj.vectors[i][x]-self.obj.vectors[i][x+1]\\n else:\\n V = self.obj.vectors[i][x]-self.obj.vectors[i][0]\\n d = (np.dot((self.plane_origin-p0), self.plane_normal) /\\n (np.dot(V, self.plane_normal)))\\n P = p0 + d*V\\n self.slice_points[curr_point] = P\\n curr_point += 1\\n\\n if goes_through[i][x] == 0:\\n if x == 0 or x == 1:\\n self.slice_points[curr_point] = self.obj.vectors[i][x]\\n self.slice_points[curr_point+1] = self.obj.vectors[i][x+1]\\n else:\\n self.slice_points[curr_point] = self.obj.vectors[i][x]\\n self.slice_points[curr_point+1] = self.obj.vectors[i][0]\\n\\n self.slice_points = np.round(self.slice_points, decimals=5)\\n self.slice_points = np.unique(self.slice_points, axis=0)\\n \\n return None\",\n \"def head_pose_points(image, rotation_vector, translation_vector, camera_matrix):\\n rear_size = 1\\n rear_depth = 0\\n front_size = image.shape[1]\\n front_depth = front_size*2\\n val = [rear_size, rear_depth, front_size, front_depth]\\n point_2d = get_2d_points(image, rotation_vector, translation_vector, camera_matrix, val)\\n y = (point_2d[5] + point_2d[8])//2\\n x = point_2d[2]\\n \\n return (x, y)\",\n \"def convert_coords(x, y, conversion):\\n if conversion == \\\"cartesian\\\" :\\n # convert to cartesian plane coordinates \\n x_new = x - (width/2)\\n y_new = (height/2) + y \\n\\n elif conversion == \\\"pygame\\\":\\n # only needed to place images in pygame\\n x_new = x + (width/2)\\n y_new = (height/2) - y\\n \\n return x_new, y_new\",\n \"def pixel_to_coords(self, x, y):\\n rx, ry = self.size\\n nx = (x / rx - 0.5) * self.scale + self.center[0]\\n ny = ((ry - y) / ry - 0.5) * self.scale + self.center[1]\\n nz = self.center[2]\\n return [nx, ny, nz]\",\n \"def get_plane(self, quantity, plane, pval):\\n\\n self.log.info('Retrieving plane for %s', quantity)\\n scalar = self.get_scalar_quantity(quantity)\\n if plane == 'yz' or plane == 'zy':\\n # z along rows, y along columns\\n return scalar[:, pval, :]\\n elif plane == 'xz' or plane == 'zx':\\n # x along columns, z along rows\\n return scalar[:, :, pval]\\n elif plane == 'xy' or plane == 'yx':\\n # x along rows, y along columns\\n return scalar[pval, :, :]\",\n \"def project(points, camera_params):\\n points_proj = rotate(points, camera_params[:, :3])\\n points_proj += camera_params[:, 3:6]\\n points_proj = points_proj[:, :2] / points_proj[:, 2, np.newaxis]\\n f = camera_params[:, 6]\\n k1 = camera_params[:, 7]\\n k2 = camera_params[:, 8]\\n n = np.sum(points_proj ** 2, axis=1)\\n r = 1 + k1 * n + k2 * n ** 2\\n points_proj *= (r * f)[:, np.newaxis]\\n return points_proj\",\n \"def roi2point(self, msg):\\n p = Vector([0,0,0])\\n if self.camerainfo.width > 0:\\n p.x = 0.5 - (msg.x_offset+(msg.width/2.0))/self.camerainfo.width\\n if self.camerainfo.height > 0:\\n p.z = 0.5 - (msg.y_offset+(msg.height/2.0))/self.camerainfo.height\\n return p\",\n \"def pyr_point_translator(x, y, org_l, dest_l):\\n dest_x = (2.0 ** (org_l - dest_l)) * x\\n dest_y = (2.0 ** (org_l - dest_l)) * y\\n return np.array([dest_x, dest_y]).transpose()\",\n \"def convert_depth_frame_to_pointcloud(depth_image, camera_intrinsics ):\\r\\n\\t\\r\\n\\t[height, width] = depth_image.shape\\r\\n\\r\\n\\tnx = np.linspace(0, width-1, width)\\r\\n\\tny = np.linspace(0, height-1, height)\\r\\n\\tu, v = np.meshgrid(nx, ny)\\r\\n\\tx = (u.flatten() - camera_intrinsics.ppx)/camera_intrinsics.fx\\r\\n\\ty = (v.flatten() - camera_intrinsics.ppy)/camera_intrinsics.fy\\r\\n\\r\\n\\tz = depth_image.flatten() / 1000;\\r\\n\\tx = np.multiply(x,z)\\r\\n\\ty = np.multiply(y,z)\\r\\n\\r\\n\\tx = x[np.nonzero(z)]\\r\\n\\ty = y[np.nonzero(z)]\\r\\n\\tz = z[np.nonzero(z)]\\r\\n\\r\\n\\treturn x, y, z\",\n \"def perspective_transform():\\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\\n M = cv2.getPerspectiveTransform(src, dst)\\n Minv = cv2.getPerspectiveTransform(dst, src)\\n\\n return M, Minv\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65616685","0.64299065","0.6374554","0.63244987","0.6322487","0.6310065","0.6286317","0.6259193","0.62357223","0.6208368","0.6159411","0.60882986","0.6084627","0.60737157","0.60300255","0.60300255","0.6017754","0.5987526","0.5984642","0.59726226","0.5969681","0.59394383","0.5935725","0.59319305","0.59159607","0.5915894","0.5896955","0.5883881","0.5883881","0.5883818","0.58621496","0.58516526","0.5838182","0.5833157","0.58171","0.5800497","0.5794973","0.5785344","0.5781255","0.5776664","0.5774433","0.5764916","0.5747197","0.57272","0.5710376","0.5708299","0.56996375","0.56931156","0.5689399","0.5688714","0.56867486","0.5682672","0.5664519","0.5659953","0.5647446","0.56437176","0.56211686","0.56146085","0.56120086","0.5608656","0.5603487","0.55956006","0.5591249","0.55892265","0.5577928","0.5577665","0.5574795","0.55518985","0.5549349","0.5545946","0.5544481","0.5536909","0.5521656","0.5521113","0.5514721","0.5511701","0.55057645","0.54976434","0.5497143","0.5495352","0.54933894","0.5493386","0.54895294","0.54843205","0.5483735","0.54777205","0.54715526","0.54681706","0.546589","0.5463146","0.54612786","0.54479754","0.5440645","0.54319215","0.54189855","0.54156077","0.5407603","0.54053557","0.5405225","0.5404569"],"string":"[\n \"0.65616685\",\n \"0.64299065\",\n \"0.6374554\",\n \"0.63244987\",\n \"0.6322487\",\n \"0.6310065\",\n \"0.6286317\",\n \"0.6259193\",\n \"0.62357223\",\n \"0.6208368\",\n \"0.6159411\",\n \"0.60882986\",\n \"0.6084627\",\n \"0.60737157\",\n \"0.60300255\",\n \"0.60300255\",\n \"0.6017754\",\n \"0.5987526\",\n \"0.5984642\",\n \"0.59726226\",\n \"0.5969681\",\n \"0.59394383\",\n \"0.5935725\",\n \"0.59319305\",\n \"0.59159607\",\n \"0.5915894\",\n \"0.5896955\",\n \"0.5883881\",\n \"0.5883881\",\n \"0.5883818\",\n \"0.58621496\",\n \"0.58516526\",\n \"0.5838182\",\n \"0.5833157\",\n \"0.58171\",\n \"0.5800497\",\n \"0.5794973\",\n \"0.5785344\",\n \"0.5781255\",\n \"0.5776664\",\n \"0.5774433\",\n \"0.5764916\",\n \"0.5747197\",\n \"0.57272\",\n \"0.5710376\",\n \"0.5708299\",\n \"0.56996375\",\n \"0.56931156\",\n \"0.5689399\",\n \"0.5688714\",\n \"0.56867486\",\n \"0.5682672\",\n \"0.5664519\",\n \"0.5659953\",\n \"0.5647446\",\n \"0.56437176\",\n \"0.56211686\",\n \"0.56146085\",\n \"0.56120086\",\n \"0.5608656\",\n \"0.5603487\",\n \"0.55956006\",\n \"0.5591249\",\n \"0.55892265\",\n \"0.5577928\",\n \"0.5577665\",\n \"0.5574795\",\n \"0.55518985\",\n \"0.5549349\",\n \"0.5545946\",\n \"0.5544481\",\n \"0.5536909\",\n \"0.5521656\",\n \"0.5521113\",\n \"0.5514721\",\n \"0.5511701\",\n \"0.55057645\",\n \"0.54976434\",\n \"0.5497143\",\n \"0.5495352\",\n \"0.54933894\",\n \"0.5493386\",\n \"0.54895294\",\n \"0.54843205\",\n \"0.5483735\",\n \"0.54777205\",\n \"0.54715526\",\n \"0.54681706\",\n \"0.546589\",\n \"0.5463146\",\n \"0.54612786\",\n \"0.54479754\",\n \"0.5440645\",\n \"0.54319215\",\n \"0.54189855\",\n \"0.54156077\",\n \"0.5407603\",\n \"0.54053557\",\n \"0.5405225\",\n \"0.5404569\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59584945"},"document_rank":{"kind":"string","value":"21"}}},{"rowIdx":14789,"cells":{"query":{"kind":"string","value":"Draw Polylines for points with given thickness specified by Window Size"},"document":{"kind":"string","value":"def draw_polylines(input_img, pts, window_size):\n return cv2.polylines(input_img, np.int_([pts]), isClosed=False, color=(255, 255, 255),\n thickness=2 * window_size)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def draw_lines(self, color, points, width = 1, closed = False):\n color = spyral.color._determine(color)\n pygame.draw.aalines(self._surf, color, closed, points)","def drawLines(self):\n\t\tintersections = [[], []]\n\t\tfor l in self.lines:\n\t\t\tif l.direction == 'v':\n\t\t\t\tif l.rtc:\n\t\t\t\t\tposition = l.coordinate + int((self.width - 1) / 2)\n\t\t\t\telse:\n\t\t\t\t\tposition = int((l.coordinate * self.width / 100) if type(l.coordinate) == float else l.coordinate)\n\t\t\t\tintersections[0].append(position)\n\t\t\t\tfor yPos in range(1, self.height - 2):\n\t\t\t\t\tself.wts(yPos, position, '│', self._borderColor)\n\t\t\t\t# endpoints\n\t\t\t\tself.wts(0, position, '┬',self._borderColor)\n\t\t\t\tself.wts(self.height - 2, position, '┴', self._borderColor)\n\t\t\telif l.direction == 'h':\n\t\t\t\tif l.rtc:\n\t\t\t\t\tposition = l.coordinate + ((self.height - 1) / 2)\n\t\t\t\telse:\n\t\t\t\t\tposition = int((l.coordinate * self.height / 100) - 1 if type(l.coordinate) == float else l.coordinate)\n\t\t\t\tintersections[1].append(position)\n\t\t\t\tself.wts(position, 1, '─' * (self.width - 2), self._borderColor)\n\t\t\t\t# endpoints\n\t\t\t\tself.wts(position, 0, '├', self._borderColor)\n\t\t\t\tself.wts(position, self.width - 1, '┤', self._borderColor)\n\t\t# draw intersections\n\t\tfor x in intersections[1]:\n\t\t\tfor y in intersections[0]:\n\t\t\t\tself.wts(x, y, '┼', self._borderColor)\n\t\tself.verticalBoundaries = intersections[0]\n\t\tif self.screenBorder:\n\t\t\tself.verticalBoundaries.append(self.width)","def drawPaths(points, lines, height, lineWidth, pointRadius):\r\n\r\n\tlineArraySize = len(lines)\r\n\tpointArraySize = len(points)\r\n\tlineArrayItems = lineArraySize / 4\r\n\tpointArrayItems = pointArraySize / 2\r\n\r\n\r\n\tglLineWidth(lineWidth)\r\n\tglPointSize(pointRadius)\r\n\r\n\tglColor4f(0.0, 0.0, 1.0, 1.0)\r\n\tglNormal3f(0.0, 0.0, 1.0)\r\n\r\n\tglDisable(GL_TEXTURE_2D)\r\n\r\n\tglBegin(GL_LINES)\r\n\r\n#\tglLoadIdentity()\r\n\r\n\tfor i in range(lineArrayItems):\r\n\t\tglVertex3f(lines[i * 4], height - lines[i * 4 + 1], 0.1)\r\n\t\tglVertex3f(lines[i * 4 + 2], height - lines[i * 4 + 3], 0.1)\r\n\r\n\tglEnd()\r\n\r\n\tglBegin(GL_POINTS)\r\n\r\n#\tglLoadIdentity()\r\n\r\n\tfor i in range(pointArrayItems):\r\n\t\tglVertex3f(points[i * 2], height - points[i * 2 + 1], 0.11)\r\n\r\n\tglEnd()\r\n\r\n\tglEnable(GL_TEXTURE_2D)","def wdraw_polyline(self, wcoords, color):\r\n dpoints = []\r\n for i in range(0, len(wcoords), 2):\r\n dpoints += self.w_to_d(wcoords[i], wcoords[i+1])\r\n self.canvas.create_line(dpoints, fill=color)","def linewidth(self, size: float):\n for line in self.ax.lines:\n line.set_linewidth(size)\n self.canvas.draw()","def draw_lines(self, color, points, width=1, closed=False):\n if width == 1:\n pygame.draw.aalines(self._surf, color, closed, points)\n else:\n pygame.draw.lines(self._surf, color, closed, points, width)\n self._version += 1\n spyral.util.scale_surface.clear(self._surf)\n return self","def draw_lines(point_list, color, border_width=1):\n GL.glEnable(GL.GL_BLEND)\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\n GL.glEnable(GL.GL_LINE_SMOOTH)\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\n\n GL.glLoadIdentity()\n\n # Set line width\n GL.glLineWidth(border_width)\n\n # Set color\n if len(color) == 4:\n GL.glColor4ub(color[0], color[1], color[2], color[3])\n elif len(color) == 3:\n GL.glColor4ub(color[0], color[1], color[2], 255)\n\n GL.glBegin(GL.GL_LINES)\n for point in point_list:\n GL.glVertex3f(point[0], point[1], 0.5)\n GL.glEnd()","def drawcutline(f,layernamelist,cutline_entities_count): \r\n \r\n #layernamelist=[layernamelist[0]] \r\n layercount=0\r\n ringlist=[[[-0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]]]\r\n flashlist=buildflashlist()\r\n cutlineset=buildcutlineset() \r\n \r\n f.write(\"0\\nSECTION\\n2\\nENTITIES\\n\")\r\n \r\n for layername in layernamelist:\r\n layercount=layercount+1\r\n for polyline in cutlineset:\r\n cutline_entities_count=cutline_entities_count+1\r\n f.write(\"0\\nPOLYLINE\\n8\\n\"+layername+\"\\n5\\n\"+hex(cutline_entities_count)[2:]) # begin writing a polyline\r\n f.write(\"\\n66\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n40\\n0.08\\n41\\n0.08\\n\")\r\n cutline_entities_count=drawwidthpolyline(polyline, cutline_entities_count, f,layername)\r\n cutline_entities_count=drawring(ringlist, cutline_entities_count, f, layername)\r\n cutline_entities_count=drawflash(flashlist, cutline_entities_count, f, layername)\r\n cutline_entities_count=drawtext(cutline_entities_count, f, layername,layercount)\r\n \r\n return cutline_entities_count","def draw_lines(self):\n for x_cord in range(0, Dimension.SCREEN_WIDTH.value, Dimension.SQUARE_WIDTH.value):\n pg.draw.line(self.window, Colors.BLACK.value, (x_cord, 0), (x_cord, Dimension.SCREEN_HEIGHT.value))\n\n for y_cord in range(0, Dimension.SCREEN_HEIGHT.value, Dimension.SQUARE_HEIGHT.value):\n pg.draw.line(self.window, Colors.BLACK.value, (0, y_cord), (Dimension.SCREEN_WIDTH.value, y_cord))\n\n pg.display.update()","def draw_line():\n\n # Small Size Line\n glLineWidth(0.1)\n glColor3f(0.5, 1.0, 0.9)\n wid = 0\n while wid <= width:\n length = 0\n while length <= height:\n glBegin(GL_LINES)\n glVertex3f(0.0, length, 0.0)\n glVertex3f(wid, length, 0)\n glEnd()\n glBegin(GL_LINES)\n glVertex3f(length, 0, 0.0)\n glVertex3f(length, wid, 0)\n glEnd()\n length += 10\n wid += 50\n # Medium Size Line\n glLineWidth(2.0)\n wid = 0\n while wid <= width:\n length = 0\n while length <= height:\n glBegin(GL_LINES)\n glVertex3f(0.0, length, 0.0)\n glVertex3f(wid, length, 0)\n glEnd()\n length += 50\n glBegin(GL_LINES)\n glVertex3f(length, 0, 0.0)\n glVertex3f(length, wid, 0)\n glEnd()\n wid += 50\n # Main Line\n # ordinat\n glLineWidth(1.5)\n glColor3f(0.5, 0.4, 0.8)\n glBegin(GL_LINES)\n glVertex3f(height / 2, 0, 0.0)\n glVertex3f(height / 2, width, 0)\n glEnd()\n # absis\n glBegin(GL_LINES)\n glVertex3f(0, width / 2, 0.0)\n glVertex3f(height, width / 2, 0)\n glEnd()","def draw_line_strip(point_list, color, border_width=1):\n GL.glEnable(GL.GL_BLEND)\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\n GL.glEnable(GL.GL_LINE_SMOOTH)\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\n\n # Set line width\n GL.glLineWidth(border_width)\n\n GL.glLoadIdentity()\n\n # Set color\n if len(color) == 4:\n GL.glColor4ub(color[0], color[1], color[2], color[3])\n elif len(color) == 3:\n GL.glColor4ub(color[0], color[1], color[2], 255)\n\n GL.glBegin(GL.GL_LINE_STRIP)\n for point in point_list:\n GL.glVertex3f(point[0], point[1], 0.5)\n GL.glEnd()","def drawPoints(self, qp):\n\n# pen = self.pen\n\n\n size = self.size()\n self.yOffset = [size.height()*0.2 + size.height()*0.618/self.NUM_CHANNEL * y for y in xrange(self.NUM_CHANNEL) ]\n\n for ix in xrange(self.NUM_CHANNEL):\n self.pen.setStyle(Qt.SolidLine)\n self.pen.setWidth(2)\n self.pen.setBrush(self.PEN_COLOR[ix])\n self.pen.setCapStyle(Qt.RoundCap)\n self.pen.setJoinStyle(Qt.RoundJoin)\n qp.setPen(self.pen)\n\n qp.drawLine(self.x - 2, self.yOffset[ix] - \\\n self.data_1[ix] * self.DISPLAY_SCALING[ix],\\\n self.x , self.yOffset[ix] - \\\n self.data[ix] * self.DISPLAY_SCALING[ix])","def draw_poly(t, n, sz):\r\n\r\n\tfor i in range(n):\r\n\t\tt.forward(sz)\r\n\t\tt.left(360/n)","def L(width = 1, size = (10, 20), layer = 0):\n D = Device(name = 'L')\n w = width/2\n s1, s2 = size\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2), (-w, s2), (-w, -w)]\n D.add_polygon(points, layer = layer)\n D.add_port(name = 1, midpoint = (0, s2), width = width, orientation = 90)\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\n return D","def draw_polygon_outline(point_list, color, border_width=1):\n GL.glEnable(GL.GL_BLEND)\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\n GL.glEnable(GL.GL_LINE_SMOOTH)\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\n\n # Set line width\n GL.glLineWidth(border_width)\n\n GL.glLoadIdentity()\n\n # Set color\n if len(color) == 4:\n GL.glColor4ub(color[0], color[1], color[2], color[3])\n elif len(color) == 3:\n GL.glColor4ub(color[0], color[1], color[2], 255)\n\n GL.glBegin(GL.GL_LINE_LOOP)\n for point in point_list:\n GL.glVertex3f(point[0], point[1], 0.5)\n GL.glEnd()","def draw_polyline(self, points, line_width, line_color):\n line_color = check_color(line_color)\n STline.line(self.canvas, points, line_width, line_color)","def draw_equitriangle(t,sz):\r\n\r\n\tdraw_poly(t, 3, sz)","def drawWarpLines(self):\n # draw warp lines\n for item in self.game.warpLines:\n anwp.sl.engine.drawLine(item[0]+self.bufferX, item[1]+self.bufferY, item[2]+self.bufferX, item[3]+self.bufferY, pyui.colors.blue)","def draw_polyline(*points):\r\n global _canvas\r\n if _canvas == None:\r\n raise RuntimeError(\"Canvas is not open yet.\")\r\n else:\r\n #print(points)\r\n #print(len(points))\r\n newpoints = []\r\n for x in range(0, len(points), 2):\r\n #print(x)\r\n pt = Point(points[x], points[x+1])\r\n newpoints += [ pt ]\r\n #print(newpoints)\r\n path = Path(*newpoints)\r\n path.setBorderWidth(_current_line_thickness)\r\n path.setBorderColor(_current_color)\r\n _canvas.add(path)","def graphicsDraw(self, win, center):\n\t\tlastPoint = None\n\t\tfor p in self.points:\n\t\t\tthisPoint = Point(p[0] + center.x, p[1] + center.y)\n\t\t\tif lastPoint is not None:\n\t\t\t\tline = Line(lastPoint, thisPoint)\n\t\t\t\tline.draw(win)\n\t\t\tlastPoint = thisPoint","def draw_lines(img, lines, color=[0, 0, 255], thickness=10):\n \n yFinal = 540 # tweak these values as per the frame size\n yIni = 350\n xPlus = []\n yPlus = []\n xMinus = []\n yMinus= []\n slope_range = 0.2\n\n if lines is not None:\n for line in lines:\n if line is not None:\n for x1,y1,x2,y2 in line:\n # check slope \n slope = (y2-y1)/(x2-x1)\n\t\t \n \t\t # Collect all points with + ve slope (right lane)\n if (slope > slope_range):\n xPlus.append(x1)\n xPlus.append(x2)\n yPlus.append(y1)\n yPlus.append(y2)\n\n # Collect all points with - ve slope (left lane)\n elif ((slope) < (-slope_range)):\n xMinus.append(x1)\n xMinus.append(x2)\n yMinus.append(y1)\n yMinus.append(y2)\n # If out of range, lists defined in beginning of this function will be empty \n else:\n continue\n \n # draw right lane\n x1,y1,x2,y2 = fit_line(xPlus, yPlus, yIni, yFinal)\n cv2.line(img,(x1,y1),(x2,y2),color, thickness) \n\n # draw left lane\n x1,y1,x2,y2 = fit_line(xMinus, yMinus, yIni, yFinal)\n cv2.line(img,(x1,y1),(x2,y2),color,thickness)","def set_spines(plot):\n for spines in plot.spines.values():\n spines.set_linewidth(.2)","def line_layer(self):\n screen_origin = self.ids.mapview.get_window_xy_from(lat1, lon1, self.ids.mapview.zoom)\n screen_destination = self.ids.mapview.get_window_xy_from(lat2, lon2, self.ids.mapview.zoom)\n point_list = [screen_origin[0], screen_origin[1], screen_destination[0], screen_destination[1]]\n\n with self.ids.line.canvas:\n self.ids.line.canvas.clear()\n\n Color(0, 0, 0, .6)\n Line(points=point_list, width=3, joint=\"bevel\")","def setLineWidth(w=1):\n dislin.linwid(w)","def to_strokes(self, width:float, color:list):\n # corner points\n # NOTE: center line of path without stroke width considered\n x0, y0, x1, y1 = self.rect\n points = [\n (x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)\n ]\n # connect each line\n strokes = []\n for i in range(len(points)-1):\n strokes.append({\n 'start': points[i],\n 'end' : points[i+1],\n 'width': width * 2.0, # seems need adjustment by * 2.0\n 'color': rgb_value(color)\n })\n return strokes","def plot(self, frame, fit, thickness=2):\n if not fit:\n return frame\n X,Y = fit.linspace()\n X = np.array(X,dtype=np.int32)\n Y = np.array(Y,dtype=np.int32)\n curve = np.column_stack((X,Y))\n cv2.polylines(frame, [curve], False, color=(0,0,255),thickness=thickness)\n return frame","def draw_lines(display, coord, box_size, color, bg_color):\n left, top = coord\n stroke = 6\n half_stroke = int(stroke / 2)\n left = left + half_stroke\n top = top + half_stroke\n box_size = box_size - stroke\n for i in range(0, box_size, int(stroke + 2)):\n pygame.draw.line(\n display, color,\n (left, top + i),\n (left + i, top),\n stroke,\n )\n pygame.draw.line(\n display, color,\n (left + i, top + box_size - 1),\n (left + box_size - 1, top + i),\n stroke,\n )\n return","def draw_lines(self):\n # draw x lines\n y = self.step_y\n while y <= self.height:\n x = 0\n while x <= self.width:\n self.canvas.create_line(x, y, x+3.5, y)\n self.canvas.update()\n x += 3.5\n y += self.step_y\n \n # draw y lines\n x = self.step_x\n while x <= self.width:\n y = 0\n while y <= self.height:\n self.canvas.create_line(x, y, x, y+3.5)\n self.canvas.update()\n y += 3.5\n x += self.step_x\n \n self.is_operating = False","def plot_insertsize():","def line(canvas, points, line_width, line_color):\n \n # duplicate first point in case only one point was given\n points = points[0], points\n canvas.create_line(points, width = int(line_width), fill = line_color)","def drawSlope(self):\n length = sqrt(1 + self.slope**2) # Length of the line segment over 1 x-unit\n xOffset = (segmentLength / length) / 2 # Figures out how many times the length of the 1 unit length fits into the desired length\n # then divides by 2 becuase half is on the left and half on the right of the center\n\n\n # Left end point\n xLeft = self.x - xOffset\n yLeft = (self.slope * (xLeft - self.x)) + self.y\n\n # Right end point\n xRight = self.x + xOffset\n yRight = (self.slope * (xRight - self.x)) + self.y\n\n\n # Converts the left and right end points from cartesian coordinates to screen coordinates\n left = cartesianToScreen(xLeft , yLeft)\n right = cartesianToScreen(xRight, yRight)\n\n\n pygame.draw.aaline(display, self.color, left, right, 1) # DRAWS THE LINE AHHHHHHHHHHHHHHHHHH :P","def draw_polygon(self, points, line_width, line_color, fill_color = \"\"):\n line_color, fill_color = check_color(line_color), check_color(fill_color)\n STpolygon.polygon(self.canvas, points, line_width, line_color, fill_color)","def set_line_thickness(thickness):\r\n global _current_line_thickness\r\n _current_line_thickness = thickness","def draw_poly(t, n, sz):\n\tfor side in range(n):\n\t\tangle = (360/n)\n\t\tt.pendown()\n\t\tt.forward(sz)\n\t\tt.right(angle)","def powerpoint_style2(Axe_tick_size=15,Line_size=3) : \n fig = plt.gcf()\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n for ax in fig.axes:\n \n # trouve tous les trucs avec linewidth et les modifie\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\n item.set_fontsize(Axe_tick_size)\n \n #for item in ([ax.xaxis.label, ax.yaxis.label]):\n # item.set_fontsize(Axe_tick_size+5)\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size)","def plot_endpoints( polylines, mymap ):\n map( \\\n lambda start : mymap.addpoint( start[-1][0], start[-1][1], \"#0000FF\") if start != [] else [],\n polylines)","def borders(w, h):\r\n pygame.draw.line(window, WHITE, [25, 0], [25, h - 50], 6)\r\n pygame.draw.line(window, WHITE, [w - 25, 0], [w - 25, h - 50], 6)\r\n pygame.draw.line(window, WHITE, [25, h - 50], [w - 25, h - 50], 6)\r\n pygame.draw.line(window, WHITE, [25, 25], [w - 25, 25], 6)","def draw_line(self, start_p, end_p, color, thickness: float):\n line_seg = LineSegs(\"interface\")\n line_seg.setColor(*color)\n line_seg.moveTo(start_p[0] * self.w_scale, 0, start_p[1] * self.h_scale)\n line_seg.drawTo(end_p[0] * self.w_scale, 0, end_p[1] * self.h_scale)\n line_seg.setThickness(thickness)\n line_np = self.aspect2d.attachNewNode(line_seg.create(False))\n return line_np","def lines(draw, coordinates: List[Tuple[float, float]], width=1, color=\"#AAAAAAFF\") -> None:\n coords = [pixelcoord(*c) for c in coordinates]\n draw.line(coords, color, width)","def draw_poly(t, n, sz):\n\n s_intern_angles = (n - 2) * 180\n for i in range(n):\n t.forward(sz)\n t.left(180 - s_intern_angles / n)\n time.sleep(5)\n turtle.Screen().clear()","def get_points_for_thick_line(start_x: float, start_y: float,\r\n end_x: float, end_y: float,\r\n line_width: float):\r\n vector_x = start_x - end_x\r\n vector_y = start_y - end_y\r\n perpendicular_x = vector_y\r\n perpendicular_y = -vector_x\r\n length = math.sqrt(vector_x * vector_x + vector_y * vector_y)\r\n if length == 0:\r\n normal_x = 1.0\r\n normal_y = 1.0\r\n else:\r\n normal_x = perpendicular_x / length\r\n normal_y = perpendicular_y / length\r\n r1_x = start_x + normal_x * line_width / 2\r\n r1_y = start_y + normal_y * line_width / 2\r\n r2_x = start_x - normal_x * line_width / 2\r\n r2_y = start_y - normal_y * line_width / 2\r\n r3_x = end_x + normal_x * line_width / 2\r\n r3_y = end_y + normal_y * line_width / 2\r\n r4_x = end_x - normal_x * line_width / 2\r\n r4_y = end_y - normal_y * line_width / 2\r\n points = (r1_x, r1_y), (r2_x, r2_y), (r4_x, r4_y), (r3_x, r3_y)\r\n return points","def plot_control_points(self, fig, ax, linewidth=1.25, linestyle='-.', color='red', markersize=5, markerstyle='o'):\n\n # One dimension (law of evolution)\n if self.ndim == 1:\n Px = np.real(self.P)\n u = np.linspace(0, 1, Px.size)\n line, = ax.plot(u, Px[0,:])\n line.set_linewidth(linewidth)\n line.set_linestyle(linestyle)\n line.set_color(color)\n line.set_marker(markerstyle)\n line.set_markersize(markersize)\n line.set_markeredgewidth(linewidth)\n line.set_markeredgecolor(color)\n line.set_markerfacecolor('w')\n line.set_zorder(4)\n # line.set_label(' ')\n\n\n # Two dimensions (plane curve)\n elif self.ndim == 2:\n Px, Py = np.real(self.P)\n line, = ax.plot(Px, Py)\n line.set_linewidth(linewidth)\n line.set_linestyle(linestyle)\n line.set_color(color)\n line.set_marker(markerstyle)\n line.set_markersize(markersize)\n line.set_markeredgewidth(linewidth)\n line.set_markeredgecolor(color)\n line.set_markerfacecolor('w')\n line.set_zorder(4)\n # line.set_label(' ')\n\n # Three dimensions (space curve)\n elif self.ndim == 3:\n Px, Py, Pz = np.real(self.P)\n line, = ax.plot(Px, Py, Pz)\n line.set_linewidth(linewidth)\n line.set_linestyle(linestyle)\n line.set_color(color)\n line.set_marker(markerstyle)\n line.set_markersize(markersize)\n line.set_markeredgewidth(linewidth)\n line.set_markeredgecolor(color)\n line.set_markerfacecolor('w')\n line.set_zorder(4)\n # line.set_label(' ')\n\n else: raise Exception('The number of dimensions must be 2 or 3')\n\n return fig, ax","def linecut_points( **kwargs ):\n npoints = kwargs.get('npoints', 320)\n extents = kwargs.get('extents',None)\n lims = kwargs.get('lims', (-80.,80.))\n direc = kwargs.get('direc', (np.pi/2, 0.))\n origin = kwargs.get('origin', vec3(0.,0.,0.))\n\n if extents is not None:\n lims = (-extents, extents)\n\n # Prepare set of points for plot \n t = np.linspace( lims[0], lims[1], npoints )\n unit = vec3()\n th = direc[0]\n ph = direc[1] \n unit.set_spherical(1, th, ph) \n # Convert vec3s to ndarray\n unit = np.array(unit)\n origin = np.array(origin) \n #\n XYZ = origin + np.outer(t, unit)\n X = XYZ[:,0]\n Y = XYZ[:,1]\n Z = XYZ[:,2]\n \n return t, X, Y, Z, lims","def draw_ellipse_outline(center_x, center_y, width, height, color,\n border_width=1, tilt_angle=0):\n\n num_segments = 128\n\n GL.glEnable(GL.GL_BLEND)\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\n GL.glEnable(GL.GL_LINE_SMOOTH)\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\n\n GL.glLoadIdentity()\n GL.glTranslatef(center_x, center_y, 0)\n GL.glRotatef(tilt_angle, 0, 0, 1)\n GL.glLineWidth(border_width)\n\n # Set color\n if len(color) == 4:\n GL.glColor4ub(color[0], color[1], color[2], color[3])\n elif len(color) == 3:\n GL.glColor4ub(color[0], color[1], color[2], 255)\n\n GL.glBegin(GL.GL_LINE_LOOP)\n for segment in range(num_segments):\n theta = 2.0 * 3.1415926 * segment / num_segments\n\n x = width * math.cos(theta)\n y = height * math.sin(theta)\n\n GL.glVertex3f(x, y, 0.5)\n\n GL.glEnd()\n GL.glLoadIdentity()","def powerpoint_style3(fig,Axe_tick_size=15,Line_size=3) : \n #fig = plt.gcf()\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n for ax in fig.axes:\n \n # trouve tous les trucs avec linewidth et les modifie\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\n item.set_fontsize(Axe_tick_size)\n \n #for item in ([ax.xaxis.label, ax.yaxis.label]):\n # item.set_fontsize(Axe_tick_size+5)\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size) \n \n \n \n #fig.show()","def pixelize(\n layer: vp.LineCollection,\n pen_width: float | None,\n mode: str,\n keep_lines: bool,\n overdraw: float,\n):\n\n if pen_width is None:\n pen_width = layer.property(vp.METADATA_FIELD_PEN_WIDTH) or vp.convert_length(\"0.6mm\")\n color = layer.property(vp.METADATA_FIELD_COLOR) or vp.Color(\"black\")\n color = color.red, color.green, color.blue\n\n pixel_pitch = pen_width\n if mode == \"big\":\n pixel_pitch *= 5\n\n bounds = layer.bounds()\n if bounds is None:\n logging.warning(\"!!! pixelize: layer is empty\")\n return layer\n x_min, y_min, x_max, y_max = bounds\n\n img_size = (\n math.ceil((x_max - x_min) / pixel_pitch),\n math.ceil((y_max - y_min) / pixel_pitch),\n )\n img = Image.new(\"RGBA\", img_size)\n draw = ImageDraw.Draw(img)\n for line in layer:\n draw.line(\n [(pt.real, pt.imag) for pt in (line - x_min - 1j * y_min) / pixel_pitch],\n fill=color,\n )\n\n doc = vp.Document()\n if mode == \"big\":\n # noinspection PyTypeChecker\n big_mode(doc, np.array(img), np.array([color]), pen_width)\n elif mode == \"line\":\n # noinspection PyTypeChecker\n line_mode(doc, np.array(img), np.array([color]), pen_width, overdraw)\n elif mode == \"snake\":\n # noinspection PyTypeChecker\n snake_mode(doc, np.array(img), np.array([color]), pen_width)\n\n doc.translate(x_min, y_min)\n\n if keep_lines:\n layer.extend(doc.layers[1])\n layer.set_property(vp.METADATA_FIELD_PEN_WIDTH, pen_width)\n return layer\n else:\n result = layer.clone(doc.layers[1])\n result.set_property(vp.METADATA_FIELD_PEN_WIDTH, pen_width)\n return result","def centerline_to_polygon(\n centerline: np.ndarray, width_scaling_factor: float = 1.0, visualize: bool = False\n) -> np.ndarray:\n # eliminate duplicates\n _, inds = np.unique(centerline, axis=0, return_index=True)\n # does not return indices in sorted order\n inds = np.sort(inds)\n centerline = centerline[inds]\n\n dx = np.gradient(centerline[:, 0])\n dy = np.gradient(centerline[:, 1])\n\n # compute the normal at each point\n slopes = dy / dx\n inv_slopes = -1.0 / slopes\n\n thetas = np.arctan(inv_slopes)\n x_disp = 3.8 * width_scaling_factor / 2.0 * np.cos(thetas)\n y_disp = 3.8 * width_scaling_factor / 2.0 * np.sin(thetas)\n\n displacement = np.hstack([x_disp[:, np.newaxis], y_disp[:, np.newaxis]])\n right_centerline = centerline + displacement\n left_centerline = centerline - displacement\n\n # right centerline position depends on sign of dx and dy\n subtract_cond1 = np.logical_and(dx > 0, dy < 0)\n subtract_cond2 = np.logical_and(dx > 0, dy > 0)\n add_cond1 = np.logical_and(dx < 0, dy < 0)\n add_cond2 = np.logical_and(dx < 0, dy > 0)\n subtract_cond = np.logical_or(subtract_cond1, subtract_cond2)\n add_cond = np.logical_or(add_cond1, add_cond2)\n left_centerline, right_centerline = swap_left_and_right(subtract_cond, left_centerline, right_centerline)\n\n # right centerline also depended on if we added or subtracted y\n neg_disp_cond = displacement[:, 1] > 0\n left_centerline, right_centerline = swap_left_and_right(neg_disp_cond, left_centerline, right_centerline)\n\n if visualize:\n plt.scatter(centerline[:, 0], centerline[:, 1], 20, marker=\".\", color=\"b\")\n plt.scatter(right_centerline[:, 0], right_centerline[:, 1], 20, marker=\".\", color=\"r\")\n plt.scatter(left_centerline[:, 0], left_centerline[:, 1], 20, marker=\".\", color=\"g\")\n fname = datetime.datetime.utcnow().strftime(\"%Y_%m_%d_%H_%M_%S_%f\")\n plt.savefig(f\"polygon_unit_tests/{fname}.png\")\n plt.close(\"all\")\n\n # return the polygon\n return convert_lane_boundaries_to_polygon(right_centerline, left_centerline)","def draw_poly(t, n, sz):\r\n angle = 180 - (n - 2) * 180 / n\r\n for i in range(n):\r\n t.forward(sz)\r\n t.left(angle)","def add_polyline(self, layer_to_use,poly,open):\n if type(poly) is not list:\n toplot = [poly]\n else:\n toplot = poly\n\n for y in toplot:\n\n polyline = self.msp.add_polyline2d(\n points=[],\n dxfattribs={'layer': layer_to_use['name']})\n\n if open==True:\n polyline.close(False)\n else:\n polyline.close(True)\n y = np.round(100*y)/100\n if layer_to_use['inversion']==0:\n polyline.append_vertices(y)\n else:\n polyline.append_vertices(-y)","def draw_spline(env, spline, num=100, linewidth=1.0, colors=(0,0,1),\n start=0, stop=1):\n linestrip = []\n for u in np.linspace(start, stop, num=num):\n linestrip.append(spline(u))\n h = env.drawlinestrip(np.array(linestrip), linewidth=linewidth,\n colors=np.array(colors))\n return h","def draw_lines(args, img, lines, color=[255, 0, 0], thickness=8):\n slopes = [ (line[0][3]-line[0][1])/(line[0][2]-line[0][0]) for line in lines]\n rights = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope > 0.0 ] # and slope < 0.5 and not np.isnan(slope) ]\n lefts = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope < 0.0 ] # and slope > -0.5 and not np.isnan(slope) ]\n #lefts[0] = [ [[x1,y1,x2,y2]] , slope , y_intercept ]\n\n y_mins = [ min(line[0][1],line[0][3]) for line in lines]\n y_min = min(y_mins)\n y_max = img.shape[0]\n\n log_new = [slopes, rights, lefts, y_mins, y_min, y_max]\n\n for lanes in [rights,lefts]:\n slope_mean = np.mean( [ lane[1] for lane in lanes ] )\n slope_std = np.std ( [ lane[1] for lane in lanes ] )\n if slope_std == 0:\n slope = slope_mean\n else:\n slope = np.mean( [ lane[1] for lane in lanes if lane[1] - slope_mean < 2*slope_std ] ) \n print()\n print('slope : {}'.format(slope))\n\n intercept_mean = np.mean( [ lane[2] for lane in lanes ] )\n intercept_std = np.std ( [ lane[2] for lane in lanes ] )\n if intercept_std == 0:\n intercept = intercept_mean\n else:\n intercept = np.mean( [ lane[2] for lane in lanes if lane[2] - intercept_mean < 2*intercept_std ] )\n print('intercept : {}'.format(intercept))\n \n x_min = int( ( y_min - intercept ) / slope ) \n x_max = int( ( y_max - intercept ) / slope )\n\n log_new.append(slope)\n log_new.append(intercept)\n log_new.append(x_min)\n log_new.append(x_max)\n\n cv2.line(img, (x_min, y_min), (x_max, y_max), color, thickness)\n\n try: \n log_line = pd.read_csv(args.path+args.csv_file, skiprows=[0], names=args.header)\n except:\n log_line = pd.DataFrame([ ], columns=args.header)\n finally:\n df = pd.DataFrame([ log_new ], columns=args.header)\n # update log: add new entry into the log\n result = pd.concat([log_line, df], ignore_index=True)\n result.to_csv(args.path+args.csv_file) #, index=False)","def plot_lines(line_list, line_width=1.0):\n \n for line in line_list: \n start_lat, end_lat, start_lon, end_lon, color, style, input_projection, resolution = line\n \n assert style in list(line_style_dict.keys())\n assert resolution in ['high', 'low']\n\n start_lat = float(start_lat)\n start_lon = float(start_lon)\n end_lat = float(end_lat)\n end_lon = float(end_lon)\n\n lons = iris.analysis.cartography.wrap_lons(numpy.array([start_lon, end_lon]), 0, 360)\n # FIXME: start=0 might not work for all input/output projection combos\n\n if resolution == 'low':\n lats = numpy.array([start_lat, end_lat]) \n elif resolution == 'high':\n assert start_lat == end_lat or start_lon == end_lon, \\\n \"High res lines need constant lat or lon in reference coordinate system\"\n\n if start_lat == end_lat:\n lons = numpy.arange(lons[0], lons[-1] + 0.5, 0.5)\n lats = numpy.repeat(start_lat, len(lons))\n else:\n lats = numpy.arange(start_lat, end_lat + 0.5, 0.5)\n lons = numpy.repeat(lons[0], len(lats))\n\n plt.plot(lons, lats, \n linestyle=line_style_dict[style], \n color=color, linewidth=line_width,\n transform=input_projections[input_projection])","def _drawpoly(self, polyitem, coordlist, fill=None,\n outline=None, width=None, top=False):\n cl = []\n for x, y in coordlist:\n cl.append(x * self.xscale)\n cl.append(-y * self.yscale)\n self.cv.coords(polyitem, *cl)\n if fill is not None:\n self.cv.itemconfigure(polyitem, fill=fill)\n if outline is not None:\n self.cv.itemconfigure(polyitem, outline=outline)\n if width is not None:\n self.cv.itemconfigure(polyitem, width=width)\n if top:\n self.cv.tag_raise(polyitem)","def draw_grid(plt):\n x0, x1, x2, x3 = 0, 3057, 6508, 9860\n y0, y1, y2, y3, y4, y5, y6, y7, y8 = 0, 1535, 2041, 2547, 3053, 3559, 4257, 5303, 6978\n alpha, linewidth = 0.3, 0.5\n\n # Vertical Lines\n plt.plot((x0, x0), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x1, x1), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x2, x2), (y0, y5), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x3, x3), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n\n # Horizontal Lines\n plt.plot((x0, x3), (y0, y0), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y1, y1), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y2, y2), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y3, y3), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y4, y4), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y5, y5), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x1), (y6, y6), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x1, x3), (y7, y7), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y8, y8), 'black', alpha=alpha, linewidth=linewidth)","def DrawRectanglePointSize(*args, **kwargs):\n return _gdi_.PseudoDC_DrawRectanglePointSize(*args, **kwargs)","def draw_line(self, DISP, side:str, indizes:tuple, pink = False):\r\n offset = 1 #< Just to draw the line nicely\r\n pos = (indizes[0] - 1) * self.grid_size, indizes[1] * self.grid_size\r\n # Check if it's a pink line\r\n if pink:\r\n start_pos = pos[0], pos[1] + self.grid_size // 2\r\n end_pos = pos[0] + self.grid_size, pos[1] + self.grid_size // 2\r\n # Check if the line should be vertically. u for up\r\n elif side == 'u':\r\n start_pos = pos[0] + self.width - offset + self.grid_size // 2, pos[1] + self.grid_size // 2\r\n end_pos = pos[0] + self.grid_size + offset + self.grid_size // 2 - self.width, pos[1] + self.grid_size // 2\r\n # Check if the line should be horizontally. l for left\r\n elif side == 'l':\r\n start_pos = pos[0] + self.grid_size // 2, pos[1] + self.width - offset + self.grid_size // 2\r\n end_pos = pos[0] + self.grid_size // 2, pos[1] - self.width + self.grid_size + offset + self.grid_size // 2\r\n if not pink:\r\n pg.draw.line(DISP, Colors.colors['BLACK'], start_pos,end_pos, self.width + 2 * offset) \r\n else:\r\n pg.draw.line(DISP, Colors.colors['PINK'], start_pos,end_pos, self.width + 2 * offset)","def drawShapes(self):\n self.draw_polygon(self.poly3.get_points() , color = \"#000\")\n self.draw_polygon(self.poly2.get_points() , color = \"#000\")\n self.draw_polygon(self.poly1.get_points() , color = \"#000\")\n self.draw_rect(0, 0, self.width, self.height, color= \"#000\")\n \"\"\"These statements are used to determine if a point is inside any of the\n 3 polygons and if so changes the point's color\"\"\"\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\n or self.poly3.point_inside_polygon(self.p1)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\n\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\n or self.poly3.point_inside_polygon(self.p2)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\n or self.poly3.point_inside_polygon(self.p3)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)","def increase_point_thickness(pt,grid_size):\n\n\tif grid_size % 2 == 0:\n\t\treturn ValueError(\"Grid Size must be odd\")\n\t\n\tgrid_width = int((grid_size -1) / 2)\n\tpt_list = []\n\tfor j in range(-grid_width,grid_width + 1):\n\t\tleft_list = [(pt[0] - j,pt[1] - i) for i in range(1,grid_width + 1)]\n\t\tright_list = [(pt[0] - j,pt[1] + i) for i in range(1,grid_width + 1)]\n\t\tmiddle_list = left_list + [(pt[0] - j,pt[1])] + right_list\n\t\tpt_list.extend(middle_list)\n\n\treturn pt_list","def draw_combined(self, points: Iterable[Tuple[float, float, float, float, Text]],eps: float = 1e-8):\n for i, p in enumerate(points[1:-1]):\n last_p = points[i]\n next_p = points[i+2]\n w = sum([last_p[2], p[2], next_p[2]]) / 3.\n self.output.write(f'<polyline points=\"{round(last_p[0])},{round(last_p[1])} {round(p[0])},{round(p[1])} {round(next_p[0])},{round(next_p[1])}\" style=\"fill:none;stroke:{p[4]};stroke-width:{w};opacity:{p[3]}\" />')\n last_p = p","def add_poly_corners(self, poly_item, marker_dict=None):\n poly = poly_item.polygon()\n\n for i in range(poly.size()):\n point = poly.at(i)\n p = self.addEllipse(-4, -4, 8, 8, self.LUBronze, self.LUBronze)\n p.setZValue(2) # Make sure corners always in front of polygon surfaces\n p.setParentItem(poly_item)\n p.__setattr__(\"localIndex\", int(i))\n p.setPos(point.x(), point.y())\n p.setFlag(QGraphicsItem.ItemIsSelectable)\n p.setFlag(QGraphicsItem.ItemIsMovable)\n self.point_coord_list = np.append(self.point_coord_list, [[p.x(), p.y()]], axis=0)\n\n self.potential_edge_splitters.append(p)\n\n # Used to pass markers when loading a g\n if marker_dict:\n if i in marker_dict:\n self.add_marker(p, marker_dict[i])\n text = p.childItems()[0]\n text.setVisible(False)","def onscreen_pres(mpl, screenwidth=1200):\n mpl.rcParams['lines.linewidth'] = 2\n fontsize = round(14 / (800.0 / screenwidth))\n mpl.rcParams['font.size'] = fontsize","def onChartSeriesLineWidthChanged(self, name, width):\n series = self.series[name]\n self.pen[name].setWidth(width)\n series.setPen(self.pen[name])","def rect(x: float, y: float, width: float, height: float) -> LineCollection:\n return LineCollection(\n [\n (\n complex(x, y),\n complex(x + width, y),\n complex(x + width, y + height),\n complex(x, y + height),\n complex(x, y),\n )\n ]\n )","def addLine(self, verts, color=[220,0,0], thickness=1.0, alpha=255,\n linestyle='=', selectable=True, movable=True, isCosmetic=False):\n\n # addLine is just a simplified interface to addPolygon\n return QViewerBase.addPolygon(self, verts, color=color, thickness=thickness, alpha=alpha,\n linestyle=linestyle, selectable=selectable, movable=movable,\n closed=False, isCosmetic=isCosmetic)","def connect_poly(self):\n\n offset = self.lower_pmos_inst.get_pin(\"G\").ll()\n # connects the top and bottom pmos' gates together\n ylength = self.upper_pmos1_inst.get_pin(\"G\").ll().y - offset.y\n self.add_rect(layer=\"poly\",\n offset=offset,\n width=self.poly_width,\n height=ylength)\n\n # connects the two poly for the two upper pmos(s)\n offset = offset + vector(0, ylength - self.poly_width)\n xlength = self.upper_pmos2_inst.get_pin(\"G\").lx() - self.upper_pmos1_inst.get_pin(\"G\").lx() + self.poly_width\n self.add_rect(layer=\"poly\",\n offset=offset,\n width=xlength,\n height=self.poly_width)","def pp(points):\n plt.plot(points[:,0], points[:,1], '.--')\n plt.gca().set_aspect('equal', 'box')","def display(points: List[Point], color, width=1) -> None:\n x = []\n y = []\n for point in points:\n x.append(point[0])\n y.append(point[1])\n plt.plot(x, y, c=color, linewidth=width)","def hLine(x_min, x_max, y):\n glClear(GL_COLOR_BUFFER_BIT)\n glColor3f(1.0, 0.0, 0.0)\n glPointSize(10.0) # Set the point with a specific radius\n glBegin(GL_POINTS) # Begin plotting point\n x = x_min\n while (x <= x_max):\n glVertex2f(x, y)\n x += 0.05\n glEnd()\n glFlush()","def draw_line(mat, pt1, pt2, color=(0, 0, 255), thickness=1):\n cv2.line(mat, pt1, pt2, color, thickness=thickness)","def draw_polygon(self, *points, color=DEFAULT.color):","def draw(self, image, color, width, quad=None):\n if image is None:\n image = self.image.copy()\n if quad is None:\n quad = self.quad\n color = tuple(np.int32(color).tolist())\n cv2.polylines(image, [np.int32(quad)], True, color, int(width))\n return image","def wdraw_polygon(self, wcoords, fill, outline):\r\n dpoints = []\r\n for i in range(0, len(wcoords), 2):\r\n dpoints += self.w_to_d(wcoords[i], wcoords[i+1])\r\n self.canvas.create_polygon(dpoints, fill=fill, outline=outline)","def plot_startpoints( polylines, mymap ):\n map( \\\n lambda start : mymap.addpoint( start[0][0], start[0][1], \"#FF0000\") if start != [] else [],\n polylines)","def draw(self):\n if len(self.__points) >= 2:\n self._total_length = 0\n for i in range(len(self.__points) - 1):\n p1 = self.__points[i]\n p2 = self.__points[i + 1]\n coords = self.__line_segment(p1, p2)\n if not coords is None:\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\n [0, 1, 2, 1, 2, 3],\n ('v2i', coords),\n ('c4b', self.color * 4)\n )\n coords = self.__line_cap(p2)\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\n [0, 1, 2, 0, 2, 3],\n ('v2i', coords),\n ('c4b', self.color * 4)\n )","def draw_line(self, color, p1: Point, p2: Point, width):\n _p1 = self.T.itrans(p1)\n _p2 = self.T.itrans(p2)\n pg.draw.line(self.screen, color, _p1(), _p2(), 2)","def whirl_plot(polygons, iterations, step, fpath, **kwargs):\n for polygon in polygons:\n for _ in range(iterations):\n # pylint: disable=invalid-name\n xy = np.vstack([polygon, polygon[0]])\n plt.plot(*np.hsplit(xy, 2), **kwargs)\n\n diff = polygon - np.roll(polygon, 1, axis=0)\n norm_velocity = diff / np.linalg.norm(diff, axis=1, keepdims=True)\n\n polygon -= step * norm_velocity\n\n plt.gca().set_aspect(\"equal\")\n plt.gca().axis(\"off\")\n\n canvas = FigureCanvasAgg(plt.gcf())\n canvas.draw()\n\n stream, (width, height) = canvas.print_to_buffer()\n img = np.fromstring(stream, np.uint8).reshape((height, width, 4))\n\n plt.imsave(fpath, _trim_border(img))","def draw_poly(drawer, center, sides, scale, color=None, border=None, rotation=0):\n if color is None and border is None:\n raise ValueError(\"There must be a value for color or border.\")\n\n center = center[0] + center[1] * 1j\n\n # Repeat the first coordinate at the end to make border drawing simpler.\n corners = [\n center + cmath.rect(scale, 2 * k * cmath.pi / sides + rotation)\n for k in range(sides + 1)\n ]\n corners = [(z.real, z.imag) for z in corners]\n\n if color is not None:\n drawer.polygon(corners[:sides], fill=color)\n\n if border is not None:\n for i in range(sides):\n drawer.line((corners[i], corners[i + 1]), fill=border, width=(scale // 10))","def draw_point(self, p):\n length = 3\n self.set_line_width(0.1)\n self.set_source_rgba(0, 0, 1, 1)\n self.move_to(p.x + length, p.y)\n self.line_to(p.x - length, p.y)\n self.stroke()\n self.move_to(p.x, p.y + length)\n self.line_to(p.x, p.y - length)\n self.stroke()","def _line_for_legend():\n points = [\n [0, 0, 0],\n [0.4, 0, 0],\n [0.4, 0.07, 0],\n [0, 0.07, 0],\n [\n 0.5,\n 0,\n 0,\n ], # last point needed to expand the bounds of the PolyData to be rendered smaller\n ]\n legendface = pyvista.PolyData()\n legendface.points = np.array(points)\n legendface.faces = [4, 0, 1, 2, 3]\n return legendface","def wdraw_line(self, wx0, wy0, wx1, wy1, color, arrow):\r\n dx0, dy0 = self.w_to_d(wx0, wy0)\r\n dx1, dy1 = self.w_to_d(wx1, wy1)\r\n self.canvas.create_line(dx0, dy0, dx1, dy1, fill=color, arrow=arrow)","def redraw_whole_plot(self):\n pcent_rand = self.rand\n pcent_decimal = pcent_rand/100\n self.x = np.array([\n n*np.random.uniform(low=1-pcent_decimal, high=1+pcent_decimal) \n for n in np.linspace(3, 9, self.num_points)\n ])\n self.y = np.array([\n n*np.random.uniform(low=1-pcent_decimal, high=1+pcent_decimal)\n for n in np.linspace(3, 9, self.num_points)\n ])\n self.redraw_slope()","def road_lines():\n cv2.polylines(frame_1, [pts_1], True, yellow_color)\n cv2.polylines(frame_2, [pts_2], True, yellow_color)","def StrokeLines(*args, **kwargs):\n return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs)","def drawPolyline(points, ax, linespec=None):\n if len(points.shape) != 2 or points.shape[0] != 2:\n raise ValueError(\"'points' must be 2xN\")\n if linespec is None:\n linespec = __color_cycle.next() + 'o-'\n ax.plot(points[0,:].T, points[1,:].T, linespec)","def __draw_polygon(self, event, klick):\n global creating_polygon\n curX = self.canvas.canvasx(event.x)\n curY = self.canvas.canvasy(event.y)\n if not klick and len(self.polygon_points) >= 2:\n c_r_x, c_r_y = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\n distanceX = curX - c_r_x\n distanceY = curY - c_r_y\n if pow(pow(distanceX, 2) + pow(distanceY, 2), 1 / 2) <= 15:\n return\n image_relative_x, image_relative_y = self.get_image_relative_coords((curX, curY))\n self.polygon_points.extend((image_relative_x, image_relative_y))\n self.polygon_groundstructure.append(self.canvas.create_rectangle(curX - 2, curY - 2, curX + 2, curY + 2,\n outline='magenta', width=1,\n activewidth=2))\n if not creating_polygon: # start with a new polygon\n creating_polygon = True\n return\n else: # draw a line between the last points\n c_r_x1, c_r_y1 = self.get_canvas_relative_coords((self.polygon_points[-4], self.polygon_points[-3]))\n c_r_x2, c_r_y2 = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\n self.polygon_groundstructure.append(self.canvas.create_line([c_r_x1, c_r_y1, c_r_x2, c_r_y2],\n fill='magenta', width=2))","def show_path_2D(start, end, coordinates, polygons, clear = True):\n global L, N, delta_t\n\n # start interactive mode\n plt.ion()\n\n # crete eempty figure on which data will go and first subplot\n fig = plt.figure()\n\n # get into the correct time step\n for time_step in range(start, end):\n # list of colours used for animation\n colours = cm.rainbow(np.linspace(0, 1, N))\n\n # loop over each particle and colour\n for i in range(N):\n # plot x, y poistion of particle in a given colour and set axis to size of box\n plt.scatter(coordinates[time_step][i][0], coordinates[time_step][i][1], s = 1, color = 'r')\n\n # plot the object\n if i < M:\n polygon = np.array(polygons[time_step][i])\n # get the points of the polygon to plot it\n x, y = polygon.T\n\n # print(x, y)\n\n x = np.append(x, x[0])\n y = np.append(y, y[0])\n\n # print(x, y)\n\n # plot the polygon\n plt.plot(x , y)\n # plt.scatter(polygons_com[time_step][i][0], polygons_com[time_step][i][1], s = 5, color = 'g')\n\n if bound_cond == True:\n plt.axis([0, L, 0, L])\n plt.axis([0, L, 0, L])\n # plt.axis([-L*2, L*2, -L*2, L*2])\n\n # show graph\n plt.show()\n plt.pause(time_pause)\n\n # decide if you want to clear\n if clear == True:\n plt.clf()\n\n return None","def create_path(number_of_vertices, radius, thickness):\n\n global screen\n dist_apart = radius * 3\n\n for i in range(0, number_of_vertices):\n vtx_x = i*dist_apart + int((WINDOW_WIDTH - dist_apart * (number_of_vertices - 1)) / 2)\n vtx_y = int(WINDOW_HEIGHT / 2)\n\n vtx = {\"ID\": i,\n \"x\": vtx_x,\n \"y\": vtx_y,\n \"color\": \"WHITE\",\n \"adjacent\": [],\n }\n\n VERTICES.append(vtx);\n\n # Assign adjacency\n for i in range(0, number_of_vertices):\n if i is not number_of_vertices - 1:\n VERTICES[i][\"adjacent\"].append(VERTICES[i + 1][\"ID\"])\n VERTICES[i + 1][\"adjacent\"].append(VERTICES[i][\"ID\"])\n\n draw_graph(VERTICES, radius, thickness)","def addPolyLineToScene(self, controlPoint, colorVar, needleType='Detection',script=False, endMarker=False, name=\"^\", trans=0, manualName=\"\",radius=1,bPause=False):\r\n #research\r\n #profprint()\r\n \"\"\"\r\n Create a model of the linear needle segments\r\n \"\"\"\r\n widget = slicer.modules.NeedleFinderWidget\r\n\r\n realNeedleLength = widget.realNeedleLength.value\r\n extendNeedle = widget.extendNeedle.isChecked()\r\n\r\n # sort the points in a decreasing order (from tip to bottom)\r\n controlPointListSorted = controlPoint #self.sortTableReverse(controlPoint, (2, 1, 0))\r\n\r\n # calculate the length of the list of ctr points\r\n lenghtTotal = 0\r\n for i in range(len(controlPoint) - 1):\r\n lenghtTotal += self.distanceTwoPoints(controlPointListSorted[i + 1], controlPointListSorted[i])\r\n #print \"Polygon added to scene, length of tube: \", lenghtTotal\r\n\r\n # in case we want to extend the needle to the wanted length\r\n \"\"\"\r\n The extension is currently done by adding a point to the control point list.\r\n \"\"\"\r\n if lenghtTotal < realNeedleLength and extendNeedle:\r\n lastPoint = [controlPointListSorted[-1][0], controlPointListSorted[-1][1], controlPointListSorted[-1][2] - (realNeedleLength - lenghtTotal)]\r\n controlPointListSorted.append(lastPoint)\r\n\r\n scene = slicer.mrmlScene\r\n points = vtk.vtkPoints()\r\n polyData = vtk.vtkPolyData()\r\n polyData.SetPoints(points)\r\n lines = vtk.vtkCellArray()\r\n polyData.SetLines(lines)\r\n linesIDArray = lines.GetData()\r\n linesIDArray.Reset()\r\n linesIDArray.InsertNextTuple1(0)\r\n polygons = vtk.vtkCellArray()\r\n polyData.SetPolys(polygons)\r\n idArray = polygons.GetData()\r\n idArray.Reset()\r\n idArray.InsertNextTuple1(0)\r\n n = len(controlPointListSorted)\r\n # start read out\r\n for i in range(n):\r\n pointIndex = points.InsertNextPoint(*(controlPointListSorted[i]))\r\n linesIDArray.InsertNextTuple1(pointIndex)\r\n linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1)\r\n lines.SetNumberOfCells(1)\r\n # ## Create model node\r\n model = slicer.vtkMRMLModelNode()\r\n model.SetScene(scene)\r\n model.SetAndObservePolyData(polyData)\r\n # ## Create display node\r\n modelDisplay = slicer.vtkMRMLModelDisplayNode()\r\n\r\n modelDisplay.SetScene(scene)\r\n scene.AddNode(modelDisplay)\r\n model.SetAndObserveDisplayNodeID(modelDisplay.GetID())\r\n # ## Add to scene\r\n modelDisplay.SetInputPolyDataConnection(model.GetPolyDataConnection())\r\n scene.AddNode(model)\r\n # ##Create Tube around the line\r\n tube = vtk.vtkTubeFilter()\r\n polyData = model.GetPolyData()\r\n tube.SetInputData(polyData)\r\n tube.SetRadius(radius)\r\n tube.SetNumberOfSides(50)\r\n tube.Update()\r\n\r\n model.SetAndObservePolyData(tube.GetOutput())\r\n model.GetDisplayNode().SliceIntersectionVisibilityOn()\r\n model.GetDisplayNode().SetOpacity(1-trans)\r\n if needleType == 'Validation':\r\n model.SetName('.manual-seg_' + str(colorVar))\r\n elif needleType == 'Obturator':\r\n model.SetName('.obturator-seg_' + str(colorVar))\r\n else:\r\n model.SetName('.auto-seg_' + str(self.round) + '-ID-' + str(model.GetID())+'-'+manualName)\r\n model.SetAttribute('type', needleType)\r\n\r\n if needleType == 'Validation' or needleType =='Debug':\r\n nth = int(colorVar) % MAXCOL\r\n modelDisplay.SetColor(self.color[int(nth)][0], self.color[int(nth)][1], self.color[int(nth)][2])\r\n model.SetAttribute(\"nth\", str(nth))\r\n\r\n else:\r\n nth = int(model.GetID().strip('vtkMRMLModelNode')) % MAXCOL\r\n modelDisplay.SetColor(self.color[int(nth)][0], self.color[int(nth)][1], self.color[int(nth)][2])\r\n model.SetAttribute(\"nth\", str(nth))\r\n\r\n if endMarker:\r\n fiducial = slicer.mrmlScene.CreateNodeByClass('vtkMRMLAnnotationFiducialNode')\r\n fiducial.SetName('.'+name+'_'+str(colorVar))\r\n fiducial.Initialize(slicer.mrmlScene)\r\n fiducial.SetFiducialCoordinates(controlPointListSorted[-1])\r\n fiducial.SetAttribute('TemporaryFiducial', '1')\r\n fiducial.SetLocked(True)\r\n displayNode = fiducial.GetDisplayNode()\r\n displayNode.SetGlyphScale(.5) # \"arrow head\"\r\n displayNode.SetColor(0, 0, 0)\r\n textNode = fiducial.GetAnnotationTextDisplayNode()\r\n textNode.SetTextScale(1)\r\n textNode.SetColor(0, 0, 0)\r\n if bPause: breakbox('Inspect this situation in the viewer!')","def add_outline(component, layer=LAYER.DEVREC):\n c = component\n points = [\n [c.xmin, c.ymin],\n [c.xmax, c.ymin],\n [c.xmax, c.ymax],\n [c.xmin, c.ymax],\n ]\n c.add_polygon(points, layer=layer)","def draw_avg_ext_lines(img, lines, color=[255, 0, 0], thickness=10):\n debug=False\n lSlopeAvg=0\n rSlopeAvg=0\n slope_tolerance=.1\n slope_tolerance_from_zero=.5\n bottom_y = img.shape[0]\n top_y = int(bottom_y /1.6)\n \n lLines = []\n rLines = []\n l = 1\n r = 1\n \n for line in lines:\n for x1,y1,x2,y2 in line:\n slope = (y2-y1)/(x2-x1)\n if np.absolute(slope) == np.inf or np.absolute(slope) < slope_tolerance_from_zero:\n continue\n if debug:\n cv2.line(img, (x1, y1), (x2, y2), color, thickness)\n if slope < 0:\n lSlopeAvg = lSlopeAvg + (slope - lSlopeAvg) / l\n l += 1\n if np.absolute(lSlopeAvg - slope) < slope_tolerance :\n lLines.append((x1,y1))\n lLines.append((x2,y2))\n else:\n rSlopeAvg = rSlopeAvg + (slope - rSlopeAvg) / r\n r += 1\n if np.absolute(rSlopeAvg - slope) < slope_tolerance :\n rLines.append((x1,y1))\n rLines.append((x2,y2)) \n \n \"\"\"\n After having split the lines, I use cv2.fitline to fit the sets of points to a single line.\n cv2.fitline gives back a unit vector and a point in the line, both of which we can use\n to calculate the slope and intercept of the line function.\n \"\"\"\n if len(lLines) > 0 and len(rLines) > 0 :\n [left_vx,left_vy,left_x,left_y] = cv2.fitLine(np.array(lLines, dtype=np.int32), cv2.DIST_L2,0,0.01,0.01) \n left_slope = left_vy / left_vx\n left_b = left_y - (left_slope*left_x)\n\n [right_vx,right_vy,right_x,right_y] = cv2.fitLine(np.array(rLines, dtype=np.int32), cv2.DIST_L2,0,0.01,0.01) \n right_slope = right_vy / right_vx\n right_b = right_y - (right_slope*right_x)\n\n # Average this line with previous frames \n prev_lines.append((left_b, left_slope, right_b, right_slope))\n \n if len(prev_lines) > 0: \n avg = np.sum(prev_lines, -3) /len(prev_lines)\n left_b = avg[0]\n left_slope = avg[1]\n right_b = avg[2]\n right_slope = avg[3]\n\n \"\"\"\n Having the slope and intercept enables us to calculate the x coordinates of our desired\n start and end points at the top and the bottom of the road.\n \"\"\"\n ltop_x = (top_y - left_b) / left_slope\n lbottom_x = (bottom_y - left_b) / left_slope\n\n rtop_x = (top_y - right_b) / right_slope\n rbottom_x = (bottom_y - right_b) / right_slope\n\n cv2.line(img, (lbottom_x, bottom_y), (ltop_x, top_y), color, thickness)\n cv2.line(img, (rbottom_x, bottom_y), (rtop_x, top_y), color, thickness)","def DrawRectanglePointSize(*args, **kwargs):\n return _gdi_.DC_DrawRectanglePointSize(*args, **kwargs)","def draw_lines_slow(orbit_pos, factor):","def draw_xywh_rectangle_outline(top_left_x, top_left_y, width, height, color,\n border_width=1):\n center_x = top_left_x + (width / 2)\n center_y = top_left_y + (height / 2)\n draw_rectangle_outline(center_x, center_y, width, height, color,\n border_width)","def drawPath(self):\r\n bgl.glColor4f(0.8,0.8,0.9,0.01)\r\n bgl.glLineWidth(0.01)\r\n\r\n bgl.glBegin(bgl.GL_LINES)\r\n bgl.glVertex3f(self.p1[0],self.p1[1],self.p1[2])\r\n bgl.glVertex3f(self.p2[0],self.p2[1],self.p2[2])\r\n bgl.glEnd()\r\n\r\n bgl.glNormal3f(0.0,0.0,1.0)\r\n bgl.glShadeModel(bgl.GL_SMOOTH);","def plot_polygon(polygon, size_points_distrib=50):\n # Get the points\n list_points = list(polygon.exterior.coords)\n distances = np.array(scipy.spatial.distance.euclidean([elt[0] for elt in list_points], [elt[1] for elt in list_points]))\n avg_dist = distances.mean()\n\n # Get the boundaries\n minx, miny, maxx, maxy = polygon.bounds\n box_points = box(minx, miny, maxx, maxy, ccw=True)\n\n fig, ax = plt.subplots(figsize=(10, 10))\n\n # Box\n plt.scatter(*zip(*list(box_points.exterior.coords)), color='black', linestyle=\"--\", alpha=0.2)\n plt.plot(*zip(*list(box_points.exterior.coords)), color='black', linestyle=\"--\", alpha=0.2)\n\n # Polygon\n plt.scatter(*zip(*list_points), color='blue')\n plt.plot(*zip(*list(list_points)), color='blue', linestyle=\"-.\", alpha=0.2)\n ax.set(xlim=[minx, maxx])\n ax.set(ylim=[miny, maxy])\n\n # Limits\n rdm_points = gen_rdm_points_square(polygon, size_points_distrib)\n # creates mask\n is_in_distrib = point_in_polygons(polygon, rdm_points)\n print(rdm_points[is_in_distrib])\n\n # Points in\n x_in, y_in = zip(*rdm_points[is_in_distrib])\n plt.scatter(x_in, y_in, color='green', alpha=0.2, marker=\"+\")\n\n # Points out\n x_out, y_out = zip(*rdm_points[~is_in_distrib])\n plt.scatter(x_out, y_out, color='red', alpha=0.2, marker=\"+\")\n\n plt.show()","def add_poly_edges(self, poly_item, marker_dict=None):\n\n poly = poly_item.polygon()\n\n for i in range(1, poly.size() + 1):\n if i == poly.size():\n p1 = poly.at(i - 1)\n p2 = poly.at(0)\n index = -poly.size()\n\n else:\n p1 = poly.at(i - 1)\n p2 = poly.at(i)\n index = i\n\n line = self.addLine(QLineF(p1, p2))\n line.setZValue(-1)\n display_line = self.addLine(QLineF(p1, p2), QPen(self.LUBronze, 3))\n line.__setattr__(\"localIndex\", index)\n line.setParentItem(poly_item)\n display_line.setParentItem(line)\n self.edge_list.append(line)\n\n # Used to pass markers when loading a g\n if marker_dict:\n if i - 1 in marker_dict:\n self.add_marker(display_line, marker_dict[i - 1])\n display_line.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, False)\n text = display_line.childItems()[0]\n text.setVisible(False)","def draw(self, camera):\n for line in self._polyline.lines:\n camera.draw_line(line.begin, line.end, self.color, self.width)","def __draw_path(\n self, x_path, y_path, opt_line, opt_marker,\n opt_colour, thickness=0.05):\n # Get colour\n colour = self.__get_colour_from_string(opt_colour)\n\n # For every point in the list, draw a line to the next one\n # (excluding last point)\n for point in range(0, len(x_path)):\n # Get point 1\n x1 = x_path[point]\n y1 = y_path[point]\n p1 = vector(x1, y1, 0)\n\n # If at end / only coordinate - draw a marker\n if point == len(x_path) - 1:\n create_marker(self.scene, x1, y1, opt_marker, colour)\n return\n\n # Get point 2\n x2 = x_path[point + 1]\n y2 = y_path[point + 1]\n p2 = vector(x2, y2, 0)\n\n if opt_line == '':\n # Only one marker to avoid double-ups\n create_marker(self.scene, x1, y1, opt_marker, colour)\n elif opt_line == '-':\n create_line(\n p1, p2, self.scene, colour=colour, thickness=thickness)\n # Only one marker to avoid double-ups\n create_marker(self.scene, x1, y1, opt_marker, colour)\n elif opt_line == '--':\n create_segmented_line(\n p1, p2, self.scene, 0.3, colour=colour,\n thickness=thickness)\n # Only one marker to avoid double-ups\n create_marker(self.scene, x1, y1, opt_marker, colour)\n elif opt_line == ':':\n create_segmented_line(\n p1, p2, self.scene, 0.05, colour=colour,\n thickness=thickness)\n # Only one marker to avoid double-ups\n create_marker(self.scene, x1, y1, opt_marker, colour)\n elif opt_line == '-.':\n raise NotImplementedError(\"Other line types not implemented\")\n else:\n raise ValueError(\"Invalid line type given\")","def polygon(self, center, angle, points, color=(255, 255, 255), width=0):\n poly = list()\n\n for point in points:\n point = self._rotate(point, angle)\n point += center\n point = self._transform(point)\n poly.append(point)\n\n pygame.draw.polygon(self.screen, color, poly, width)","def show_points(self, video, roi_size=None):\n if roi_size is None:\n if hasattr(self, 'roi_size'):\n roi_size = self.roi_size\n\n fig, ax = plt.subplots(figsize=(15, 5))\n ax.imshow(video.mraw[0].astype(float), cmap='gray')\n ax.scatter(video.points[:, 1],\n video.points[:, 0], marker='.', color='r')\n\n if roi_size is not None:\n for point in video.points:\n roi_border = patches.Rectangle((point - self.roi_size//2)[::-1], self.roi_size[1], self.roi_size[0],\n linewidth=1, edgecolor='r', facecolor='none')\n ax.add_patch(roi_border)\n\n plt.grid(False)\n plt.show()"],"string":"[\n \"def draw_lines(self, color, points, width = 1, closed = False):\\n color = spyral.color._determine(color)\\n pygame.draw.aalines(self._surf, color, closed, points)\",\n \"def drawLines(self):\\n\\t\\tintersections = [[], []]\\n\\t\\tfor l in self.lines:\\n\\t\\t\\tif l.direction == 'v':\\n\\t\\t\\t\\tif l.rtc:\\n\\t\\t\\t\\t\\tposition = l.coordinate + int((self.width - 1) / 2)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tposition = int((l.coordinate * self.width / 100) if type(l.coordinate) == float else l.coordinate)\\n\\t\\t\\t\\tintersections[0].append(position)\\n\\t\\t\\t\\tfor yPos in range(1, self.height - 2):\\n\\t\\t\\t\\t\\tself.wts(yPos, position, '│', self._borderColor)\\n\\t\\t\\t\\t# endpoints\\n\\t\\t\\t\\tself.wts(0, position, '┬',self._borderColor)\\n\\t\\t\\t\\tself.wts(self.height - 2, position, '┴', self._borderColor)\\n\\t\\t\\telif l.direction == 'h':\\n\\t\\t\\t\\tif l.rtc:\\n\\t\\t\\t\\t\\tposition = l.coordinate + ((self.height - 1) / 2)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tposition = int((l.coordinate * self.height / 100) - 1 if type(l.coordinate) == float else l.coordinate)\\n\\t\\t\\t\\tintersections[1].append(position)\\n\\t\\t\\t\\tself.wts(position, 1, '─' * (self.width - 2), self._borderColor)\\n\\t\\t\\t\\t# endpoints\\n\\t\\t\\t\\tself.wts(position, 0, '├', self._borderColor)\\n\\t\\t\\t\\tself.wts(position, self.width - 1, '┤', self._borderColor)\\n\\t\\t# draw intersections\\n\\t\\tfor x in intersections[1]:\\n\\t\\t\\tfor y in intersections[0]:\\n\\t\\t\\t\\tself.wts(x, y, '┼', self._borderColor)\\n\\t\\tself.verticalBoundaries = intersections[0]\\n\\t\\tif self.screenBorder:\\n\\t\\t\\tself.verticalBoundaries.append(self.width)\",\n \"def drawPaths(points, lines, height, lineWidth, pointRadius):\\r\\n\\r\\n\\tlineArraySize = len(lines)\\r\\n\\tpointArraySize = len(points)\\r\\n\\tlineArrayItems = lineArraySize / 4\\r\\n\\tpointArrayItems = pointArraySize / 2\\r\\n\\r\\n\\r\\n\\tglLineWidth(lineWidth)\\r\\n\\tglPointSize(pointRadius)\\r\\n\\r\\n\\tglColor4f(0.0, 0.0, 1.0, 1.0)\\r\\n\\tglNormal3f(0.0, 0.0, 1.0)\\r\\n\\r\\n\\tglDisable(GL_TEXTURE_2D)\\r\\n\\r\\n\\tglBegin(GL_LINES)\\r\\n\\r\\n#\\tglLoadIdentity()\\r\\n\\r\\n\\tfor i in range(lineArrayItems):\\r\\n\\t\\tglVertex3f(lines[i * 4], height - lines[i * 4 + 1], 0.1)\\r\\n\\t\\tglVertex3f(lines[i * 4 + 2], height - lines[i * 4 + 3], 0.1)\\r\\n\\r\\n\\tglEnd()\\r\\n\\r\\n\\tglBegin(GL_POINTS)\\r\\n\\r\\n#\\tglLoadIdentity()\\r\\n\\r\\n\\tfor i in range(pointArrayItems):\\r\\n\\t\\tglVertex3f(points[i * 2], height - points[i * 2 + 1], 0.11)\\r\\n\\r\\n\\tglEnd()\\r\\n\\r\\n\\tglEnable(GL_TEXTURE_2D)\",\n \"def wdraw_polyline(self, wcoords, color):\\r\\n dpoints = []\\r\\n for i in range(0, len(wcoords), 2):\\r\\n dpoints += self.w_to_d(wcoords[i], wcoords[i+1])\\r\\n self.canvas.create_line(dpoints, fill=color)\",\n \"def linewidth(self, size: float):\\n for line in self.ax.lines:\\n line.set_linewidth(size)\\n self.canvas.draw()\",\n \"def draw_lines(self, color, points, width=1, closed=False):\\n if width == 1:\\n pygame.draw.aalines(self._surf, color, closed, points)\\n else:\\n pygame.draw.lines(self._surf, color, closed, points, width)\\n self._version += 1\\n spyral.util.scale_surface.clear(self._surf)\\n return self\",\n \"def draw_lines(point_list, color, border_width=1):\\n GL.glEnable(GL.GL_BLEND)\\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\\n GL.glEnable(GL.GL_LINE_SMOOTH)\\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\\n\\n GL.glLoadIdentity()\\n\\n # Set line width\\n GL.glLineWidth(border_width)\\n\\n # Set color\\n if len(color) == 4:\\n GL.glColor4ub(color[0], color[1], color[2], color[3])\\n elif len(color) == 3:\\n GL.glColor4ub(color[0], color[1], color[2], 255)\\n\\n GL.glBegin(GL.GL_LINES)\\n for point in point_list:\\n GL.glVertex3f(point[0], point[1], 0.5)\\n GL.glEnd()\",\n \"def drawcutline(f,layernamelist,cutline_entities_count): \\r\\n \\r\\n #layernamelist=[layernamelist[0]] \\r\\n layercount=0\\r\\n ringlist=[[[-0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]]]\\r\\n flashlist=buildflashlist()\\r\\n cutlineset=buildcutlineset() \\r\\n \\r\\n f.write(\\\"0\\\\nSECTION\\\\n2\\\\nENTITIES\\\\n\\\")\\r\\n \\r\\n for layername in layernamelist:\\r\\n layercount=layercount+1\\r\\n for polyline in cutlineset:\\r\\n cutline_entities_count=cutline_entities_count+1\\r\\n f.write(\\\"0\\\\nPOLYLINE\\\\n8\\\\n\\\"+layername+\\\"\\\\n5\\\\n\\\"+hex(cutline_entities_count)[2:]) # begin writing a polyline\\r\\n f.write(\\\"\\\\n66\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n40\\\\n0.08\\\\n41\\\\n0.08\\\\n\\\")\\r\\n cutline_entities_count=drawwidthpolyline(polyline, cutline_entities_count, f,layername)\\r\\n cutline_entities_count=drawring(ringlist, cutline_entities_count, f, layername)\\r\\n cutline_entities_count=drawflash(flashlist, cutline_entities_count, f, layername)\\r\\n cutline_entities_count=drawtext(cutline_entities_count, f, layername,layercount)\\r\\n \\r\\n return cutline_entities_count\",\n \"def draw_lines(self):\\n for x_cord in range(0, Dimension.SCREEN_WIDTH.value, Dimension.SQUARE_WIDTH.value):\\n pg.draw.line(self.window, Colors.BLACK.value, (x_cord, 0), (x_cord, Dimension.SCREEN_HEIGHT.value))\\n\\n for y_cord in range(0, Dimension.SCREEN_HEIGHT.value, Dimension.SQUARE_HEIGHT.value):\\n pg.draw.line(self.window, Colors.BLACK.value, (0, y_cord), (Dimension.SCREEN_WIDTH.value, y_cord))\\n\\n pg.display.update()\",\n \"def draw_line():\\n\\n # Small Size Line\\n glLineWidth(0.1)\\n glColor3f(0.5, 1.0, 0.9)\\n wid = 0\\n while wid <= width:\\n length = 0\\n while length <= height:\\n glBegin(GL_LINES)\\n glVertex3f(0.0, length, 0.0)\\n glVertex3f(wid, length, 0)\\n glEnd()\\n glBegin(GL_LINES)\\n glVertex3f(length, 0, 0.0)\\n glVertex3f(length, wid, 0)\\n glEnd()\\n length += 10\\n wid += 50\\n # Medium Size Line\\n glLineWidth(2.0)\\n wid = 0\\n while wid <= width:\\n length = 0\\n while length <= height:\\n glBegin(GL_LINES)\\n glVertex3f(0.0, length, 0.0)\\n glVertex3f(wid, length, 0)\\n glEnd()\\n length += 50\\n glBegin(GL_LINES)\\n glVertex3f(length, 0, 0.0)\\n glVertex3f(length, wid, 0)\\n glEnd()\\n wid += 50\\n # Main Line\\n # ordinat\\n glLineWidth(1.5)\\n glColor3f(0.5, 0.4, 0.8)\\n glBegin(GL_LINES)\\n glVertex3f(height / 2, 0, 0.0)\\n glVertex3f(height / 2, width, 0)\\n glEnd()\\n # absis\\n glBegin(GL_LINES)\\n glVertex3f(0, width / 2, 0.0)\\n glVertex3f(height, width / 2, 0)\\n glEnd()\",\n \"def draw_line_strip(point_list, color, border_width=1):\\n GL.glEnable(GL.GL_BLEND)\\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\\n GL.glEnable(GL.GL_LINE_SMOOTH)\\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\\n\\n # Set line width\\n GL.glLineWidth(border_width)\\n\\n GL.glLoadIdentity()\\n\\n # Set color\\n if len(color) == 4:\\n GL.glColor4ub(color[0], color[1], color[2], color[3])\\n elif len(color) == 3:\\n GL.glColor4ub(color[0], color[1], color[2], 255)\\n\\n GL.glBegin(GL.GL_LINE_STRIP)\\n for point in point_list:\\n GL.glVertex3f(point[0], point[1], 0.5)\\n GL.glEnd()\",\n \"def drawPoints(self, qp):\\n\\n# pen = self.pen\\n\\n\\n size = self.size()\\n self.yOffset = [size.height()*0.2 + size.height()*0.618/self.NUM_CHANNEL * y for y in xrange(self.NUM_CHANNEL) ]\\n\\n for ix in xrange(self.NUM_CHANNEL):\\n self.pen.setStyle(Qt.SolidLine)\\n self.pen.setWidth(2)\\n self.pen.setBrush(self.PEN_COLOR[ix])\\n self.pen.setCapStyle(Qt.RoundCap)\\n self.pen.setJoinStyle(Qt.RoundJoin)\\n qp.setPen(self.pen)\\n\\n qp.drawLine(self.x - 2, self.yOffset[ix] - \\\\\\n self.data_1[ix] * self.DISPLAY_SCALING[ix],\\\\\\n self.x , self.yOffset[ix] - \\\\\\n self.data[ix] * self.DISPLAY_SCALING[ix])\",\n \"def draw_poly(t, n, sz):\\r\\n\\r\\n\\tfor i in range(n):\\r\\n\\t\\tt.forward(sz)\\r\\n\\t\\tt.left(360/n)\",\n \"def L(width = 1, size = (10, 20), layer = 0):\\n D = Device(name = 'L')\\n w = width/2\\n s1, s2 = size\\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2), (-w, s2), (-w, -w)]\\n D.add_polygon(points, layer = layer)\\n D.add_port(name = 1, midpoint = (0, s2), width = width, orientation = 90)\\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\\n return D\",\n \"def draw_polygon_outline(point_list, color, border_width=1):\\n GL.glEnable(GL.GL_BLEND)\\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\\n GL.glEnable(GL.GL_LINE_SMOOTH)\\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\\n\\n # Set line width\\n GL.glLineWidth(border_width)\\n\\n GL.glLoadIdentity()\\n\\n # Set color\\n if len(color) == 4:\\n GL.glColor4ub(color[0], color[1], color[2], color[3])\\n elif len(color) == 3:\\n GL.glColor4ub(color[0], color[1], color[2], 255)\\n\\n GL.glBegin(GL.GL_LINE_LOOP)\\n for point in point_list:\\n GL.glVertex3f(point[0], point[1], 0.5)\\n GL.glEnd()\",\n \"def draw_polyline(self, points, line_width, line_color):\\n line_color = check_color(line_color)\\n STline.line(self.canvas, points, line_width, line_color)\",\n \"def draw_equitriangle(t,sz):\\r\\n\\r\\n\\tdraw_poly(t, 3, sz)\",\n \"def drawWarpLines(self):\\n # draw warp lines\\n for item in self.game.warpLines:\\n anwp.sl.engine.drawLine(item[0]+self.bufferX, item[1]+self.bufferY, item[2]+self.bufferX, item[3]+self.bufferY, pyui.colors.blue)\",\n \"def draw_polyline(*points):\\r\\n global _canvas\\r\\n if _canvas == None:\\r\\n raise RuntimeError(\\\"Canvas is not open yet.\\\")\\r\\n else:\\r\\n #print(points)\\r\\n #print(len(points))\\r\\n newpoints = []\\r\\n for x in range(0, len(points), 2):\\r\\n #print(x)\\r\\n pt = Point(points[x], points[x+1])\\r\\n newpoints += [ pt ]\\r\\n #print(newpoints)\\r\\n path = Path(*newpoints)\\r\\n path.setBorderWidth(_current_line_thickness)\\r\\n path.setBorderColor(_current_color)\\r\\n _canvas.add(path)\",\n \"def graphicsDraw(self, win, center):\\n\\t\\tlastPoint = None\\n\\t\\tfor p in self.points:\\n\\t\\t\\tthisPoint = Point(p[0] + center.x, p[1] + center.y)\\n\\t\\t\\tif lastPoint is not None:\\n\\t\\t\\t\\tline = Line(lastPoint, thisPoint)\\n\\t\\t\\t\\tline.draw(win)\\n\\t\\t\\tlastPoint = thisPoint\",\n \"def draw_lines(img, lines, color=[0, 0, 255], thickness=10):\\n \\n yFinal = 540 # tweak these values as per the frame size\\n yIni = 350\\n xPlus = []\\n yPlus = []\\n xMinus = []\\n yMinus= []\\n slope_range = 0.2\\n\\n if lines is not None:\\n for line in lines:\\n if line is not None:\\n for x1,y1,x2,y2 in line:\\n # check slope \\n slope = (y2-y1)/(x2-x1)\\n\\t\\t \\n \\t\\t # Collect all points with + ve slope (right lane)\\n if (slope > slope_range):\\n xPlus.append(x1)\\n xPlus.append(x2)\\n yPlus.append(y1)\\n yPlus.append(y2)\\n\\n # Collect all points with - ve slope (left lane)\\n elif ((slope) < (-slope_range)):\\n xMinus.append(x1)\\n xMinus.append(x2)\\n yMinus.append(y1)\\n yMinus.append(y2)\\n # If out of range, lists defined in beginning of this function will be empty \\n else:\\n continue\\n \\n # draw right lane\\n x1,y1,x2,y2 = fit_line(xPlus, yPlus, yIni, yFinal)\\n cv2.line(img,(x1,y1),(x2,y2),color, thickness) \\n\\n # draw left lane\\n x1,y1,x2,y2 = fit_line(xMinus, yMinus, yIni, yFinal)\\n cv2.line(img,(x1,y1),(x2,y2),color,thickness)\",\n \"def set_spines(plot):\\n for spines in plot.spines.values():\\n spines.set_linewidth(.2)\",\n \"def line_layer(self):\\n screen_origin = self.ids.mapview.get_window_xy_from(lat1, lon1, self.ids.mapview.zoom)\\n screen_destination = self.ids.mapview.get_window_xy_from(lat2, lon2, self.ids.mapview.zoom)\\n point_list = [screen_origin[0], screen_origin[1], screen_destination[0], screen_destination[1]]\\n\\n with self.ids.line.canvas:\\n self.ids.line.canvas.clear()\\n\\n Color(0, 0, 0, .6)\\n Line(points=point_list, width=3, joint=\\\"bevel\\\")\",\n \"def setLineWidth(w=1):\\n dislin.linwid(w)\",\n \"def to_strokes(self, width:float, color:list):\\n # corner points\\n # NOTE: center line of path without stroke width considered\\n x0, y0, x1, y1 = self.rect\\n points = [\\n (x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)\\n ]\\n # connect each line\\n strokes = []\\n for i in range(len(points)-1):\\n strokes.append({\\n 'start': points[i],\\n 'end' : points[i+1],\\n 'width': width * 2.0, # seems need adjustment by * 2.0\\n 'color': rgb_value(color)\\n })\\n return strokes\",\n \"def plot(self, frame, fit, thickness=2):\\n if not fit:\\n return frame\\n X,Y = fit.linspace()\\n X = np.array(X,dtype=np.int32)\\n Y = np.array(Y,dtype=np.int32)\\n curve = np.column_stack((X,Y))\\n cv2.polylines(frame, [curve], False, color=(0,0,255),thickness=thickness)\\n return frame\",\n \"def draw_lines(display, coord, box_size, color, bg_color):\\n left, top = coord\\n stroke = 6\\n half_stroke = int(stroke / 2)\\n left = left + half_stroke\\n top = top + half_stroke\\n box_size = box_size - stroke\\n for i in range(0, box_size, int(stroke + 2)):\\n pygame.draw.line(\\n display, color,\\n (left, top + i),\\n (left + i, top),\\n stroke,\\n )\\n pygame.draw.line(\\n display, color,\\n (left + i, top + box_size - 1),\\n (left + box_size - 1, top + i),\\n stroke,\\n )\\n return\",\n \"def draw_lines(self):\\n # draw x lines\\n y = self.step_y\\n while y <= self.height:\\n x = 0\\n while x <= self.width:\\n self.canvas.create_line(x, y, x+3.5, y)\\n self.canvas.update()\\n x += 3.5\\n y += self.step_y\\n \\n # draw y lines\\n x = self.step_x\\n while x <= self.width:\\n y = 0\\n while y <= self.height:\\n self.canvas.create_line(x, y, x, y+3.5)\\n self.canvas.update()\\n y += 3.5\\n x += self.step_x\\n \\n self.is_operating = False\",\n \"def plot_insertsize():\",\n \"def line(canvas, points, line_width, line_color):\\n \\n # duplicate first point in case only one point was given\\n points = points[0], points\\n canvas.create_line(points, width = int(line_width), fill = line_color)\",\n \"def drawSlope(self):\\n length = sqrt(1 + self.slope**2) # Length of the line segment over 1 x-unit\\n xOffset = (segmentLength / length) / 2 # Figures out how many times the length of the 1 unit length fits into the desired length\\n # then divides by 2 becuase half is on the left and half on the right of the center\\n\\n\\n # Left end point\\n xLeft = self.x - xOffset\\n yLeft = (self.slope * (xLeft - self.x)) + self.y\\n\\n # Right end point\\n xRight = self.x + xOffset\\n yRight = (self.slope * (xRight - self.x)) + self.y\\n\\n\\n # Converts the left and right end points from cartesian coordinates to screen coordinates\\n left = cartesianToScreen(xLeft , yLeft)\\n right = cartesianToScreen(xRight, yRight)\\n\\n\\n pygame.draw.aaline(display, self.color, left, right, 1) # DRAWS THE LINE AHHHHHHHHHHHHHHHHHH :P\",\n \"def draw_polygon(self, points, line_width, line_color, fill_color = \\\"\\\"):\\n line_color, fill_color = check_color(line_color), check_color(fill_color)\\n STpolygon.polygon(self.canvas, points, line_width, line_color, fill_color)\",\n \"def set_line_thickness(thickness):\\r\\n global _current_line_thickness\\r\\n _current_line_thickness = thickness\",\n \"def draw_poly(t, n, sz):\\n\\tfor side in range(n):\\n\\t\\tangle = (360/n)\\n\\t\\tt.pendown()\\n\\t\\tt.forward(sz)\\n\\t\\tt.right(angle)\",\n \"def powerpoint_style2(Axe_tick_size=15,Line_size=3) : \\n fig = plt.gcf()\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n for ax in fig.axes:\\n \\n # trouve tous les trucs avec linewidth et les modifie\\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\\n item.set_fontsize(Axe_tick_size)\\n \\n #for item in ([ax.xaxis.label, ax.yaxis.label]):\\n # item.set_fontsize(Axe_tick_size+5)\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size)\",\n \"def plot_endpoints( polylines, mymap ):\\n map( \\\\\\n lambda start : mymap.addpoint( start[-1][0], start[-1][1], \\\"#0000FF\\\") if start != [] else [],\\n polylines)\",\n \"def borders(w, h):\\r\\n pygame.draw.line(window, WHITE, [25, 0], [25, h - 50], 6)\\r\\n pygame.draw.line(window, WHITE, [w - 25, 0], [w - 25, h - 50], 6)\\r\\n pygame.draw.line(window, WHITE, [25, h - 50], [w - 25, h - 50], 6)\\r\\n pygame.draw.line(window, WHITE, [25, 25], [w - 25, 25], 6)\",\n \"def draw_line(self, start_p, end_p, color, thickness: float):\\n line_seg = LineSegs(\\\"interface\\\")\\n line_seg.setColor(*color)\\n line_seg.moveTo(start_p[0] * self.w_scale, 0, start_p[1] * self.h_scale)\\n line_seg.drawTo(end_p[0] * self.w_scale, 0, end_p[1] * self.h_scale)\\n line_seg.setThickness(thickness)\\n line_np = self.aspect2d.attachNewNode(line_seg.create(False))\\n return line_np\",\n \"def lines(draw, coordinates: List[Tuple[float, float]], width=1, color=\\\"#AAAAAAFF\\\") -> None:\\n coords = [pixelcoord(*c) for c in coordinates]\\n draw.line(coords, color, width)\",\n \"def draw_poly(t, n, sz):\\n\\n s_intern_angles = (n - 2) * 180\\n for i in range(n):\\n t.forward(sz)\\n t.left(180 - s_intern_angles / n)\\n time.sleep(5)\\n turtle.Screen().clear()\",\n \"def get_points_for_thick_line(start_x: float, start_y: float,\\r\\n end_x: float, end_y: float,\\r\\n line_width: float):\\r\\n vector_x = start_x - end_x\\r\\n vector_y = start_y - end_y\\r\\n perpendicular_x = vector_y\\r\\n perpendicular_y = -vector_x\\r\\n length = math.sqrt(vector_x * vector_x + vector_y * vector_y)\\r\\n if length == 0:\\r\\n normal_x = 1.0\\r\\n normal_y = 1.0\\r\\n else:\\r\\n normal_x = perpendicular_x / length\\r\\n normal_y = perpendicular_y / length\\r\\n r1_x = start_x + normal_x * line_width / 2\\r\\n r1_y = start_y + normal_y * line_width / 2\\r\\n r2_x = start_x - normal_x * line_width / 2\\r\\n r2_y = start_y - normal_y * line_width / 2\\r\\n r3_x = end_x + normal_x * line_width / 2\\r\\n r3_y = end_y + normal_y * line_width / 2\\r\\n r4_x = end_x - normal_x * line_width / 2\\r\\n r4_y = end_y - normal_y * line_width / 2\\r\\n points = (r1_x, r1_y), (r2_x, r2_y), (r4_x, r4_y), (r3_x, r3_y)\\r\\n return points\",\n \"def plot_control_points(self, fig, ax, linewidth=1.25, linestyle='-.', color='red', markersize=5, markerstyle='o'):\\n\\n # One dimension (law of evolution)\\n if self.ndim == 1:\\n Px = np.real(self.P)\\n u = np.linspace(0, 1, Px.size)\\n line, = ax.plot(u, Px[0,:])\\n line.set_linewidth(linewidth)\\n line.set_linestyle(linestyle)\\n line.set_color(color)\\n line.set_marker(markerstyle)\\n line.set_markersize(markersize)\\n line.set_markeredgewidth(linewidth)\\n line.set_markeredgecolor(color)\\n line.set_markerfacecolor('w')\\n line.set_zorder(4)\\n # line.set_label(' ')\\n\\n\\n # Two dimensions (plane curve)\\n elif self.ndim == 2:\\n Px, Py = np.real(self.P)\\n line, = ax.plot(Px, Py)\\n line.set_linewidth(linewidth)\\n line.set_linestyle(linestyle)\\n line.set_color(color)\\n line.set_marker(markerstyle)\\n line.set_markersize(markersize)\\n line.set_markeredgewidth(linewidth)\\n line.set_markeredgecolor(color)\\n line.set_markerfacecolor('w')\\n line.set_zorder(4)\\n # line.set_label(' ')\\n\\n # Three dimensions (space curve)\\n elif self.ndim == 3:\\n Px, Py, Pz = np.real(self.P)\\n line, = ax.plot(Px, Py, Pz)\\n line.set_linewidth(linewidth)\\n line.set_linestyle(linestyle)\\n line.set_color(color)\\n line.set_marker(markerstyle)\\n line.set_markersize(markersize)\\n line.set_markeredgewidth(linewidth)\\n line.set_markeredgecolor(color)\\n line.set_markerfacecolor('w')\\n line.set_zorder(4)\\n # line.set_label(' ')\\n\\n else: raise Exception('The number of dimensions must be 2 or 3')\\n\\n return fig, ax\",\n \"def linecut_points( **kwargs ):\\n npoints = kwargs.get('npoints', 320)\\n extents = kwargs.get('extents',None)\\n lims = kwargs.get('lims', (-80.,80.))\\n direc = kwargs.get('direc', (np.pi/2, 0.))\\n origin = kwargs.get('origin', vec3(0.,0.,0.))\\n\\n if extents is not None:\\n lims = (-extents, extents)\\n\\n # Prepare set of points for plot \\n t = np.linspace( lims[0], lims[1], npoints )\\n unit = vec3()\\n th = direc[0]\\n ph = direc[1] \\n unit.set_spherical(1, th, ph) \\n # Convert vec3s to ndarray\\n unit = np.array(unit)\\n origin = np.array(origin) \\n #\\n XYZ = origin + np.outer(t, unit)\\n X = XYZ[:,0]\\n Y = XYZ[:,1]\\n Z = XYZ[:,2]\\n \\n return t, X, Y, Z, lims\",\n \"def draw_ellipse_outline(center_x, center_y, width, height, color,\\n border_width=1, tilt_angle=0):\\n\\n num_segments = 128\\n\\n GL.glEnable(GL.GL_BLEND)\\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\\n GL.glEnable(GL.GL_LINE_SMOOTH)\\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\\n\\n GL.glLoadIdentity()\\n GL.glTranslatef(center_x, center_y, 0)\\n GL.glRotatef(tilt_angle, 0, 0, 1)\\n GL.glLineWidth(border_width)\\n\\n # Set color\\n if len(color) == 4:\\n GL.glColor4ub(color[0], color[1], color[2], color[3])\\n elif len(color) == 3:\\n GL.glColor4ub(color[0], color[1], color[2], 255)\\n\\n GL.glBegin(GL.GL_LINE_LOOP)\\n for segment in range(num_segments):\\n theta = 2.0 * 3.1415926 * segment / num_segments\\n\\n x = width * math.cos(theta)\\n y = height * math.sin(theta)\\n\\n GL.glVertex3f(x, y, 0.5)\\n\\n GL.glEnd()\\n GL.glLoadIdentity()\",\n \"def powerpoint_style3(fig,Axe_tick_size=15,Line_size=3) : \\n #fig = plt.gcf()\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n for ax in fig.axes:\\n \\n # trouve tous les trucs avec linewidth et les modifie\\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\\n item.set_fontsize(Axe_tick_size)\\n \\n #for item in ([ax.xaxis.label, ax.yaxis.label]):\\n # item.set_fontsize(Axe_tick_size+5)\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size) \\n \\n \\n \\n #fig.show()\",\n \"def pixelize(\\n layer: vp.LineCollection,\\n pen_width: float | None,\\n mode: str,\\n keep_lines: bool,\\n overdraw: float,\\n):\\n\\n if pen_width is None:\\n pen_width = layer.property(vp.METADATA_FIELD_PEN_WIDTH) or vp.convert_length(\\\"0.6mm\\\")\\n color = layer.property(vp.METADATA_FIELD_COLOR) or vp.Color(\\\"black\\\")\\n color = color.red, color.green, color.blue\\n\\n pixel_pitch = pen_width\\n if mode == \\\"big\\\":\\n pixel_pitch *= 5\\n\\n bounds = layer.bounds()\\n if bounds is None:\\n logging.warning(\\\"!!! pixelize: layer is empty\\\")\\n return layer\\n x_min, y_min, x_max, y_max = bounds\\n\\n img_size = (\\n math.ceil((x_max - x_min) / pixel_pitch),\\n math.ceil((y_max - y_min) / pixel_pitch),\\n )\\n img = Image.new(\\\"RGBA\\\", img_size)\\n draw = ImageDraw.Draw(img)\\n for line in layer:\\n draw.line(\\n [(pt.real, pt.imag) for pt in (line - x_min - 1j * y_min) / pixel_pitch],\\n fill=color,\\n )\\n\\n doc = vp.Document()\\n if mode == \\\"big\\\":\\n # noinspection PyTypeChecker\\n big_mode(doc, np.array(img), np.array([color]), pen_width)\\n elif mode == \\\"line\\\":\\n # noinspection PyTypeChecker\\n line_mode(doc, np.array(img), np.array([color]), pen_width, overdraw)\\n elif mode == \\\"snake\\\":\\n # noinspection PyTypeChecker\\n snake_mode(doc, np.array(img), np.array([color]), pen_width)\\n\\n doc.translate(x_min, y_min)\\n\\n if keep_lines:\\n layer.extend(doc.layers[1])\\n layer.set_property(vp.METADATA_FIELD_PEN_WIDTH, pen_width)\\n return layer\\n else:\\n result = layer.clone(doc.layers[1])\\n result.set_property(vp.METADATA_FIELD_PEN_WIDTH, pen_width)\\n return result\",\n \"def centerline_to_polygon(\\n centerline: np.ndarray, width_scaling_factor: float = 1.0, visualize: bool = False\\n) -> np.ndarray:\\n # eliminate duplicates\\n _, inds = np.unique(centerline, axis=0, return_index=True)\\n # does not return indices in sorted order\\n inds = np.sort(inds)\\n centerline = centerline[inds]\\n\\n dx = np.gradient(centerline[:, 0])\\n dy = np.gradient(centerline[:, 1])\\n\\n # compute the normal at each point\\n slopes = dy / dx\\n inv_slopes = -1.0 / slopes\\n\\n thetas = np.arctan(inv_slopes)\\n x_disp = 3.8 * width_scaling_factor / 2.0 * np.cos(thetas)\\n y_disp = 3.8 * width_scaling_factor / 2.0 * np.sin(thetas)\\n\\n displacement = np.hstack([x_disp[:, np.newaxis], y_disp[:, np.newaxis]])\\n right_centerline = centerline + displacement\\n left_centerline = centerline - displacement\\n\\n # right centerline position depends on sign of dx and dy\\n subtract_cond1 = np.logical_and(dx > 0, dy < 0)\\n subtract_cond2 = np.logical_and(dx > 0, dy > 0)\\n add_cond1 = np.logical_and(dx < 0, dy < 0)\\n add_cond2 = np.logical_and(dx < 0, dy > 0)\\n subtract_cond = np.logical_or(subtract_cond1, subtract_cond2)\\n add_cond = np.logical_or(add_cond1, add_cond2)\\n left_centerline, right_centerline = swap_left_and_right(subtract_cond, left_centerline, right_centerline)\\n\\n # right centerline also depended on if we added or subtracted y\\n neg_disp_cond = displacement[:, 1] > 0\\n left_centerline, right_centerline = swap_left_and_right(neg_disp_cond, left_centerline, right_centerline)\\n\\n if visualize:\\n plt.scatter(centerline[:, 0], centerline[:, 1], 20, marker=\\\".\\\", color=\\\"b\\\")\\n plt.scatter(right_centerline[:, 0], right_centerline[:, 1], 20, marker=\\\".\\\", color=\\\"r\\\")\\n plt.scatter(left_centerline[:, 0], left_centerline[:, 1], 20, marker=\\\".\\\", color=\\\"g\\\")\\n fname = datetime.datetime.utcnow().strftime(\\\"%Y_%m_%d_%H_%M_%S_%f\\\")\\n plt.savefig(f\\\"polygon_unit_tests/{fname}.png\\\")\\n plt.close(\\\"all\\\")\\n\\n # return the polygon\\n return convert_lane_boundaries_to_polygon(right_centerline, left_centerline)\",\n \"def draw_poly(t, n, sz):\\r\\n angle = 180 - (n - 2) * 180 / n\\r\\n for i in range(n):\\r\\n t.forward(sz)\\r\\n t.left(angle)\",\n \"def add_polyline(self, layer_to_use,poly,open):\\n if type(poly) is not list:\\n toplot = [poly]\\n else:\\n toplot = poly\\n\\n for y in toplot:\\n\\n polyline = self.msp.add_polyline2d(\\n points=[],\\n dxfattribs={'layer': layer_to_use['name']})\\n\\n if open==True:\\n polyline.close(False)\\n else:\\n polyline.close(True)\\n y = np.round(100*y)/100\\n if layer_to_use['inversion']==0:\\n polyline.append_vertices(y)\\n else:\\n polyline.append_vertices(-y)\",\n \"def draw_spline(env, spline, num=100, linewidth=1.0, colors=(0,0,1),\\n start=0, stop=1):\\n linestrip = []\\n for u in np.linspace(start, stop, num=num):\\n linestrip.append(spline(u))\\n h = env.drawlinestrip(np.array(linestrip), linewidth=linewidth,\\n colors=np.array(colors))\\n return h\",\n \"def draw_lines(args, img, lines, color=[255, 0, 0], thickness=8):\\n slopes = [ (line[0][3]-line[0][1])/(line[0][2]-line[0][0]) for line in lines]\\n rights = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope > 0.0 ] # and slope < 0.5 and not np.isnan(slope) ]\\n lefts = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope < 0.0 ] # and slope > -0.5 and not np.isnan(slope) ]\\n #lefts[0] = [ [[x1,y1,x2,y2]] , slope , y_intercept ]\\n\\n y_mins = [ min(line[0][1],line[0][3]) for line in lines]\\n y_min = min(y_mins)\\n y_max = img.shape[0]\\n\\n log_new = [slopes, rights, lefts, y_mins, y_min, y_max]\\n\\n for lanes in [rights,lefts]:\\n slope_mean = np.mean( [ lane[1] for lane in lanes ] )\\n slope_std = np.std ( [ lane[1] for lane in lanes ] )\\n if slope_std == 0:\\n slope = slope_mean\\n else:\\n slope = np.mean( [ lane[1] for lane in lanes if lane[1] - slope_mean < 2*slope_std ] ) \\n print()\\n print('slope : {}'.format(slope))\\n\\n intercept_mean = np.mean( [ lane[2] for lane in lanes ] )\\n intercept_std = np.std ( [ lane[2] for lane in lanes ] )\\n if intercept_std == 0:\\n intercept = intercept_mean\\n else:\\n intercept = np.mean( [ lane[2] for lane in lanes if lane[2] - intercept_mean < 2*intercept_std ] )\\n print('intercept : {}'.format(intercept))\\n \\n x_min = int( ( y_min - intercept ) / slope ) \\n x_max = int( ( y_max - intercept ) / slope )\\n\\n log_new.append(slope)\\n log_new.append(intercept)\\n log_new.append(x_min)\\n log_new.append(x_max)\\n\\n cv2.line(img, (x_min, y_min), (x_max, y_max), color, thickness)\\n\\n try: \\n log_line = pd.read_csv(args.path+args.csv_file, skiprows=[0], names=args.header)\\n except:\\n log_line = pd.DataFrame([ ], columns=args.header)\\n finally:\\n df = pd.DataFrame([ log_new ], columns=args.header)\\n # update log: add new entry into the log\\n result = pd.concat([log_line, df], ignore_index=True)\\n result.to_csv(args.path+args.csv_file) #, index=False)\",\n \"def plot_lines(line_list, line_width=1.0):\\n \\n for line in line_list: \\n start_lat, end_lat, start_lon, end_lon, color, style, input_projection, resolution = line\\n \\n assert style in list(line_style_dict.keys())\\n assert resolution in ['high', 'low']\\n\\n start_lat = float(start_lat)\\n start_lon = float(start_lon)\\n end_lat = float(end_lat)\\n end_lon = float(end_lon)\\n\\n lons = iris.analysis.cartography.wrap_lons(numpy.array([start_lon, end_lon]), 0, 360)\\n # FIXME: start=0 might not work for all input/output projection combos\\n\\n if resolution == 'low':\\n lats = numpy.array([start_lat, end_lat]) \\n elif resolution == 'high':\\n assert start_lat == end_lat or start_lon == end_lon, \\\\\\n \\\"High res lines need constant lat or lon in reference coordinate system\\\"\\n\\n if start_lat == end_lat:\\n lons = numpy.arange(lons[0], lons[-1] + 0.5, 0.5)\\n lats = numpy.repeat(start_lat, len(lons))\\n else:\\n lats = numpy.arange(start_lat, end_lat + 0.5, 0.5)\\n lons = numpy.repeat(lons[0], len(lats))\\n\\n plt.plot(lons, lats, \\n linestyle=line_style_dict[style], \\n color=color, linewidth=line_width,\\n transform=input_projections[input_projection])\",\n \"def _drawpoly(self, polyitem, coordlist, fill=None,\\n outline=None, width=None, top=False):\\n cl = []\\n for x, y in coordlist:\\n cl.append(x * self.xscale)\\n cl.append(-y * self.yscale)\\n self.cv.coords(polyitem, *cl)\\n if fill is not None:\\n self.cv.itemconfigure(polyitem, fill=fill)\\n if outline is not None:\\n self.cv.itemconfigure(polyitem, outline=outline)\\n if width is not None:\\n self.cv.itemconfigure(polyitem, width=width)\\n if top:\\n self.cv.tag_raise(polyitem)\",\n \"def draw_grid(plt):\\n x0, x1, x2, x3 = 0, 3057, 6508, 9860\\n y0, y1, y2, y3, y4, y5, y6, y7, y8 = 0, 1535, 2041, 2547, 3053, 3559, 4257, 5303, 6978\\n alpha, linewidth = 0.3, 0.5\\n\\n # Vertical Lines\\n plt.plot((x0, x0), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x1, x1), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x2, x2), (y0, y5), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x3, x3), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n\\n # Horizontal Lines\\n plt.plot((x0, x3), (y0, y0), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y1, y1), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y2, y2), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y3, y3), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y4, y4), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y5, y5), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x1), (y6, y6), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x1, x3), (y7, y7), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y8, y8), 'black', alpha=alpha, linewidth=linewidth)\",\n \"def DrawRectanglePointSize(*args, **kwargs):\\n return _gdi_.PseudoDC_DrawRectanglePointSize(*args, **kwargs)\",\n \"def draw_line(self, DISP, side:str, indizes:tuple, pink = False):\\r\\n offset = 1 #< Just to draw the line nicely\\r\\n pos = (indizes[0] - 1) * self.grid_size, indizes[1] * self.grid_size\\r\\n # Check if it's a pink line\\r\\n if pink:\\r\\n start_pos = pos[0], pos[1] + self.grid_size // 2\\r\\n end_pos = pos[0] + self.grid_size, pos[1] + self.grid_size // 2\\r\\n # Check if the line should be vertically. u for up\\r\\n elif side == 'u':\\r\\n start_pos = pos[0] + self.width - offset + self.grid_size // 2, pos[1] + self.grid_size // 2\\r\\n end_pos = pos[0] + self.grid_size + offset + self.grid_size // 2 - self.width, pos[1] + self.grid_size // 2\\r\\n # Check if the line should be horizontally. l for left\\r\\n elif side == 'l':\\r\\n start_pos = pos[0] + self.grid_size // 2, pos[1] + self.width - offset + self.grid_size // 2\\r\\n end_pos = pos[0] + self.grid_size // 2, pos[1] - self.width + self.grid_size + offset + self.grid_size // 2\\r\\n if not pink:\\r\\n pg.draw.line(DISP, Colors.colors['BLACK'], start_pos,end_pos, self.width + 2 * offset) \\r\\n else:\\r\\n pg.draw.line(DISP, Colors.colors['PINK'], start_pos,end_pos, self.width + 2 * offset)\",\n \"def drawShapes(self):\\n self.draw_polygon(self.poly3.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly2.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly1.get_points() , color = \\\"#000\\\")\\n self.draw_rect(0, 0, self.width, self.height, color= \\\"#000\\\")\\n \\\"\\\"\\\"These statements are used to determine if a point is inside any of the\\n 3 polygons and if so changes the point's color\\\"\\\"\\\"\\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\\n or self.poly3.point_inside_polygon(self.p1)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\\n\\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\\n or self.poly3.point_inside_polygon(self.p2)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\\n or self.poly3.point_inside_polygon(self.p3)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)\",\n \"def increase_point_thickness(pt,grid_size):\\n\\n\\tif grid_size % 2 == 0:\\n\\t\\treturn ValueError(\\\"Grid Size must be odd\\\")\\n\\t\\n\\tgrid_width = int((grid_size -1) / 2)\\n\\tpt_list = []\\n\\tfor j in range(-grid_width,grid_width + 1):\\n\\t\\tleft_list = [(pt[0] - j,pt[1] - i) for i in range(1,grid_width + 1)]\\n\\t\\tright_list = [(pt[0] - j,pt[1] + i) for i in range(1,grid_width + 1)]\\n\\t\\tmiddle_list = left_list + [(pt[0] - j,pt[1])] + right_list\\n\\t\\tpt_list.extend(middle_list)\\n\\n\\treturn pt_list\",\n \"def draw_combined(self, points: Iterable[Tuple[float, float, float, float, Text]],eps: float = 1e-8):\\n for i, p in enumerate(points[1:-1]):\\n last_p = points[i]\\n next_p = points[i+2]\\n w = sum([last_p[2], p[2], next_p[2]]) / 3.\\n self.output.write(f'<polyline points=\\\"{round(last_p[0])},{round(last_p[1])} {round(p[0])},{round(p[1])} {round(next_p[0])},{round(next_p[1])}\\\" style=\\\"fill:none;stroke:{p[4]};stroke-width:{w};opacity:{p[3]}\\\" />')\\n last_p = p\",\n \"def add_poly_corners(self, poly_item, marker_dict=None):\\n poly = poly_item.polygon()\\n\\n for i in range(poly.size()):\\n point = poly.at(i)\\n p = self.addEllipse(-4, -4, 8, 8, self.LUBronze, self.LUBronze)\\n p.setZValue(2) # Make sure corners always in front of polygon surfaces\\n p.setParentItem(poly_item)\\n p.__setattr__(\\\"localIndex\\\", int(i))\\n p.setPos(point.x(), point.y())\\n p.setFlag(QGraphicsItem.ItemIsSelectable)\\n p.setFlag(QGraphicsItem.ItemIsMovable)\\n self.point_coord_list = np.append(self.point_coord_list, [[p.x(), p.y()]], axis=0)\\n\\n self.potential_edge_splitters.append(p)\\n\\n # Used to pass markers when loading a g\\n if marker_dict:\\n if i in marker_dict:\\n self.add_marker(p, marker_dict[i])\\n text = p.childItems()[0]\\n text.setVisible(False)\",\n \"def onscreen_pres(mpl, screenwidth=1200):\\n mpl.rcParams['lines.linewidth'] = 2\\n fontsize = round(14 / (800.0 / screenwidth))\\n mpl.rcParams['font.size'] = fontsize\",\n \"def onChartSeriesLineWidthChanged(self, name, width):\\n series = self.series[name]\\n self.pen[name].setWidth(width)\\n series.setPen(self.pen[name])\",\n \"def rect(x: float, y: float, width: float, height: float) -> LineCollection:\\n return LineCollection(\\n [\\n (\\n complex(x, y),\\n complex(x + width, y),\\n complex(x + width, y + height),\\n complex(x, y + height),\\n complex(x, y),\\n )\\n ]\\n )\",\n \"def addLine(self, verts, color=[220,0,0], thickness=1.0, alpha=255,\\n linestyle='=', selectable=True, movable=True, isCosmetic=False):\\n\\n # addLine is just a simplified interface to addPolygon\\n return QViewerBase.addPolygon(self, verts, color=color, thickness=thickness, alpha=alpha,\\n linestyle=linestyle, selectable=selectable, movable=movable,\\n closed=False, isCosmetic=isCosmetic)\",\n \"def connect_poly(self):\\n\\n offset = self.lower_pmos_inst.get_pin(\\\"G\\\").ll()\\n # connects the top and bottom pmos' gates together\\n ylength = self.upper_pmos1_inst.get_pin(\\\"G\\\").ll().y - offset.y\\n self.add_rect(layer=\\\"poly\\\",\\n offset=offset,\\n width=self.poly_width,\\n height=ylength)\\n\\n # connects the two poly for the two upper pmos(s)\\n offset = offset + vector(0, ylength - self.poly_width)\\n xlength = self.upper_pmos2_inst.get_pin(\\\"G\\\").lx() - self.upper_pmos1_inst.get_pin(\\\"G\\\").lx() + self.poly_width\\n self.add_rect(layer=\\\"poly\\\",\\n offset=offset,\\n width=xlength,\\n height=self.poly_width)\",\n \"def pp(points):\\n plt.plot(points[:,0], points[:,1], '.--')\\n plt.gca().set_aspect('equal', 'box')\",\n \"def display(points: List[Point], color, width=1) -> None:\\n x = []\\n y = []\\n for point in points:\\n x.append(point[0])\\n y.append(point[1])\\n plt.plot(x, y, c=color, linewidth=width)\",\n \"def hLine(x_min, x_max, y):\\n glClear(GL_COLOR_BUFFER_BIT)\\n glColor3f(1.0, 0.0, 0.0)\\n glPointSize(10.0) # Set the point with a specific radius\\n glBegin(GL_POINTS) # Begin plotting point\\n x = x_min\\n while (x <= x_max):\\n glVertex2f(x, y)\\n x += 0.05\\n glEnd()\\n glFlush()\",\n \"def draw_line(mat, pt1, pt2, color=(0, 0, 255), thickness=1):\\n cv2.line(mat, pt1, pt2, color, thickness=thickness)\",\n \"def draw_polygon(self, *points, color=DEFAULT.color):\",\n \"def draw(self, image, color, width, quad=None):\\n if image is None:\\n image = self.image.copy()\\n if quad is None:\\n quad = self.quad\\n color = tuple(np.int32(color).tolist())\\n cv2.polylines(image, [np.int32(quad)], True, color, int(width))\\n return image\",\n \"def wdraw_polygon(self, wcoords, fill, outline):\\r\\n dpoints = []\\r\\n for i in range(0, len(wcoords), 2):\\r\\n dpoints += self.w_to_d(wcoords[i], wcoords[i+1])\\r\\n self.canvas.create_polygon(dpoints, fill=fill, outline=outline)\",\n \"def plot_startpoints( polylines, mymap ):\\n map( \\\\\\n lambda start : mymap.addpoint( start[0][0], start[0][1], \\\"#FF0000\\\") if start != [] else [],\\n polylines)\",\n \"def draw(self):\\n if len(self.__points) >= 2:\\n self._total_length = 0\\n for i in range(len(self.__points) - 1):\\n p1 = self.__points[i]\\n p2 = self.__points[i + 1]\\n coords = self.__line_segment(p1, p2)\\n if not coords is None:\\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\\n [0, 1, 2, 1, 2, 3],\\n ('v2i', coords),\\n ('c4b', self.color * 4)\\n )\\n coords = self.__line_cap(p2)\\n pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,\\n [0, 1, 2, 0, 2, 3],\\n ('v2i', coords),\\n ('c4b', self.color * 4)\\n )\",\n \"def draw_line(self, color, p1: Point, p2: Point, width):\\n _p1 = self.T.itrans(p1)\\n _p2 = self.T.itrans(p2)\\n pg.draw.line(self.screen, color, _p1(), _p2(), 2)\",\n \"def whirl_plot(polygons, iterations, step, fpath, **kwargs):\\n for polygon in polygons:\\n for _ in range(iterations):\\n # pylint: disable=invalid-name\\n xy = np.vstack([polygon, polygon[0]])\\n plt.plot(*np.hsplit(xy, 2), **kwargs)\\n\\n diff = polygon - np.roll(polygon, 1, axis=0)\\n norm_velocity = diff / np.linalg.norm(diff, axis=1, keepdims=True)\\n\\n polygon -= step * norm_velocity\\n\\n plt.gca().set_aspect(\\\"equal\\\")\\n plt.gca().axis(\\\"off\\\")\\n\\n canvas = FigureCanvasAgg(plt.gcf())\\n canvas.draw()\\n\\n stream, (width, height) = canvas.print_to_buffer()\\n img = np.fromstring(stream, np.uint8).reshape((height, width, 4))\\n\\n plt.imsave(fpath, _trim_border(img))\",\n \"def draw_poly(drawer, center, sides, scale, color=None, border=None, rotation=0):\\n if color is None and border is None:\\n raise ValueError(\\\"There must be a value for color or border.\\\")\\n\\n center = center[0] + center[1] * 1j\\n\\n # Repeat the first coordinate at the end to make border drawing simpler.\\n corners = [\\n center + cmath.rect(scale, 2 * k * cmath.pi / sides + rotation)\\n for k in range(sides + 1)\\n ]\\n corners = [(z.real, z.imag) for z in corners]\\n\\n if color is not None:\\n drawer.polygon(corners[:sides], fill=color)\\n\\n if border is not None:\\n for i in range(sides):\\n drawer.line((corners[i], corners[i + 1]), fill=border, width=(scale // 10))\",\n \"def draw_point(self, p):\\n length = 3\\n self.set_line_width(0.1)\\n self.set_source_rgba(0, 0, 1, 1)\\n self.move_to(p.x + length, p.y)\\n self.line_to(p.x - length, p.y)\\n self.stroke()\\n self.move_to(p.x, p.y + length)\\n self.line_to(p.x, p.y - length)\\n self.stroke()\",\n \"def _line_for_legend():\\n points = [\\n [0, 0, 0],\\n [0.4, 0, 0],\\n [0.4, 0.07, 0],\\n [0, 0.07, 0],\\n [\\n 0.5,\\n 0,\\n 0,\\n ], # last point needed to expand the bounds of the PolyData to be rendered smaller\\n ]\\n legendface = pyvista.PolyData()\\n legendface.points = np.array(points)\\n legendface.faces = [4, 0, 1, 2, 3]\\n return legendface\",\n \"def wdraw_line(self, wx0, wy0, wx1, wy1, color, arrow):\\r\\n dx0, dy0 = self.w_to_d(wx0, wy0)\\r\\n dx1, dy1 = self.w_to_d(wx1, wy1)\\r\\n self.canvas.create_line(dx0, dy0, dx1, dy1, fill=color, arrow=arrow)\",\n \"def redraw_whole_plot(self):\\n pcent_rand = self.rand\\n pcent_decimal = pcent_rand/100\\n self.x = np.array([\\n n*np.random.uniform(low=1-pcent_decimal, high=1+pcent_decimal) \\n for n in np.linspace(3, 9, self.num_points)\\n ])\\n self.y = np.array([\\n n*np.random.uniform(low=1-pcent_decimal, high=1+pcent_decimal)\\n for n in np.linspace(3, 9, self.num_points)\\n ])\\n self.redraw_slope()\",\n \"def road_lines():\\n cv2.polylines(frame_1, [pts_1], True, yellow_color)\\n cv2.polylines(frame_2, [pts_2], True, yellow_color)\",\n \"def StrokeLines(*args, **kwargs):\\n return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs)\",\n \"def drawPolyline(points, ax, linespec=None):\\n if len(points.shape) != 2 or points.shape[0] != 2:\\n raise ValueError(\\\"'points' must be 2xN\\\")\\n if linespec is None:\\n linespec = __color_cycle.next() + 'o-'\\n ax.plot(points[0,:].T, points[1,:].T, linespec)\",\n \"def __draw_polygon(self, event, klick):\\n global creating_polygon\\n curX = self.canvas.canvasx(event.x)\\n curY = self.canvas.canvasy(event.y)\\n if not klick and len(self.polygon_points) >= 2:\\n c_r_x, c_r_y = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\\n distanceX = curX - c_r_x\\n distanceY = curY - c_r_y\\n if pow(pow(distanceX, 2) + pow(distanceY, 2), 1 / 2) <= 15:\\n return\\n image_relative_x, image_relative_y = self.get_image_relative_coords((curX, curY))\\n self.polygon_points.extend((image_relative_x, image_relative_y))\\n self.polygon_groundstructure.append(self.canvas.create_rectangle(curX - 2, curY - 2, curX + 2, curY + 2,\\n outline='magenta', width=1,\\n activewidth=2))\\n if not creating_polygon: # start with a new polygon\\n creating_polygon = True\\n return\\n else: # draw a line between the last points\\n c_r_x1, c_r_y1 = self.get_canvas_relative_coords((self.polygon_points[-4], self.polygon_points[-3]))\\n c_r_x2, c_r_y2 = self.get_canvas_relative_coords((self.polygon_points[-2], self.polygon_points[-1]))\\n self.polygon_groundstructure.append(self.canvas.create_line([c_r_x1, c_r_y1, c_r_x2, c_r_y2],\\n fill='magenta', width=2))\",\n \"def show_path_2D(start, end, coordinates, polygons, clear = True):\\n global L, N, delta_t\\n\\n # start interactive mode\\n plt.ion()\\n\\n # crete eempty figure on which data will go and first subplot\\n fig = plt.figure()\\n\\n # get into the correct time step\\n for time_step in range(start, end):\\n # list of colours used for animation\\n colours = cm.rainbow(np.linspace(0, 1, N))\\n\\n # loop over each particle and colour\\n for i in range(N):\\n # plot x, y poistion of particle in a given colour and set axis to size of box\\n plt.scatter(coordinates[time_step][i][0], coordinates[time_step][i][1], s = 1, color = 'r')\\n\\n # plot the object\\n if i < M:\\n polygon = np.array(polygons[time_step][i])\\n # get the points of the polygon to plot it\\n x, y = polygon.T\\n\\n # print(x, y)\\n\\n x = np.append(x, x[0])\\n y = np.append(y, y[0])\\n\\n # print(x, y)\\n\\n # plot the polygon\\n plt.plot(x , y)\\n # plt.scatter(polygons_com[time_step][i][0], polygons_com[time_step][i][1], s = 5, color = 'g')\\n\\n if bound_cond == True:\\n plt.axis([0, L, 0, L])\\n plt.axis([0, L, 0, L])\\n # plt.axis([-L*2, L*2, -L*2, L*2])\\n\\n # show graph\\n plt.show()\\n plt.pause(time_pause)\\n\\n # decide if you want to clear\\n if clear == True:\\n plt.clf()\\n\\n return None\",\n \"def create_path(number_of_vertices, radius, thickness):\\n\\n global screen\\n dist_apart = radius * 3\\n\\n for i in range(0, number_of_vertices):\\n vtx_x = i*dist_apart + int((WINDOW_WIDTH - dist_apart * (number_of_vertices - 1)) / 2)\\n vtx_y = int(WINDOW_HEIGHT / 2)\\n\\n vtx = {\\\"ID\\\": i,\\n \\\"x\\\": vtx_x,\\n \\\"y\\\": vtx_y,\\n \\\"color\\\": \\\"WHITE\\\",\\n \\\"adjacent\\\": [],\\n }\\n\\n VERTICES.append(vtx);\\n\\n # Assign adjacency\\n for i in range(0, number_of_vertices):\\n if i is not number_of_vertices - 1:\\n VERTICES[i][\\\"adjacent\\\"].append(VERTICES[i + 1][\\\"ID\\\"])\\n VERTICES[i + 1][\\\"adjacent\\\"].append(VERTICES[i][\\\"ID\\\"])\\n\\n draw_graph(VERTICES, radius, thickness)\",\n \"def addPolyLineToScene(self, controlPoint, colorVar, needleType='Detection',script=False, endMarker=False, name=\\\"^\\\", trans=0, manualName=\\\"\\\",radius=1,bPause=False):\\r\\n #research\\r\\n #profprint()\\r\\n \\\"\\\"\\\"\\r\\n Create a model of the linear needle segments\\r\\n \\\"\\\"\\\"\\r\\n widget = slicer.modules.NeedleFinderWidget\\r\\n\\r\\n realNeedleLength = widget.realNeedleLength.value\\r\\n extendNeedle = widget.extendNeedle.isChecked()\\r\\n\\r\\n # sort the points in a decreasing order (from tip to bottom)\\r\\n controlPointListSorted = controlPoint #self.sortTableReverse(controlPoint, (2, 1, 0))\\r\\n\\r\\n # calculate the length of the list of ctr points\\r\\n lenghtTotal = 0\\r\\n for i in range(len(controlPoint) - 1):\\r\\n lenghtTotal += self.distanceTwoPoints(controlPointListSorted[i + 1], controlPointListSorted[i])\\r\\n #print \\\"Polygon added to scene, length of tube: \\\", lenghtTotal\\r\\n\\r\\n # in case we want to extend the needle to the wanted length\\r\\n \\\"\\\"\\\"\\r\\n The extension is currently done by adding a point to the control point list.\\r\\n \\\"\\\"\\\"\\r\\n if lenghtTotal < realNeedleLength and extendNeedle:\\r\\n lastPoint = [controlPointListSorted[-1][0], controlPointListSorted[-1][1], controlPointListSorted[-1][2] - (realNeedleLength - lenghtTotal)]\\r\\n controlPointListSorted.append(lastPoint)\\r\\n\\r\\n scene = slicer.mrmlScene\\r\\n points = vtk.vtkPoints()\\r\\n polyData = vtk.vtkPolyData()\\r\\n polyData.SetPoints(points)\\r\\n lines = vtk.vtkCellArray()\\r\\n polyData.SetLines(lines)\\r\\n linesIDArray = lines.GetData()\\r\\n linesIDArray.Reset()\\r\\n linesIDArray.InsertNextTuple1(0)\\r\\n polygons = vtk.vtkCellArray()\\r\\n polyData.SetPolys(polygons)\\r\\n idArray = polygons.GetData()\\r\\n idArray.Reset()\\r\\n idArray.InsertNextTuple1(0)\\r\\n n = len(controlPointListSorted)\\r\\n # start read out\\r\\n for i in range(n):\\r\\n pointIndex = points.InsertNextPoint(*(controlPointListSorted[i]))\\r\\n linesIDArray.InsertNextTuple1(pointIndex)\\r\\n linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1)\\r\\n lines.SetNumberOfCells(1)\\r\\n # ## Create model node\\r\\n model = slicer.vtkMRMLModelNode()\\r\\n model.SetScene(scene)\\r\\n model.SetAndObservePolyData(polyData)\\r\\n # ## Create display node\\r\\n modelDisplay = slicer.vtkMRMLModelDisplayNode()\\r\\n\\r\\n modelDisplay.SetScene(scene)\\r\\n scene.AddNode(modelDisplay)\\r\\n model.SetAndObserveDisplayNodeID(modelDisplay.GetID())\\r\\n # ## Add to scene\\r\\n modelDisplay.SetInputPolyDataConnection(model.GetPolyDataConnection())\\r\\n scene.AddNode(model)\\r\\n # ##Create Tube around the line\\r\\n tube = vtk.vtkTubeFilter()\\r\\n polyData = model.GetPolyData()\\r\\n tube.SetInputData(polyData)\\r\\n tube.SetRadius(radius)\\r\\n tube.SetNumberOfSides(50)\\r\\n tube.Update()\\r\\n\\r\\n model.SetAndObservePolyData(tube.GetOutput())\\r\\n model.GetDisplayNode().SliceIntersectionVisibilityOn()\\r\\n model.GetDisplayNode().SetOpacity(1-trans)\\r\\n if needleType == 'Validation':\\r\\n model.SetName('.manual-seg_' + str(colorVar))\\r\\n elif needleType == 'Obturator':\\r\\n model.SetName('.obturator-seg_' + str(colorVar))\\r\\n else:\\r\\n model.SetName('.auto-seg_' + str(self.round) + '-ID-' + str(model.GetID())+'-'+manualName)\\r\\n model.SetAttribute('type', needleType)\\r\\n\\r\\n if needleType == 'Validation' or needleType =='Debug':\\r\\n nth = int(colorVar) % MAXCOL\\r\\n modelDisplay.SetColor(self.color[int(nth)][0], self.color[int(nth)][1], self.color[int(nth)][2])\\r\\n model.SetAttribute(\\\"nth\\\", str(nth))\\r\\n\\r\\n else:\\r\\n nth = int(model.GetID().strip('vtkMRMLModelNode')) % MAXCOL\\r\\n modelDisplay.SetColor(self.color[int(nth)][0], self.color[int(nth)][1], self.color[int(nth)][2])\\r\\n model.SetAttribute(\\\"nth\\\", str(nth))\\r\\n\\r\\n if endMarker:\\r\\n fiducial = slicer.mrmlScene.CreateNodeByClass('vtkMRMLAnnotationFiducialNode')\\r\\n fiducial.SetName('.'+name+'_'+str(colorVar))\\r\\n fiducial.Initialize(slicer.mrmlScene)\\r\\n fiducial.SetFiducialCoordinates(controlPointListSorted[-1])\\r\\n fiducial.SetAttribute('TemporaryFiducial', '1')\\r\\n fiducial.SetLocked(True)\\r\\n displayNode = fiducial.GetDisplayNode()\\r\\n displayNode.SetGlyphScale(.5) # \\\"arrow head\\\"\\r\\n displayNode.SetColor(0, 0, 0)\\r\\n textNode = fiducial.GetAnnotationTextDisplayNode()\\r\\n textNode.SetTextScale(1)\\r\\n textNode.SetColor(0, 0, 0)\\r\\n if bPause: breakbox('Inspect this situation in the viewer!')\",\n \"def add_outline(component, layer=LAYER.DEVREC):\\n c = component\\n points = [\\n [c.xmin, c.ymin],\\n [c.xmax, c.ymin],\\n [c.xmax, c.ymax],\\n [c.xmin, c.ymax],\\n ]\\n c.add_polygon(points, layer=layer)\",\n \"def draw_avg_ext_lines(img, lines, color=[255, 0, 0], thickness=10):\\n debug=False\\n lSlopeAvg=0\\n rSlopeAvg=0\\n slope_tolerance=.1\\n slope_tolerance_from_zero=.5\\n bottom_y = img.shape[0]\\n top_y = int(bottom_y /1.6)\\n \\n lLines = []\\n rLines = []\\n l = 1\\n r = 1\\n \\n for line in lines:\\n for x1,y1,x2,y2 in line:\\n slope = (y2-y1)/(x2-x1)\\n if np.absolute(slope) == np.inf or np.absolute(slope) < slope_tolerance_from_zero:\\n continue\\n if debug:\\n cv2.line(img, (x1, y1), (x2, y2), color, thickness)\\n if slope < 0:\\n lSlopeAvg = lSlopeAvg + (slope - lSlopeAvg) / l\\n l += 1\\n if np.absolute(lSlopeAvg - slope) < slope_tolerance :\\n lLines.append((x1,y1))\\n lLines.append((x2,y2))\\n else:\\n rSlopeAvg = rSlopeAvg + (slope - rSlopeAvg) / r\\n r += 1\\n if np.absolute(rSlopeAvg - slope) < slope_tolerance :\\n rLines.append((x1,y1))\\n rLines.append((x2,y2)) \\n \\n \\\"\\\"\\\"\\n After having split the lines, I use cv2.fitline to fit the sets of points to a single line.\\n cv2.fitline gives back a unit vector and a point in the line, both of which we can use\\n to calculate the slope and intercept of the line function.\\n \\\"\\\"\\\"\\n if len(lLines) > 0 and len(rLines) > 0 :\\n [left_vx,left_vy,left_x,left_y] = cv2.fitLine(np.array(lLines, dtype=np.int32), cv2.DIST_L2,0,0.01,0.01) \\n left_slope = left_vy / left_vx\\n left_b = left_y - (left_slope*left_x)\\n\\n [right_vx,right_vy,right_x,right_y] = cv2.fitLine(np.array(rLines, dtype=np.int32), cv2.DIST_L2,0,0.01,0.01) \\n right_slope = right_vy / right_vx\\n right_b = right_y - (right_slope*right_x)\\n\\n # Average this line with previous frames \\n prev_lines.append((left_b, left_slope, right_b, right_slope))\\n \\n if len(prev_lines) > 0: \\n avg = np.sum(prev_lines, -3) /len(prev_lines)\\n left_b = avg[0]\\n left_slope = avg[1]\\n right_b = avg[2]\\n right_slope = avg[3]\\n\\n \\\"\\\"\\\"\\n Having the slope and intercept enables us to calculate the x coordinates of our desired\\n start and end points at the top and the bottom of the road.\\n \\\"\\\"\\\"\\n ltop_x = (top_y - left_b) / left_slope\\n lbottom_x = (bottom_y - left_b) / left_slope\\n\\n rtop_x = (top_y - right_b) / right_slope\\n rbottom_x = (bottom_y - right_b) / right_slope\\n\\n cv2.line(img, (lbottom_x, bottom_y), (ltop_x, top_y), color, thickness)\\n cv2.line(img, (rbottom_x, bottom_y), (rtop_x, top_y), color, thickness)\",\n \"def DrawRectanglePointSize(*args, **kwargs):\\n return _gdi_.DC_DrawRectanglePointSize(*args, **kwargs)\",\n \"def draw_lines_slow(orbit_pos, factor):\",\n \"def draw_xywh_rectangle_outline(top_left_x, top_left_y, width, height, color,\\n border_width=1):\\n center_x = top_left_x + (width / 2)\\n center_y = top_left_y + (height / 2)\\n draw_rectangle_outline(center_x, center_y, width, height, color,\\n border_width)\",\n \"def drawPath(self):\\r\\n bgl.glColor4f(0.8,0.8,0.9,0.01)\\r\\n bgl.glLineWidth(0.01)\\r\\n\\r\\n bgl.glBegin(bgl.GL_LINES)\\r\\n bgl.glVertex3f(self.p1[0],self.p1[1],self.p1[2])\\r\\n bgl.glVertex3f(self.p2[0],self.p2[1],self.p2[2])\\r\\n bgl.glEnd()\\r\\n\\r\\n bgl.glNormal3f(0.0,0.0,1.0)\\r\\n bgl.glShadeModel(bgl.GL_SMOOTH);\",\n \"def plot_polygon(polygon, size_points_distrib=50):\\n # Get the points\\n list_points = list(polygon.exterior.coords)\\n distances = np.array(scipy.spatial.distance.euclidean([elt[0] for elt in list_points], [elt[1] for elt in list_points]))\\n avg_dist = distances.mean()\\n\\n # Get the boundaries\\n minx, miny, maxx, maxy = polygon.bounds\\n box_points = box(minx, miny, maxx, maxy, ccw=True)\\n\\n fig, ax = plt.subplots(figsize=(10, 10))\\n\\n # Box\\n plt.scatter(*zip(*list(box_points.exterior.coords)), color='black', linestyle=\\\"--\\\", alpha=0.2)\\n plt.plot(*zip(*list(box_points.exterior.coords)), color='black', linestyle=\\\"--\\\", alpha=0.2)\\n\\n # Polygon\\n plt.scatter(*zip(*list_points), color='blue')\\n plt.plot(*zip(*list(list_points)), color='blue', linestyle=\\\"-.\\\", alpha=0.2)\\n ax.set(xlim=[minx, maxx])\\n ax.set(ylim=[miny, maxy])\\n\\n # Limits\\n rdm_points = gen_rdm_points_square(polygon, size_points_distrib)\\n # creates mask\\n is_in_distrib = point_in_polygons(polygon, rdm_points)\\n print(rdm_points[is_in_distrib])\\n\\n # Points in\\n x_in, y_in = zip(*rdm_points[is_in_distrib])\\n plt.scatter(x_in, y_in, color='green', alpha=0.2, marker=\\\"+\\\")\\n\\n # Points out\\n x_out, y_out = zip(*rdm_points[~is_in_distrib])\\n plt.scatter(x_out, y_out, color='red', alpha=0.2, marker=\\\"+\\\")\\n\\n plt.show()\",\n \"def add_poly_edges(self, poly_item, marker_dict=None):\\n\\n poly = poly_item.polygon()\\n\\n for i in range(1, poly.size() + 1):\\n if i == poly.size():\\n p1 = poly.at(i - 1)\\n p2 = poly.at(0)\\n index = -poly.size()\\n\\n else:\\n p1 = poly.at(i - 1)\\n p2 = poly.at(i)\\n index = i\\n\\n line = self.addLine(QLineF(p1, p2))\\n line.setZValue(-1)\\n display_line = self.addLine(QLineF(p1, p2), QPen(self.LUBronze, 3))\\n line.__setattr__(\\\"localIndex\\\", index)\\n line.setParentItem(poly_item)\\n display_line.setParentItem(line)\\n self.edge_list.append(line)\\n\\n # Used to pass markers when loading a g\\n if marker_dict:\\n if i - 1 in marker_dict:\\n self.add_marker(display_line, marker_dict[i - 1])\\n display_line.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, False)\\n text = display_line.childItems()[0]\\n text.setVisible(False)\",\n \"def draw(self, camera):\\n for line in self._polyline.lines:\\n camera.draw_line(line.begin, line.end, self.color, self.width)\",\n \"def __draw_path(\\n self, x_path, y_path, opt_line, opt_marker,\\n opt_colour, thickness=0.05):\\n # Get colour\\n colour = self.__get_colour_from_string(opt_colour)\\n\\n # For every point in the list, draw a line to the next one\\n # (excluding last point)\\n for point in range(0, len(x_path)):\\n # Get point 1\\n x1 = x_path[point]\\n y1 = y_path[point]\\n p1 = vector(x1, y1, 0)\\n\\n # If at end / only coordinate - draw a marker\\n if point == len(x_path) - 1:\\n create_marker(self.scene, x1, y1, opt_marker, colour)\\n return\\n\\n # Get point 2\\n x2 = x_path[point + 1]\\n y2 = y_path[point + 1]\\n p2 = vector(x2, y2, 0)\\n\\n if opt_line == '':\\n # Only one marker to avoid double-ups\\n create_marker(self.scene, x1, y1, opt_marker, colour)\\n elif opt_line == '-':\\n create_line(\\n p1, p2, self.scene, colour=colour, thickness=thickness)\\n # Only one marker to avoid double-ups\\n create_marker(self.scene, x1, y1, opt_marker, colour)\\n elif opt_line == '--':\\n create_segmented_line(\\n p1, p2, self.scene, 0.3, colour=colour,\\n thickness=thickness)\\n # Only one marker to avoid double-ups\\n create_marker(self.scene, x1, y1, opt_marker, colour)\\n elif opt_line == ':':\\n create_segmented_line(\\n p1, p2, self.scene, 0.05, colour=colour,\\n thickness=thickness)\\n # Only one marker to avoid double-ups\\n create_marker(self.scene, x1, y1, opt_marker, colour)\\n elif opt_line == '-.':\\n raise NotImplementedError(\\\"Other line types not implemented\\\")\\n else:\\n raise ValueError(\\\"Invalid line type given\\\")\",\n \"def polygon(self, center, angle, points, color=(255, 255, 255), width=0):\\n poly = list()\\n\\n for point in points:\\n point = self._rotate(point, angle)\\n point += center\\n point = self._transform(point)\\n poly.append(point)\\n\\n pygame.draw.polygon(self.screen, color, poly, width)\",\n \"def show_points(self, video, roi_size=None):\\n if roi_size is None:\\n if hasattr(self, 'roi_size'):\\n roi_size = self.roi_size\\n\\n fig, ax = plt.subplots(figsize=(15, 5))\\n ax.imshow(video.mraw[0].astype(float), cmap='gray')\\n ax.scatter(video.points[:, 1],\\n video.points[:, 0], marker='.', color='r')\\n\\n if roi_size is not None:\\n for point in video.points:\\n roi_border = patches.Rectangle((point - self.roi_size//2)[::-1], self.roi_size[1], self.roi_size[0],\\n linewidth=1, edgecolor='r', facecolor='none')\\n ax.add_patch(roi_border)\\n\\n plt.grid(False)\\n plt.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6230124","0.61896694","0.61215425","0.6083533","0.5963582","0.5954477","0.58733976","0.58443934","0.5826821","0.58263594","0.58262116","0.5811678","0.57939386","0.573556","0.5720824","0.5711357","0.57111347","0.57054645","0.56073576","0.557913","0.55431724","0.5536334","0.553583","0.5531654","0.5529746","0.55269706","0.55130357","0.5499437","0.54823595","0.54584074","0.5443384","0.5440205","0.5423629","0.541394","0.5410481","0.54030985","0.53576624","0.53527004","0.5334009","0.53292876","0.53243315","0.5322216","0.53152037","0.52995026","0.5294935","0.52893597","0.52835447","0.52828026","0.52687824","0.5261536","0.52423954","0.52288556","0.52280724","0.52273864","0.5219809","0.52159834","0.52141464","0.52130705","0.5212313","0.5200581","0.51932335","0.51926404","0.51899344","0.51895356","0.5186895","0.5178078","0.51760113","0.51757234","0.5173339","0.5172805","0.5153475","0.51509917","0.51503617","0.5149903","0.51458836","0.51443005","0.5143996","0.5143718","0.51391166","0.5135582","0.5128317","0.5124028","0.5122016","0.5119897","0.5118365","0.5115714","0.511166","0.51096463","0.510419","0.51014763","0.50988734","0.5098022","0.5094942","0.5093273","0.50921816","0.50844634","0.5079295","0.5078388","0.5077461","0.5072084"],"string":"[\n \"0.6230124\",\n \"0.61896694\",\n \"0.61215425\",\n \"0.6083533\",\n \"0.5963582\",\n \"0.5954477\",\n \"0.58733976\",\n \"0.58443934\",\n \"0.5826821\",\n \"0.58263594\",\n \"0.58262116\",\n \"0.5811678\",\n \"0.57939386\",\n \"0.573556\",\n \"0.5720824\",\n \"0.5711357\",\n \"0.57111347\",\n \"0.57054645\",\n \"0.56073576\",\n \"0.557913\",\n \"0.55431724\",\n \"0.5536334\",\n \"0.553583\",\n \"0.5531654\",\n \"0.5529746\",\n \"0.55269706\",\n \"0.55130357\",\n \"0.5499437\",\n \"0.54823595\",\n \"0.54584074\",\n \"0.5443384\",\n \"0.5440205\",\n \"0.5423629\",\n \"0.541394\",\n \"0.5410481\",\n \"0.54030985\",\n \"0.53576624\",\n \"0.53527004\",\n \"0.5334009\",\n \"0.53292876\",\n \"0.53243315\",\n \"0.5322216\",\n \"0.53152037\",\n \"0.52995026\",\n \"0.5294935\",\n \"0.52893597\",\n \"0.52835447\",\n \"0.52828026\",\n \"0.52687824\",\n \"0.5261536\",\n \"0.52423954\",\n \"0.52288556\",\n \"0.52280724\",\n \"0.52273864\",\n \"0.5219809\",\n \"0.52159834\",\n \"0.52141464\",\n \"0.52130705\",\n \"0.5212313\",\n \"0.5200581\",\n \"0.51932335\",\n \"0.51926404\",\n \"0.51899344\",\n \"0.51895356\",\n \"0.5186895\",\n \"0.5178078\",\n \"0.51760113\",\n \"0.51757234\",\n \"0.5173339\",\n \"0.5172805\",\n \"0.5153475\",\n \"0.51509917\",\n \"0.51503617\",\n \"0.5149903\",\n \"0.51458836\",\n \"0.51443005\",\n \"0.5143996\",\n \"0.5143718\",\n \"0.51391166\",\n \"0.5135582\",\n \"0.5128317\",\n \"0.5124028\",\n \"0.5122016\",\n \"0.5119897\",\n \"0.5118365\",\n \"0.5115714\",\n \"0.511166\",\n \"0.51096463\",\n \"0.510419\",\n \"0.51014763\",\n \"0.50988734\",\n \"0.5098022\",\n \"0.5094942\",\n \"0.5093273\",\n \"0.50921816\",\n \"0.50844634\",\n \"0.5079295\",\n \"0.5078388\",\n \"0.5077461\",\n \"0.5072084\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69677657"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14790,"cells":{"query":{"kind":"string","value":"Use polyfit from the mask points for smoothening them"},"document":{"kind":"string","value":"def smoothen_masks(fit, img_, window_size):\n img_size = img_.shape\n mask_poly = np.zeros_like(img_)\n # Get top to Bottom for refactoring #\n mask_y = np.linspace(0, img_size[0] - 1, img_size[0])\n mask_x = get_intercepts(fit, mask_y)\n\n # Smoothen the mask #\n pts = coordinates_to_imgpts(mask_x, mask_y)\n mask_poly_smooth = draw_polylines(mask_poly, pts, window_size)\n return mask_poly_smooth"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def sigclip_polyfit(p, xx, yy, degree, weight = None):\n # read constants from p\n sigclip = p['WAVE_SIGCLIP']\n # initialise the while loop\n sigmax = sigclip + 1\n # initialise mask\n mask = np.ones_like(xx, dtype='Bool')\n while sigmax > sigclip:\n # Need to mask weight here if not None\n if weight is not None:\n weight2 = weight[mask]\n else:\n weight2 = None\n # fit on masked values\n coeff = nanpolyfit(xx[mask], yy[mask], deg=degree, w=weight2)\n # get residuals (not masked or dimension breaks)\n res = yy - np.polyval(coeff, xx)\n # normalise the residuals\n res = np.abs(res / np.nanmedian(np.abs(res[mask])))\n # get the max residual in sigmas\n sigmax = np.max(res[mask])\n # mask all outliers\n if sigmax > sigclip:\n mask[res >= sigclip] = False\n # return the coefficients and mask\n return coeff, mask","def fit_clip(x, y, clip=0.4, index_fit = 2, kernel = 19, mask =\"\", \n xmin=\"\",xmax=\"\",ymin=\"\",ymax=\"\",percentile_min=2, percentile_max=98,\n ptitle=None, xlabel=None, ylabel = None, label=\"\", \n hlines=[], vlines=[],chlines=[], cvlines=[], axvspan=[[0,0]], hwidth =1, vwidth =1,\n plot=True, verbose=True):\n \n # Preparing the data. Trim edges and remove nans\n \n \n \n \n if kernel != 0:\n x = np.array(x)\n y = np.array(y)\n \n y_smooth = signal.medfilt(y, kernel)\n residuals = y - y_smooth\n residuals_std = np.std(residuals)\n \n y_nan = [np.nan if np.abs(i) > residuals_std*clip else 1. for i in residuals ] \n y_clipped = y * y_nan\n \n idx = np.isfinite(x) & np.isfinite(y_clipped)\n \n fit = np.polyfit(x[idx], y_clipped[idx], index_fit) \n pp=np.poly1d(fit)\n y_fit=pp(x)\n y_fit_clipped =pp(x[idx])\n \n if verbose: \n print(\"\\n> Fitting a polynomium of degree\",index_fit,\"using clip =\",clip,\"* std ...\")\n print(\" Eliminated\",len(x)-len(x[idx]),\"outliers, the solution is: \",fit)\n \n if plot:\n if ylabel is None: ylabel = \"y (x)\"\n \n if ptitle is None:\n ptitle = \"Polyfit of degree \"+np.str(index_fit)+\" using clip = \"+np.str(clip)+\" * std\"\n plot_plot(x, [y,y_smooth, y_clipped, y_fit], psym=[\"+\",\"-\", \"+\",\"-\"],\n alpha=[0.5,0.5,0.8,1], color=[\"r\",\"b\",\"g\",\"k\"], label=label,\n xlabel=xlabel, ylabel=ylabel, ptitle=ptitle, \n xmin=xmin,xmax=xmax,ymin=ymin,ymax=ymax,percentile_min=percentile_min, percentile_max=percentile_max,\n hlines=hlines, vlines=vlines,chlines=chlines, cvlines=cvlines, \n axvspan=axvspan, hwidth =hwidth, vwidth =vwidth)\n\n return fit, pp, y_fit, y_fit_clipped, x[idx], y_clipped[idx] \n else:\n fit = np.polyfit(x, y, index_fit) \n pp=np.poly1d(fit)\n y_fit=pp(x)\n return fit, pp, y_fit, y_fit, x, y","def poly_scale(self,p,ind=5,groupby=None):\n\n time = self.data.index.values[:ind]\n\n if groupby is None:\n #group = {(None,self.meta.index)}\n for i in range(self.data.shape[1]):\n temp = self.data.iloc[:,i]\n od = temp.values[:ind]\n\n coeff = np.polyfit(time,od,p)\n\n temp = temp - np.polyval(coeff,self.data.index.values[0])\n self.data.iloc[:,i] = temp\n else:\n group = self.meta.groupby(groupby)\n for k,index in group.groups.items():\n temp = self.data.loc[:,index]\n od = temp.values[:ind,:].ravel()\n\n coeff = np.polyfit(time.tolist()*temp.shape[1],od,p)\n\n temp = temp - np.polyval(coeff,self.data.index.values[0])\n self.data.loc[:,index] = temp","def linear_regression(self, x_data, y_data, mask = None, ax = None):\n if mask is None:\n mask = full(len(y_data), True, dtype=bool)\n poly = poly1d(polyfit(x_data[mask], y_data[mask], 1))\n\n if ax is not None:\n ax.plot(x_data, polyval(poly, x_data), \"--r\",\\\n label = \"Slope: %.2f\" %(poly[1]))\n return poly","def poly2mask(self):\n self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)\n self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)\n img = Image.new(\"L\", (self.x_gridnum, self.y_gridnum), 0)\n\n self.perimeter = 0.0\n for ii in self.polygons:\n pp = np.array(ii) * self.CD # polygon\n polygonlen = len(pp)\n self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))\n pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize\n pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize\n vetex_list = list(pp)\n polygon = [tuple(y) for y in vetex_list]\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\n\n self.data = np.array(img)\n self.data = np.float64(self.data)\n\n self.spat_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.freq_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))","def test_linear_fit_2d_model_set_masked_values(self):\n init_model = models.Polynomial2D(1, n_models=2)\n x, y = np.mgrid[0:5, 0:5]\n z = np.ma.masked_array(\n [2 * x + 3 * y + 1, x - 0.5 * y - 2], mask=np.zeros_like([x, x])\n )\n\n z[0, 3, 1] = -1000.0 # throw off fit coefficients if unmasked\n z.mask[0, 3, 1] = True\n\n fitter = LinearLSQFitter()\n fitted_model = fitter(init_model, x, y, z)\n\n assert_allclose(fitted_model.c0_0, [1.0, -2.0], atol=1e-14)\n assert_allclose(fitted_model.c1_0, [2.0, 1.0], atol=1e-14)\n assert_allclose(fitted_model.c0_1, [3.0, -0.5], atol=1e-14)","def fitdata(X, Y, func, mask, p0 = None, filename = \"fit\", sigma = None,\\\r\n xlabel = None, ylabel = None, scatter = False):\r\n \r\n #gather indices that are within the masking region \r\n index = (X>mask[0]) & (X<mask[1])\r\n \r\n #get parameters of the fitting of the function using scipy\r\n (p, er) = optimize.curve_fit(func, X[index], Y[index], p0 = p0,\\\r\n sigma = sigma)\r\n \r\n #print out the parameter values and the errors\r\n print(\"###################\")\r\n print(p)\r\n print(np.sqrt(np.diag(er)))\r\n print(\"###################\")\r\n \r\n #create scatter plot if required\r\n if scatter:\r\n f = plt.figure()\r\n ax1 = f.add_subplot(111)\r\n ax1.scatter(X, Y, linewidth = 1, label = \"data\", marker = 'x')\r\n ax1.set_xlabel(xlabel)\r\n ax1.set_ylabel(ylabel)\r\n else:\r\n f = makeplot(X, [Y], [\"data\"], xlabel, ylabel, plainlines = True)\r\n f.axes[0].plot(np.linspace(X[index][0],X[index][-1],1000), \\\r\n func(np.linspace(X[index][0],X[index][-1],1000), p[0],p[1],p[2]), \\\r\n 'r-', label = \"fit\")\r\n f.axes[0].errorbar(X, Y, yerr = sigma, fmt = 'bx', elinewidth = 1,\\\r\n ecolor = 'black', capsize = 2)\r\n f.axes[0].legend(loc = 'best')\r\n f.axes[0].grid()\r\n f.savefig(filename+\".svg\")","def fit_polynomial_regression(self, x_train, y_train):\n x_poly = self.poly_reg.fit_transform(x_train)\n self.lin_reg.fit(x_poly, y_train)","def slopemap(inr,insp,dims): \n slope,intercept = np.polyfit(inr,insp, 1)\n slopemap = slope.reshape(dims)\n\n return slopemap","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def fit_1d_solution_sigclip(p, loc):\n func_name = __NAME__ + '.fit_1d_solution_sigclip()'\n # read constants from p\n n_init = p['WAVE_N_ORD_START']\n n_fin = p['WAVE_N_ORD_FINAL']\n\n # set up storage arrays\n xpix = np.arange(loc['NBPIX'])\n wave_map_final = np.zeros((n_fin - n_init, loc['NBPIX']))\n poly_wave_sol_final = np.zeros((n_fin - n_init, p['IC_LL_DEGR_FIT'] + 1))\n\n # fit x v wavelength w/sigma-clipping\n # we remove modulo 1 pixel errors in line centers - 3 iterations\n n_ite_mod_x = 3\n for ite in range(n_ite_mod_x):\n # set up storage\n wsumres = 0.0\n wsumres2 = 0.0\n sweight = 0.0\n fp_x_final_clip = []\n fp_x_in_clip = []\n fp_ll_final_clip = []\n fp_ll_in_clip = []\n fp_ord_clip = []\n res_clip = []\n wei_clip = []\n scale = []\n res_modx = np.zeros_like(loc['FP_XX_NEW'])\n # loop over the orders\n for onum in range(n_fin - n_init):\n # order mask\n ord_mask = np.where(loc['FP_ORD_NEW'] == onum +\n n_init)\n # get FP line pixel positions for the order\n fp_x_ord = loc['FP_XX_NEW'][ord_mask]\n # get new FP line wavelengths for the order\n fp_ll_new_ord = np.asarray(loc['FP_LL_NEW'])[ord_mask]\n # get weights for the order\n wei_ord = np.asarray(loc['FP_WEI'])[ord_mask]\n # fit solution for the order w/sigma-clipping\n coeffs, mask = sigclip_polyfit(p, fp_x_ord, fp_ll_new_ord,\n p['IC_LL_DEGR_FIT'], wei_ord)\n # store the coefficients\n poly_wave_sol_final[onum] = coeffs[::-1]\n # get the residuals modulo x\n res_modx[ord_mask] = speed_of_light * (fp_ll_new_ord /\n np.polyval(coeffs,\n fp_x_ord) - 1)\n # mask input arrays for statistics\n fp_x_ord = fp_x_ord[mask]\n fp_ll_new_ord = fp_ll_new_ord[mask]\n wei_ord = wei_ord[mask]\n # get final wavelengths\n fp_ll_final_ord = np.polyval(coeffs, fp_x_ord)\n # save wave map\n wave_map_final[onum] = np.polyval(coeffs, xpix)\n # save masked arrays\n fp_x_final_clip.append(fp_x_ord)\n fp_x_in_clip.append(loc['FP_XX_INIT'][ord_mask][mask])\n fp_ll_final_clip.append(fp_ll_final_ord)\n fp_ll_in_clip.append(fp_ll_new_ord)\n fp_ord_clip.append(loc['FP_ORD_NEW'][ord_mask][mask])\n wei_clip.append(wei_ord)\n # residuals in km/s\n # calculate the residuals for the final masked arrays\n res = fp_ll_final_ord - fp_ll_new_ord\n res_clip.append(res * speed_of_light / fp_ll_new_ord)\n # save stats\n # get the derivative of the coefficients\n poly = np.poly1d(coeffs)\n dldx = np.polyder(poly)(fp_x_ord)\n # work out conversion factor\n convert = speed_of_light * dldx / fp_ll_final_ord\n scale.append(convert)\n # sum the weights (recursively)\n sweight += np.nansum(wei_clip[onum])\n # sum the weighted residuals in km/s\n wsumres += np.nansum(res_clip[onum] * wei_clip[onum])\n # sum the weighted squared residuals in km/s\n wsumres2 += np.nansum(wei_clip[onum] * res_clip[onum] ** 2)\n\n # we construct a sin/cos model of the error in line center position\n # and fit it to the residuals\n cos = np.cos(2 * np.pi * (loc['FP_XX_NEW'] % 1))\n sin = np.sin(2 * np.pi * (loc['FP_XX_NEW'] % 1))\n\n # find points that are not residual outliers\n # We fit a zeroth order polynomial, so it returns\n # outliers to the mean value.\n outl_fit, mask_all = sigclip_polyfit(p, loc['FP_XX_NEW'],\n res_modx, 0)\n # create model\n acos = np.nansum(cos[mask_all] * res_modx[mask_all]) / \\\n np.nansum(cos[mask_all] ** 2)\n asin = np.nansum(sin[mask_all] * res_modx[mask_all]) / \\\n np.nansum(sin[mask_all] ** 2)\n model_sin = (cos * acos + sin * asin)\n # update the xpeak positions with model\n loc['FP_XX_NEW'] += model_sin / 2.2\n\n # calculate the final var and mean\n total_lines = len(np.concatenate(fp_ll_in_clip))\n final_mean = wsumres / sweight\n final_var = (wsumres2 / sweight) - (final_mean ** 2)\n # log the global stats\n wmsg1 = 'On fiber {0} fit line statistic:'.format(p['FIBER'])\n wargs2 = [final_mean * 1000.0, np.sqrt(final_var) * 1000.0,\n total_lines, 1000.0 * np.sqrt(final_var / total_lines)]\n wmsg2 = ('\\tmean={0:.3f}[m/s] rms={1:.1f} {2} lines (error on mean '\n 'value:{3:.4f}[m/s])'.format(*wargs2))\n WLOG(p, 'info', [wmsg1, wmsg2])\n\n # save final (sig-clipped) arrays to loc\n loc['FP_ORD_CL'] = np.array(np.concatenate(fp_ord_clip).ravel())\n loc['FP_LLIN_CL'] = np.array(np.concatenate(fp_ll_in_clip).ravel())\n loc['FP_XIN_CL'] = np.array(np.concatenate(fp_x_in_clip).ravel())\n loc['FP_XOUT_CL'] = np.array(np.concatenate(fp_x_final_clip).ravel())\n loc['FP_WEI_CL'] = np.array(np.concatenate(wei_clip).ravel())\n loc['RES_CL'] = np.array(np.concatenate(res_clip).ravel())\n loc['LL_OUT_2'] = wave_map_final\n loc['LL_PARAM_2'] = poly_wave_sol_final\n loc['X_MEAN_2'] = final_mean\n loc['X_VAR_2'] = final_var\n loc['TOTAL_LINES_2'] = total_lines\n loc['SCALE_2'] = scale\n\n # set up x_details and ll_details structures for line list table:\n # X_DETAILS_i: list, [lines, xfit, cfit, weight] where\n # lines= original wavelength-centers used for the fit\n # xfit= original pixel-centers used for the fit\n # cfit= fitted pixel-centers using fit coefficients\n # weight=the line weights used\n # LL_DETAILS_i: numpy array (1D), the [nres, wei] where\n # nres = normalised residuals in km/s\n # wei = the line weights\n x_details = []\n ll_details = []\n for ord_num in range(n_init, n_fin):\n omask = loc['FP_ORD_CL'] == ord_num\n x_details.append([loc['FP_LLIN_CL'][omask], loc['FP_XIN_CL'][omask],\n loc['FP_XOUT_CL'][omask], loc['FP_WEI_CL'][omask]])\n ll_details.append([loc['RES_CL'][omask], loc['FP_WEI_CL'][omask]])\n loc['X_DETAILS_2'] = x_details\n loc['LL_DETAILS_2'] = ll_details\n\n # return\n return loc","def test_linear_fit_model_set_masked_values(self):\n # NB. For single models, there is an equivalent doctest.\n\n init_model = models.Polynomial1D(degree=1, n_models=2)\n x = np.arange(10)\n y = np.ma.masked_array([2 * x + 1, x - 2], mask=np.zeros_like([x, x]))\n\n y[0, 7] = 100.0 # throw off fit coefficients if unmasked\n y.mask[0, 7] = True\n y[1, 1:3] = -100.0\n y.mask[1, 1:3] = True\n\n fitter = LinearLSQFitter()\n fitted_model = fitter(init_model, x, y)\n\n assert_allclose(fitted_model.c0, [1.0, -2.0], atol=1e-14)\n assert_allclose(fitted_model.c1, [2.0, 1.0], atol=1e-14)","def fit():\n pass","def fit_data(x, y, flag_thr, deg=9):\n # Flag sorted data\n xf, yf = diff_xy(x, y, flag_thr)\n\n # Fit polynomial to flagged data\n p = np.polyfit(xf, yf, deg)\n p = np.poly1d(p)\n pg = p(x)\n\n return pg","def smoothing(data, mask):\n smooth_data = gaussian_filter(data, [2, 2, 2, 0])\n\n Y = smooth_data[mask].T\n\n return Y","def polyfit(x, y, yerror, pinit=[0,0,0,0]):\n x = np.array(x)\n y = np.array(y)\n pinit[2] = np.mean(y)\n pinit[3] = x[len(x)/2]\n if (type(yerror) != list and type(yerror) != np.ndarray):\n yerror = np.ones(len(x)) * yerror\n fitfunc = lambda p, x: p[2] + p[1]*(x-p[3]) + p[0]*(x-p[3])**2\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\n p = out[0]\n covar = out[1]\n return(p)","def poly_regression_cubic(X, Y, Xs_test, Ys_test):\n ## YOUR CODE HERE\n #################\n return 0","def linearfit(x,y):\n fit = np.polyfit(x,y,1)\n fit_fn = np.poly1d(fit)\n yy = fit_fn(x) \n \n return yy","def polyfitr(x, y, N, s, fev=100, w=None, diag=False, clip='both', \\\n verbose=False, plotfit=False, plotall=False, eps=1e-13, catchLinAlgError=False):\n # 2008-10-01 13:01 IJC: Created & completed\n # 2009-10-01 10:23 IJC: 1 year later! Moved \"import\" statements within func.\n # 2009-10-22 14:01 IJC: Added 'clip' options for continuum fitting\n # 2009-12-08 15:35 IJC: Automatically clip all non-finite points\n # 2010-10-29 09:09 IJC: Moved pylab imports inside this function\n # 2012-08-20 16:47 IJMC: Major change: now only reject one point per iteration!\n # 2012-08-27 10:44 IJMC: Verbose < 0 now resets to 0\n # 2013-05-21 23:15 IJMC: Added catchLinAlgError\n\n from CARSMath import polyfitw\n from numpy import polyfit, polyval, isfinite, ones\n from numpy.linalg import LinAlgError\n from pylab import plot, legend, title\n\n if verbose < 0:\n verbose = 0\n\n xx = array(x, copy=False)\n yy = array(y, copy=False)\n noweights = (w==None)\n if noweights:\n ww = ones(xx.shape, float)\n else:\n ww = array(w, copy=False)\n\n ii = 0\n nrej = 1\n\n if noweights:\n goodind = isfinite(xx)*isfinite(yy)\n else:\n goodind = isfinite(xx)*isfinite(yy)*isfinite(ww)\n \n xx2 = xx[goodind]\n yy2 = yy[goodind]\n ww2 = ww[goodind]\n\n while (ii<fev and (nrej<>0)):\n if noweights:\n p = polyfit(xx2,yy2,N)\n residual = yy2 - polyval(p,xx2)\n stdResidual = std(residual)\n clipmetric = s * stdResidual\n else:\n if catchLinAlgError:\n try:\n p = polyfitw(xx2,yy2, ww2, N)\n except LinAlgError:\n p = np.zeros(N+1, dtype=float)\n else:\n p = polyfitw(xx2,yy2, ww2, N)\n\n p = p[::-1] # polyfitw uses reverse coefficient ordering\n residual = (yy2 - polyval(p,xx2)) * np.sqrt(ww2)\n clipmetric = s\n\n if clip=='both':\n worstOffender = abs(residual).max()\n if worstOffender <= clipmetric or worstOffender < eps:\n ind = ones(residual.shape, dtype=bool)\n else:\n ind = abs(residual) <= worstOffender\n elif clip=='above':\n worstOffender = residual.max()\n if worstOffender <= clipmetric:\n ind = ones(residual.shape, dtype=bool)\n else:\n ind = residual < worstOffender\n elif clip=='below':\n worstOffender = residual.min()\n if worstOffender >= -clipmetric:\n ind = ones(residual.shape, dtype=bool)\n else:\n ind = residual > worstOffender\n else:\n ind = ones(residual.shape, dtype=bool)\n \n xx2 = xx2[ind]\n yy2 = yy2[ind]\n if (not noweights):\n ww2 = ww2[ind]\n ii = ii + 1\n nrej = len(residual) - len(xx2)\n if plotall:\n plot(x,y, '.', xx2,yy2, 'x', x, polyval(p, x), '--')\n legend(['data', 'fit data', 'fit'])\n title('Iter. #' + str(ii) + ' -- Close all windows to continue....')\n\n if verbose:\n print str(len(x)-len(xx2)) + ' points rejected on iteration #' + str(ii)\n\n if (plotfit or plotall):\n plot(x,y, '.', xx2,yy2, 'x', x, polyval(p, x), '--')\n legend(['data', 'fit data', 'fit'])\n title('Close window to continue....')\n\n if diag:\n chisq = ( (residual)**2 / yy2 ).sum()\n p = (p, chisq, ii)\n\n return p","def ApplyMask(data,mask):\n \n # loop through portions\n for portion in data.keys():\n # match data keys and apply mask \n for key in data[portion].keys():\n if key in 'xyerr':\n if mask != 'UnMasked':\n data[portion][key].mask = data[portion]['UnMasked']\n data[portion][key].mask = data[portion][mask]\n\t\n return data","def fit_circle_func():\n pass","def fit(x, a, p, b):\n return a * (p ** x) + b","def fit_linreg_robust(x, y, mask=None, intercept=False, r2=True, est_method=\"rlm\"):\n\n x = x.A if issparse(x) else x\n y = y.A if issparse(y) else y\n\n _mask = np.logical_and(~np.isnan(x), ~np.isnan(y))\n if mask is not None:\n _mask &= mask\n xx = x[_mask]\n yy = y[_mask]\n\n try:\n if est_method.lower() == \"rlm\":\n xx_ = sm.add_constant(xx) if intercept else xx\n res = sm.RLM(yy, xx_).fit()\n k, b = res.params[::-1] if intercept else (res.params[0], 0)\n elif est_method.lower() == \"ransac\":\n reg = RANSACRegressor(LinearRegression(fit_intercept=intercept), random_state=0)\n reg.fit(xx.reshape(-1, 1), yy.reshape(-1, 1))\n k, b = reg.estimator_.coef_[0, 0], (reg.estimator_.intercept_[0] if intercept else 0)\n else:\n raise ImportError(\n f\"estimation method {est_method} is not implemented. \"\n f\"Currently supported linear regression methods include `rlm` and `ransac`.\"\n )\n except:\n if intercept:\n ym = np.mean(yy)\n xm = np.mean(xx)\n\n cov = np.mean(xx * yy) - xm * ym\n var_x = np.mean(xx * xx) - xm * xm\n k = cov / var_x\n b = ym - k * xm\n # # assume b is always positive\n # if b < 0:\n # k, b = np.mean(xx * yy) / np.mean(xx * xx), 0\n else:\n # use uncentered cov and var_x\n cov = np.mean(xx * yy)\n var_x = np.mean(xx * xx)\n k = cov / var_x\n b = 0\n\n if r2:\n SS_tot_n, all_SS_tot_n = np.var(yy), np.var(y)\n SS_res_n, all_SS_res_n = (\n np.mean((yy - k * xx - b) ** 2),\n np.mean((y - k * x - b) ** 2),\n )\n r2, all_r2 = 1 - SS_res_n / SS_tot_n, 1 - all_SS_res_n / all_SS_tot_n\n\n return k, b, r2, all_r2\n else:\n return k, b","def fit_slope_with_zero_intercept_residue(X,Y):\n X = np.array(X)\n Y = np.array(Y)\n slope = np.sum(Y*X)/np.sum(np.power(X,2))\n return slope*X - Y","def fit_poly(img_shape, leftx, lefty, rightx, righty):\n left_fit = np.polyfit(lefty, leftx, deg=2)\n right_fit = np.polyfit(righty, rightx, deg=2)\n # Generate x and y values for plotting\n ploty = np.linspace(0, img_shape[0]-1, img_shape[0])\n ### TO-DO: Calc both polynomials using ploty, left_fit and right_fit ###\n left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]\n right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\n \n return left_fitx, right_fitx, ploty","def fit(self, X, Y):\n ...","def scatter_singlet_fit(self):\n return self._scatter_singlet_fit","def partial_fit(self, X, y=...):\n ...","def partial_fit(self, X, y=...):\n ...","def fit(self, x):\n pass","def _fit_poly(y_data, deg=5):\n x = np.arange(1, len(y_data) + 1)\n coeffs = np.polynomial.polynomial.polyfit(\n x, y_data, deg=deg)\n y_pred = poly(x, coeffs)\n return coeffs, np.mean((y_data - y_pred) ** 2)","def fit_polynomial(binary_warped, plot = False):\n image_shape = binary_warped.shape\n left_curverad = left_line.radius_of_curvature\n right_curverad = right_line.radius_of_curvature\n # Find our lane pixels first\n if (not left_line.detected and left_line.frames_not_detected > \\\n reset_search) or len(left_line.last_n_fits) == 0:\n leftx, lefty, rightx, righty = find_lane_pixels(binary_warped)\n else:\n leftx, lefty, rightx, righty = \\\n polyfit_using_prev(binary_warped, left_line.last_n_fits[-1], right_line.last_n_fits[-1])\n # leftx, lefty, rightx, righty = find_lane_pixels(binary_warped)\n \n # Generate x and y values for plotting\n ploty = np.linspace(0, image_shape[0]-1, image_shape[0])\n if len(lefty) !=0 and len(righty) != 0:\n left_fit = np.polyfit(lefty, leftx, 2)\n right_fit = np.polyfit(righty, rightx, 2)\n left_curverad, right_curverad = measure_curvature_real(left_fit, right_fit, image_shape[0]-1)\n left_line.radius_of_curvature = left_curverad\n right_line.radius_of_curvature = right_curverad\n \n left_fitx = eval_at_y(left_fit, ploty)\n right_fitx = eval_at_y(right_fit, ploty)\n if not sanity_check(left_fitx, right_fitx):\n left_line.detected = False\n right_line.detected = False\n else:\n left_line.detected = True\n right_line.detected = True\n else:\n left_fit =[]\n right_fit = []\n left_line.detected = False\n right_line.detected = False\n \n \n if not plot:\n left_fit = left_line.calculate_fit(left_fit)\n right_fit = right_line.calculate_fit(right_fit)\n \n \n offset = 0\n # calculate offset from center of lane\n if len(left_fit) != 0:\n left_fitx = eval_at_y(left_fit, ploty)\n right_fitx = eval_at_y(right_fit, ploty)\n\n left_bottom_x = left_fitx[-1]\n right_bottom_x = right_fitx[-1]\n # offset calculation\n lane_midpoint = (left_bottom_x + right_bottom_x)/2.0\n camera_midpoint = (image_shape[1]-1)/2.0\n offset = (camera_midpoint - lane_midpoint)*xm_per_pix\n \n if plot:\n ## Visualization ##\n # Colors in the left and right lane regions\n # Create an output image to draw on and visualize the result\n # Create an output image to draw on and visualize the result\n out_img = np.dstack((binary_warped, binary_warped, binary_warped))\n plt.figure(3)\n if not left_line.detected:\n print('Sanity check failed, displaying rejected lines')\n out_img[lefty, leftx] = [255, 0, 0]\n out_img[righty, rightx] = [0, 0, 255]\n\n # Plots the left and right polynomials on the lane lines\n plt.plot(left_fitx, ploty, color='yellow')\n plt.plot(right_fitx, ploty, color='yellow')\n # plt.xlim(0, image_shape[1])\n # plt.ylim(image_shape[0], 0)\n plt.imshow(out_img)\n plt.title(\"Lane lines identified\")\n return left_fitx, right_fitx, ploty, left_curverad, right_curverad, offset","def _forward_mask_point(self, features, mask_coarse_logits, instances):\n if not self.mask_point_on:\n return {} if self.training else mask_coarse_logits\n\n mask_features_list = [features[k] for k in self.mask_point_in_features]\n features_scales = [self._feature_scales[k] for k in self.mask_point_in_features]\n\n if self.training:\n proposal_boxes = [x.proposal_boxes for x in instances]\n gt_classes = cat([x.gt_classes for x in instances])\n with torch.no_grad():\n point_coords = get_uncertain_point_coords_with_randomness(\n mask_coarse_logits,\n lambda logits: calculate_uncertainty_ins_seg(logits, gt_classes),\n self.mask_point_train_num_points,\n self.mask_point_oversample_ratio,\n self.mask_point_importance_sample_ratio,\n )\n\n fine_grained_features, point_coords_wrt_image = point_sample_fine_grained_features(\n mask_features_list, features_scales, proposal_boxes, point_coords\n )\n coarse_features = point_sample(mask_coarse_logits, point_coords, align_corners=False)\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\n return {\n \"loss_mask_point\": roi_mask_point_loss(\n point_logits, instances, point_coords_wrt_image\n )\n }\n else:\n pred_boxes = [x.pred_boxes for x in instances]\n pred_classes = cat([x.pred_classes for x in instances])\n # The subdivision code will fail with the empty list of boxes\n if len(pred_classes) == 0:\n return mask_coarse_logits\n\n mask_logits = mask_coarse_logits.clone()\n for subdivions_step in range(self.mask_point_subdivision_steps):\n mask_logits = interpolate(\n mask_logits, scale_factor=2, mode=\"bilinear\", align_corners=False\n )\n # If `mask_point_subdivision_num_points` is larger or equal to the\n # resolution of the next step, then we can skip this step\n H, W = mask_logits.shape[-2:]\n if (\n self.mask_point_subdivision_num_points >= 4 * H * W\n and subdivions_step < self.mask_point_subdivision_steps - 1\n ):\n continue\n uncertainty_map = calculate_uncertainty_ins_seg(mask_logits, pred_classes)\n point_indices, point_coords = get_uncertain_point_coords_on_grid(\n uncertainty_map, self.mask_point_subdivision_num_points\n )\n fine_grained_features, _ = point_sample_fine_grained_features(\n mask_features_list, features_scales, pred_boxes, point_coords\n )\n coarse_features = point_sample(\n mask_coarse_logits, point_coords, align_corners=False\n )\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\n\n # put mask point predictions to the right places on the upsampled grid.\n R, C, H, W = mask_logits.shape\n point_indices = point_indices.unsqueeze(1).expand(-1, C, -1)\n mask_logits = (\n mask_logits.reshape(R, C, H * W)\n .scatter_(2, point_indices, point_logits)\n .view(R, C, H, W)\n )\n return mask_logits","def fit(self, X):","def fitting_residual(x: np.ndarray, y: np.ndarray, func, args, mask_min: float = None,\n standardized: bool = False) -> np.ndarray:\n y_predict = func(x, *args)\n res = np.subtract(y, y_predict)\n norm = np.std(res)\n if mask_min is not None:\n res[np.where(abs(res) < mask_min)] = 0\n if standardized and norm != 0:\n res /= norm\n return res","def reduce_y(y, mask):\n return y","def mask_and_fit(mask, binary_warped, flag):\n img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)\n x, y = extract_pixels(img)\n fit, foundFlag, confidence_index = check_and_fit(x, y, flag)\n return fit, foundFlag, confidence_index","def fit_transform(self, x: Array2D) -> Array2D:","def limited_search(img_, window_size, flag='L'):\n # Initialize Mask with Same Size as Image #\n mask_poly = np.zeros_like(img_)\n # Get previous Coefficients #\n fit = get_last_fit(flag=flag)\n if fit is not None:\n mask_poly_smooth = smoothen_masks(fit, img_, window_size)\n return mask_poly_smooth.astype(np.uint8)\n else:\n return mask_poly","def fit_poly(x, y, n=5, log=False):\n \n x_g = x\n x = np.ma.array(x, mask=y.mask).compressed()\n y = y.compressed()\n if log:\n yl = np.log10(y)\n else:\n yl = y\n fit = np.polyfit(x, yl, n)\n p = np.poly1d(fit)\n \n if log:\n return 10**(p(x_g))\n else:\n return p(x_g)","def _lowess_robustify_fit(x_copy, y_copy, fitted, weights, k, n):\n nn_indices = [0,k]\n X = np.ones((k,2))\n\n residual_weights = np.copy(y_copy)\n residual_weights.shape = (n,)\n residual_weights -= fitted\n residual_weights = np.absolute(residual_weights)#, out=residual_weights)\n s = np.median(residual_weights)\n residual_weights /= (6*s)\n too_big = residual_weights>=1\n _lowess_bisquare(residual_weights)\n residual_weights[too_big] = 0\n\n\n for i in range(n):\n total_weights = weights[i,:] * np.sqrt(residual_weights[nn_indices[0]:\n nn_indices[1]])\n\n X[:,1] = x_copy[nn_indices[0]:nn_indices[1]]\n y_i = total_weights * y_copy[nn_indices[0]:nn_indices[1]]\n total_weights.shape = (k,1)\n\n beta = lstsq(total_weights * X, y_i, rcond=-1)[0]\n\n fitted[i] = beta[0] + beta[1] * x_copy[i]\n\n _lowess_update_nn(x_copy, nn_indices, i+1)","def regression_fit(self, x, y, deg):\n return np.polyfit(x, y, deg=deg)","def apply_mask(self, m, mask):\n\n m[0] *= mask[0]\n if self.pol:\n m[1:] *= (mask[1] if self.pol_mask else mask[0])[None, :]\n\n return m","def polyfit(data, tvec, intfun):\n\n posx = intfun(tvec, data[:, 0])\n posz = intfun(tvec, data[:, 1])\n velx = posx.derivative(1)\n velz = posz.derivative(1)\n accx = posx.derivative(2)\n accz = posz.derivative(2)\n\n pos = np.c_[posx(tvec), posz(tvec)]\n vel = np.c_[velx(tvec), velz(tvec)]\n acc = np.c_[accx(tvec), accz(tvec)]\n\n return pos, vel, acc","def fit_slope_1d_residue(X,Y):\n X = np.array(X)\n Y = np.array(Y)\n slope, alpha = fit_slope_1d(X,Y)\n return slope*X + alpha - Y","def lsq_coefficients(x, y, fit_intercept=False):\n if fit_intercept:\n x = np.vstack([x, np.ones(len(x))]).T\n else:\n x = np.vstack([x, np.zeros(len(x))]).T\n return np.dot(np.dot(np.linalg.pinv(np.dot(x.T, x)), x.T), y)","def _sparsify_from_mask(X, mask):\n S = X.copy()\n S.data[mask] = 0.\n S.eliminate_zeros()\n return S","def line_fit(x,y):\n\t# clean\n\tx = np.squeeze(x)\n\ty = np.squeeze(y)\n\t# concatenate\n\txy = np.concatenate((x[:,np.newaxis],y[:,np.newaxis]),1)\n\t# sort by x values\n\txy = xy[xy[:,0].argsort()]\n\t#print(xy)\n\tf = lambda x,m,b : m*x+b\n\tpars,_ = opt.curve_fit(f,xy[:,0],xy[:,1])\n\tm = pars[0]\n\tb = pars[1]\n\tpts = np.zeros((2,2))\n\tpts[0,0] = xy[0,0]\n\tpts[1,0] = xy[-1,0]\n\tpts[:,1] = pts[:,0]*m+b\n\tsig = np.std((xy[:,1]-f(xy[:,0],m,b)))\n\treturn pts, sig","def linearfit_s1(x, y):\r\n x *= N.ones(1); y *= N.ones(1)\r\n mx = N.mean(x); my = N.mean(y)\r\n slope = 1.; yint = my-mx\r\n rl_slope, sd_slope, rl_yint, sd_yint, s_yint, cov = robust_linefit(x, y)\r\n \r\n return slope, sd_slope, yint, sd_yint, s_yint, cov","def fit(self, X,y):\n pass","def fit_transform(self, X, y=...):\n ...","def apply_mask(self):\n for mask, param in self.masked_parameters:\n param.mul_(mask)","def dmsp_map_interpolate_NN_smooth(X_dmsp, Y_dmsp, X_map, Y_map, Obs_map, k = 5, tol = 3):\n #reshape to N by 2 array where each row is (X, Y)\n dmsp_points = np.hstack((X_dmsp.flatten().reshape(-1,1),Y_dmsp.flatten().reshape(-1,1)))\n map_points = np.hstack((X_map.flatten().reshape(-1,1), Y_map.flatten().reshape(-1,1)))\n N_points = dmsp_points.shape[0]\n obs_val = Obs_map.flatten()\n model = sklearn.neighbors.BallTree(map_points,leaf_size = 40 )\n dists, inds = model.query(dmsp_points, k=k) \n\n obs_interp = np.empty(N_points)\n for i in range(N_points):\n norm = LA.norm(dists[i])\n if (norm > tol):\n obs_interp[i] = np.nan\n else:\n# weights = dists[i]/norm\n\n weights = dists[i]/np.nansum(dists[i])\n obs_interp[i] = np.nansum( obs_val[inds[i]] * weights )\n\n return obs_interp","def _smooth_profile(self, x, y, xbnds, usepts, nanrad):\n\n xz = np.hstack((x[:,np.newaxis],y[:,np.newaxis]))\n xz, xloc = self._gridloc(xz, xbnds, 0)\n\n dx = np.diff(xbnds)\n xnew = xbnds[:-1] + 0.5 * dx\n\n nanmask = np.array([np.sum(np.abs(xloc - ix+1) <= nanrad) == 0 \\\n for ix in range(len(xnew))])\n\n frac = usepts/xz.shape[0]\n\n with np.errstate(invalid='ignore'):\n try:\n w = sm.nonparametric.lowess(xz[:,1], xz[:,0], frac=frac,\n delta=np.nanmean(dx), it=0)\n znew = np.interp(xnew, w[:,0], w[:,1])\n except:\n znew = np.nan\n\n znew[nanmask] = np.nan\n return xnew, znew","def fit(self, x, y):\n for i in range(len(x)):\n for j in range(len(x[i])):\n\n # init probability\n if j == 0:\n self.init_probability[y[i][j]] += 1\n\n # transition probability\n else:\n self.transition[y[i][j], y[i][j - 1]] += 1\n\n # emission probability\n self.emission[x[i][j]][y[i][j]] += 1\n\n # laplace smoothing\n self.init_probability = (self.init_probability + 1) / np.sum(self.init_probability)\n self.transition = (self.transition + 1) / (np.sum(self.transition) + self.n_classes)\n self.emission = (self.emission + 1) / (np.sum(self.emission) + self.n_feature)","def _linear_wcs_fit(params, lon, lat, x, y, w_obj): # pragma: no cover\n cd = params[0:4]\n crpix = params[4:6]\n\n w_obj.wcs.cd = ((cd[0], cd[1]), (cd[2], cd[3]))\n w_obj.wcs.crpix = crpix\n lon2, lat2 = w_obj.wcs_pix2world(x, y, 0)\n\n resids = np.concatenate((lon-lon2, lat-lat2))\n resids[resids > 180] = 360 - resids[resids > 180]\n resids[resids < -180] = 360\t+ resids[resids < -180]\n\n return resids","def smooth(x, y, PLOT=False, **kwargs):\n assert len(x) == len(y)\n x = np.array(x)\n y = np.array(y)\n\n # do a grid search to find the optimal polynomial degree\n model = GridSearchCV(\n # use a linear model with polynomial features\n sklearn.pipeline.Pipeline([\n ('poly', sklearn.preprocessing.PolynomialFeatures(degree=3)),\n ('linear', sklearn.linear_model.LinearRegression())\n ]),\n cv=kwargs.get('cv', min(5, len(x))),\n param_grid={\n 'poly__degree': np.arange(\n kwargs.get('min_degree', 3),\n kwargs.get('max_degree', 14),\n 2\n )\n }\n )\n x = x.reshape(-1, 1)\n model.fit(x, y)\n\n def predict(_x):\n return model.predict(np.array(_x).reshape(-1, 1))\n\n if PLOT:\n yhat = predict(x)\n fig, ax = plt.subplots(1, 1)\n ax.plot(x, yhat, 'k--')\n ax.plot(x, y, 'ko')\n ax.set(xlabel='x', ylabel='y')\n sns.despine()\n return predict, fig, ax\n if kwargs.get('PRINT'):\n print(model)\n return predict","def LinearLeastSquaresFit(x,y):\n \n xavg = np.zeros(len(x),float) #<x> average\n xavg = sum(x)/len(x)\n \n yavg = np.zeros(len(y),float) #<y> average\n yavg = sum(y)/len(y)\n \n x2avg = np.zeros(len(x),float) #<x^2> average\n x2avg = sum(x**2)/len(x)\n \n xyavg = np.zeros(len(x),float) #<xy> average\n xyavg = sum(x*y)/len(x)\n \n m = (xyavg - xavg*yavg)/(x2avg-xavg**2) #slope\n b = (x2avg*yavg-xavg*xyavg)/(x2avg-xavg**2) #intercept\n \n d = np.zeros(len(x),float)\n for n in range(len(x)):\n d[n] = y[n] -(m*x[n]+b)\n \n x2 = np.zeros(len(x),float)\n for n in range(len(x)):\n x2[n] = sum(d[n]**2)\n \n \n d2avg = np.zeros(len(d),float) #<d^2> average\n d2avg = sum(x2)/float(len(x))\n \n Dm = sqrt((1/float(len(x)-2))*(d2avg/(x2avg-xavg**2))) #slope error\n Db = sqrt((1/float(len(x)-2))*((d2avg*x2avg)/(x2avg-xavg**2))) # intercept error\n print \"slope=\", m, \"Slope Error=\", Dm,\"Intercept=\", b, \"Intercept Error=\", Db\n return \"slope=\", m, \"Slope Error=\", Dm,\"Intercept=\", b, \"Intercept Error=\",Db","def fit(self, X, y, l2regularize = None ) :\n\n X = self.generate_polynomial_features(X) # map features\n\n ### ========== TODO : START ========== ###\n # part e: implement closed-form solution\n # hint: use np.dot(...) and np.linalg.pinv(...)\n # be sure to update self.coef_ with your solution\n X_X_T = np.linalg.pinv(np.dot(X.transpose(),X) + l2regularize*np.identity(np.shape(X.transpose())[0]))\n self.coef_ = np.dot(X_X_T,np.dot(X.transpose(),y))\n\n\n ### ========== TODO : END ========== ###\n\n return self","def polyLS(pd, x, y, f, X, Y \\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\n \n numP = int((pd + 1) * (pd + 2) / 2)\n \n if (len(xmc) == 1) and (len(ymc) == 1) :\n \n\n if coeff == [] :\n p = poly(x, y, pd)\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\n\n B = poly(X, Y, pd)\n approx = B.dot(coeff).flatten()\n coeff_copy = coeff\n \n else :\n \n approx = np.zeros(len(X), float)\n \n if coeff == [] :\n for i in range(len(xmc)) :\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\n if len(IND) < int(1.5 * numP) :\n raise ValueError(\"Not enough data for this polynomial \" \\\n + \"degree.\\nEither lower the polynomial degree or \" \\\n + \"decrease the number of subdivisions.\")\n p = poly(x[IND], y[IND], pd)\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\n coeff.append(lam)\n\n coeff_copy = coeff.copy()\n\n for i in range(len(xmc) - 1, -1, -1) :\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\n B = poly(X[IND], Y[IND], pd)\n lam = coeff.pop()\n approx[IND] = B.dot(lam).flatten()\n \n return approx, coeff_copy","def fitLine(x, y, n_chans, deg=1):\n x_fine = np.linspace(x[0], x[-1], n_chans)\n x = x[len(x)/4:3*len(x)/4]\n y = y[len(y)/4:3*len(y)/4]\n p = np.polyfit(x[::-1], y, deg) # poly fit\n v = np.polyval(p, x_fine)\n return v","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def test_partial_fit(self, pipeline):\n pipeline.fit(X, Y)\n pipeline.partial_fit(X, Y)","def fit_curve(x,y,p0,func):\n ifixx = np.zeros(np.array(x).shape)\n data = sodr.Data(x,y)\n model = sodr.Model(func)\n worker = sodr.ODR(data,model,p0,ifixx=ifixx,maxit=500)\n out = worker.run()\n out = worker.restart()\n return out","def test_fit(self):\n X,Y,Z = self.generate_data()\n\n p={'k':-1,'r':0}\n key = (p['r'],p['k'])\n\n task = mmSCHPOLY()\n fit_result = task.fit(X,Y,Z)\n\n self.assertEqual(fit_result.best_poly_df[key].shape[0]==4,True)\n\n task2 = mmSCH2W()\n fit_result = task2.fit(X,Y,Z)\n\n self.assertEqual(fit_result.best_inter_df[key].shape[0]==6,True)","def roi_mask_point_loss(mask_logits, instances, points_coord):\n with torch.no_grad():\n cls_agnostic_mask = mask_logits.size(1) == 1\n total_num_masks = mask_logits.size(0)\n\n gt_classes = []\n gt_mask_logits = []\n idx = 0\n for instances_per_image in instances:\n if len(instances_per_image) == 0:\n continue\n assert isinstance(\n instances_per_image.gt_masks, BitMasks\n ), \"Point head works with GT in 'bitmask' format. Set INPUT.MASK_FORMAT to 'bitmask'.\"\n\n if not cls_agnostic_mask:\n gt_classes_per_image = instances_per_image.gt_classes.to(dtype=torch.int64)\n gt_classes.append(gt_classes_per_image)\n\n gt_bit_masks = instances_per_image.gt_masks.tensor\n h, w = instances_per_image.gt_masks.image_size\n scale = torch.tensor([w, h], dtype=torch.float, device=gt_bit_masks.device)\n points_coord_grid_sample_format = (\n points_coord[idx: idx + len(instances_per_image)] / scale\n )\n idx += len(instances_per_image)\n gt_mask_logits.append(\n point_sample(\n gt_bit_masks.to(torch.float32).unsqueeze(1),\n points_coord_grid_sample_format,\n align_corners=False,\n ).squeeze(1)\n )\n\n if len(gt_mask_logits) == 0:\n return mask_logits.sum() * 0\n\n gt_mask_logits = cat(gt_mask_logits)\n assert gt_mask_logits.numel() > 0, gt_mask_logits.shape\n\n if cls_agnostic_mask:\n mask_logits = mask_logits[:, 0]\n else:\n indices = torch.arange(total_num_masks)\n gt_classes = cat(gt_classes, dim=0)\n mask_logits = mask_logits[indices, gt_classes]\n\n # Log the training accuracy (using gt classes and 0.0 threshold for the logits)\n mask_accurate = (mask_logits > 0.0) == gt_mask_logits.to(dtype=torch.uint8)\n mask_accuracy = mask_accurate.nonzero(as_tuple=False).size(0) / mask_accurate.numel()\n get_event_storage().put_scalar(\"point_rend/accuracy\", mask_accuracy)\n\n point_loss = F.binary_cross_entropy_with_logits(\n mask_logits, gt_mask_logits.to(dtype=torch.float32), reduction=\"mean\"\n )\n return point_loss","def fitfunc_SC(x, *p):\n val = p[0]\n for n in range(0, len(p) - 1, 2):\n ind = n + 1\n mode = (n / 2) + 1\n val = (\n val\n + p[ind] * np.sin(2 * np.pi * mode * (x) / 360.0)\n + p[ind + 1] * np.cos(2 * np.pi * mode * (x) / 360.0)\n )\n return val","def check_and_fit(x, y, flag='L', threshold=1000):\n \n confidence_index = len(x)\n if IsLaneFound is False:\n threshold =500\n if confidence_index < threshold:\n fit = None\n foundFlag = False\n else:\n fit, cov = curve_fit(lambda x, a, b, c:a*x*x+b*x + c , x, y)\n foundFlag = True\n return fit, foundFlag, confidence_index","def _polyfit_coeffs(self, spec, specerr, scatter, labelA):\n deno = specerr ** 2. + scatter ** 2.\n Y = spec / deno\n ATY = tf.tensordot(tf.transpose(labelA), Y, axes=[[1], [0]])\n C = tf.expand_dims(1. / deno, 0)\n CiA = labelA * tf.transpose(tf.tile(C, [tf.shape(labelA)[1], 1]))\n ATCiA = tf.tensordot(tf.transpose(labelA), CiA, axes=[[1], [0]])\n ATCiAinv = tf.linalg.inv(ATCiA)\n return tf.tensordot(ATCiAinv, ATY, axes=[[1], [0]])","def rls_fit0(xdata: np.ndarray,\n ydata: np.ndarray | ma.MaskedArray) -> tuple:\n if xdata.size < 2:\n raise RuntimeError('too few points for a fit')\n if xdata.size != ydata.shape[-1]:\n raise RuntimeError('number of samples not equal for xdata, ydata')\n\n # perform all computations on 2 dimensional arrays\n img_shape = ydata.shape[:-1]\n yy1 = ydata.reshape(-1, xdata.size)\n\n # calculate weights\n if ma.isMaskedArray(ydata):\n wghts = calc_ma_weights(xdata, ma.getmaskarray(yy1))\n else:\n buff = np.concatenate(([2 * (xdata[1] - xdata[0])],\n xdata[2:] - xdata[0:-2],\n [2 * (xdata[-1] - xdata[-2])]))\n wghts = np.repeat([buff], yy1.shape[0], axis=0)\n wx1 = wghts / xdata\n wx2 = wghts / xdata ** 2\n\n # calculate the Q elements\n q00 = wghts.sum(axis=1)\n q11 = (wx1 * yy1).sum(axis=1)\n q22 = (wx2 * yy1 ** 2).sum(axis=1)\n\n # calculate fit parameter and its variance\n num = yy1.count(axis=1) if ma.isMaskedArray(ydata) else len(xdata)\n cc1 = q11 / q00\n if ma.isMaskedArray(ydata):\n cc1[num < 1] = ma.masked\n chi2 = ma.abs(q22 - q00 * cc1 ** 2) / np.clip(num - 1, 1, None)\n chi2[num <= 1] = ma.masked\n sc1 = ma.sqrt(chi2 / q00)\n return (cc1.reshape(img_shape).filled(np.nan),\n sc1.reshape(img_shape).filled(np.nan))\n\n # using only non-MaskedArray functions\n cc1[num < 1] = np.nan\n chi2 = np.abs(q22 - q00 * cc1 ** 2) / np.clip(num - 1, 1, None)\n chi2[num <= 1] = np.nan\n sc1 = np.sqrt(chi2 / q00)\n return cc1.reshape(img_shape), sc1.reshape(img_shape)","def fit_polynomial(self, ym_per_pix, xm_per_pix):\r\n\r\n # Fit a second order polynomial\r\n self.current_fit = np.polyfit(self.ally, self.allx, 2)\r\n\r\n # Fit a second order polynomial (in meters)\r\n current_fit_real = np.polyfit(self.ally * ym_per_pix, self.allx * xm_per_pix, 2)\r\n\r\n # calculate the curvature (in meters)\r\n self.radius_of_curvature = ((1 + (2 * current_fit_real[0] * self.y_eval * ym_per_pix + current_fit_real[1])**2)**1.5) / np.absolute(2 * current_fit_real[0])\r\n\r\n # flag that a polynomial is found\r\n self.detected = True","def get_mask(self, shape):\n h, w = shape[0:2]\n y, x = np.mgrid[:h, :w]\n points = np.transpose((x.ravel(), y.ravel()))\n\n mask = _nxutils_points_inside_poly(points, self.verts)\n #mask = nxutils.points_inside_poly(points, self.verts)\n return mask.reshape(h, w)","def fit_line_int(model,scaling,intercept):\n\treturn scaling*model + intercept","def test_fit() -> None:\n mapie = MapieRegressor()\n mapie.fit(X_toy, y_toy)","def partial_fit(self, X, y, sample_weight=...):\n ...","def apply_pafmap_mask(self, img_keypoints, input_shape, pafmap_joints, thickness=8):\n paf_masks = [np.zeros((self.input_shape[0], self.input_shape[1], 1), dtype=np.float32)\n for _ in range(len(pafmap_joints) * 2)]\n n_pafs = [0 for _ in range(len(pafmap_joints))]\n\n for kp in img_keypoints:\n for i, (kp0, kp1) in enumerate(pafmap_joints):\n x1 = int(np.round(kp[kp0 * 3] / input_shape[1] * self.input_shape[1]))\n y1 = int(np.round(kp[kp0 * 3 + 1] / input_shape[0] * self.input_shape[0]))\n x2 = int(np.round(kp[kp1 * 3] / input_shape[1] * self.input_shape[1]))\n y2 = int(np.round(kp[kp1 * 3 + 1] / input_shape[0] * self.input_shape[0]))\n\n if kp[kp0 * 3 + 2] != 0 and kp[kp1 * 3 + 2] != 0 and (x2 - x1 != 0 or y2 - y1 != 0):\n tmp_paf_x = np.zeros((self.input_shape[0], self.input_shape[1], 1), dtype=np.float32)\n tmp_paf_y = np.zeros((self.input_shape[0], self.input_shape[1], 1), dtype=np.float32)\n\n cv2.line(tmp_paf_x, (x1, y1), (x2, y2), 1, thickness)\n cv2.line(tmp_paf_y, (x1, y1), (x2, y2), 1, thickness)\n\n x_val = (x2 - x1) / np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)\n y_val = (y2 - y1) / np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)\n\n tmp_paf_x = tmp_paf_x * x_val\n tmp_paf_y = tmp_paf_y * y_val\n\n paf_masks[i * 2][tmp_paf_x != 0] = tmp_paf_x[tmp_paf_x != 0]\n paf_masks[i * 2 + 1][tmp_paf_y != 0] = tmp_paf_y[tmp_paf_y != 0]\n\n n_pafs[i] += 1\n\n paf_masks = np.array(paf_masks)\n\n return np.squeeze(paf_masks).transpose((1, 2, 0)), np.array(n_pafs)","def flatspectrum(xarr, yarr, mode='mean', thresh=3, iter=5, order=3):\n if mode == 'mean':\n # subtract off the mean value\n sarr = yarr - clipstats(yarr, thresh, iter)[0]\n elif mode == 'poly':\n # calculate the statistics and mask all of the mask with values above\n # these\n it = iterfit(xarr, yarr, function='poly', order=order)\n it.iterfit()\n sarr = yarr - it(xarr)\n elif mode == 'mask':\n # mask the values\n mean, std = clipstats(yarr, thresh, iter)\n mask = (yarr < mean + thresh * std)\n sarr = yarr.copy()\n sarr[mask] = 0\n else:\n sarr = yarr.copy()\n return sarr","def polyfit_2d(Xu,X):\n\txu = Xu[:,0]\n\tyu = Xu[:,1]\n\tX = np.squeeze(X) # an mx1 vector\n\tM = np.squeeze((np.ones(xu.size),xu,yu,xu**2,xu*yu,yu**2,\n\t\txu**3,xu**2*yu,xu*yu**2,yu**3)) # a mxn matrix\n\tM = M.transpose()\n\tprint(\"solving for the polynomial fitting coefficients...\")\n\tK,resid,rnk,svs = np.linalg.lstsq(M,X,rcond=-1) # k has size n\n\tprint(\"residue:%0.8f\trank:%0.8f\"%(np.sum(resid),rnk))\n\treturn K","def fit(self, x):\n raise NotImplementedError()","def linearfit(x, y, runs=1e4):\r\n x *= N.ones(1); y *= N.ones(1)\r\n slope, yint, r, prob2, see = stats.linregress(x, y)\r\n scale = N.mean(y) - N.mean(x)\r\n nsig = Smad(N.log10(10**y/(10**x*10**scale)))\r\n bs_slope = N.zeros(runs); bs_yint = N.zeros(runs)\r\n for i in range(bs_slope.size):\r\n bsrun = bs.bootstrap_resample(N.arange(x.size))\r\n bsuse = N.where((10**y[bsrun]/(10**x[bsrun]*10**scale)>=10**(-1.*nsig)) & (10**y[bsrun]/(10**x[bsrun]*10**scale)<=10.**nsig))\r\n bs_slope[i], bs_yint[i] = stats.linregress(x[bsuse], y[bsuse])[:2]\r\n sd_slope = bs_slope.std(); sd_yint = N.sqrt(sd_slope**2/bs_yint.size*N.sum(bs_yint**2))\r\n \r\n return slope, sd_slope, yint, sd_yint","def fit(self, x):\n x = np.asarray(x)\n _ = self.fit_transform(x)","def fit(self, X, y=None):\n #import pdb\n #pdb.set_trace()\n return self.partial_fit(X, y)","def inner_fit(self):\n pass","def inner_fit(self):\n pass","def poisson_blend(source, mask, target, mix = False, strength = 1):\n mask_points = np.argwhere(mask)\n mask_points = list(map(tuple, mask_points))\n\n print(np.shape(mask_points))\n \n # Build Sparse\n A, b = build_arrays(source, mask, target, mask_points, mix, strength)\n A = A.tocsr()\n\n #regular solve to be clipped later\n r = linalg.cg(A, b[:,0])[0]\n g = linalg.cg(A, b[:,1])[0]\n b = linalg.cg(A, b[:,2])[0]\n \n # go through the mask points and assign the new intensity\n for i,index in enumerate(mask_points):\n target[index][0] = np.clip(r[i], 0.0, 1.0)\n target[index][1] = np.clip(g[i], 0.0, 1.0)\n target[index][2] = np.clip(b[i], 0.0, 1.0)\n\n return target","def direct_mask_loss(\n self, pos_idx, idx_t, loc_data, mask_data, priors, masks\n ):\n loss_m = 0\n for idx in range(mask_data.size(0)):\n with torch.no_grad():\n cur_pos_idx = pos_idx[idx, :, :]\n cur_pos_idx_squeezed = cur_pos_idx[:, 1]\n\n # Shape: [num_priors, 4], decoded predicted bboxes\n pos_bboxes = decode(\n loc_data[idx, :, :], priors.data, cfg.use_yolo_regressors\n )\n pos_bboxes = pos_bboxes[cur_pos_idx].view(-1, 4).clamp(0, 1)\n pos_lookup = idx_t[idx, cur_pos_idx_squeezed]\n\n cur_masks = masks[idx]\n pos_masks = cur_masks[pos_lookup, :, :]\n\n # Convert bboxes to absolute coordinates\n num_pos, img_height, img_width = pos_masks.size()\n\n x1, x2 = sanitize_coordinates(\n pos_bboxes[:, 0], pos_bboxes[:, 2], img_width\n )\n y1, y2 = sanitize_coordinates(\n pos_bboxes[:, 1], pos_bboxes[:, 3], img_height\n )\n\n scaled_masks = []\n for jdx in range(num_pos):\n tmp_mask = pos_masks[\n jdx, y1[jdx]: y2[jdx], x1[jdx]: x2[jdx]\n ]\n\n while tmp_mask.dim() < 2:\n tmp_mask = tmp_mask.unsqueeze(0)\n\n new_mask = F.adaptive_avg_pool2d(\n tmp_mask.unsqueeze(0), cfg.mask_size\n )\n scaled_masks.append(new_mask.view(1, -1))\n\n mask_t = (\n torch.cat(scaled_masks, 0).gt(0.5).float()\n ) # Threshold downsampled mask\n\n pos_mask_data = mask_data[idx, cur_pos_idx_squeezed, :]\n loss_m += (\n F.binary_cross_entropy(\n torch.clamp(pos_mask_data, 0, 1), mask_t, reduction=\"sum\"\n )\n * cfg.mask_alpha\n )\n\n return loss_m","def coefficients_to_slip(x, y, a):\n partials = np.zeros((x.size, 3))\n partials[:, 0] = (x / a) * (9 * (x / a) / 8 - 3 / 4)\n partials[:, 1] = (1 - 3 * (x / a) / 2) * (1 + 3 * (x / a) / 2)\n partials[:, 2] = (x / a) * (9 * (x / a) / 8 + 3 / 4)\n slip = partials @ y\n return slip","def smooth(y, box_pts):\r\n box = np.ones(box_pts)/box_pts\r\n y_smooth = np.convolve(y, box, mode='same')\r\n return y_smooth","def linear_slope_fit(wf, mean_y, sigma_y, slope, intercept):\n\n sum_x = sum_x2 = sum_xy = sum_y = mean_y[0] = sigma_y[0] = 0\n isum = len(wf)\n\n for i,value in enumerate(wf):\n sum_x += i \n sum_x2 += i**2\n sum_xy += (value * i)\n sum_y += value\n mean_y += (value-mean_y) / (i+1)\n sigma_y += (value-mean_y)**2\n\n\n sigma_y /= (isum + 1)\n np.sqrt(sigma_y, sigma_y)\n\n\n slope[0] = (isum * sum_xy - sum_x * sum_y) / (isum * sum_x2 - sum_x * sum_x)\n intercept[0] = (sum_y - sum_x * slope[0])/isum"],"string":"[\n \"def sigclip_polyfit(p, xx, yy, degree, weight = None):\\n # read constants from p\\n sigclip = p['WAVE_SIGCLIP']\\n # initialise the while loop\\n sigmax = sigclip + 1\\n # initialise mask\\n mask = np.ones_like(xx, dtype='Bool')\\n while sigmax > sigclip:\\n # Need to mask weight here if not None\\n if weight is not None:\\n weight2 = weight[mask]\\n else:\\n weight2 = None\\n # fit on masked values\\n coeff = nanpolyfit(xx[mask], yy[mask], deg=degree, w=weight2)\\n # get residuals (not masked or dimension breaks)\\n res = yy - np.polyval(coeff, xx)\\n # normalise the residuals\\n res = np.abs(res / np.nanmedian(np.abs(res[mask])))\\n # get the max residual in sigmas\\n sigmax = np.max(res[mask])\\n # mask all outliers\\n if sigmax > sigclip:\\n mask[res >= sigclip] = False\\n # return the coefficients and mask\\n return coeff, mask\",\n \"def fit_clip(x, y, clip=0.4, index_fit = 2, kernel = 19, mask =\\\"\\\", \\n xmin=\\\"\\\",xmax=\\\"\\\",ymin=\\\"\\\",ymax=\\\"\\\",percentile_min=2, percentile_max=98,\\n ptitle=None, xlabel=None, ylabel = None, label=\\\"\\\", \\n hlines=[], vlines=[],chlines=[], cvlines=[], axvspan=[[0,0]], hwidth =1, vwidth =1,\\n plot=True, verbose=True):\\n \\n # Preparing the data. Trim edges and remove nans\\n \\n \\n \\n \\n if kernel != 0:\\n x = np.array(x)\\n y = np.array(y)\\n \\n y_smooth = signal.medfilt(y, kernel)\\n residuals = y - y_smooth\\n residuals_std = np.std(residuals)\\n \\n y_nan = [np.nan if np.abs(i) > residuals_std*clip else 1. for i in residuals ] \\n y_clipped = y * y_nan\\n \\n idx = np.isfinite(x) & np.isfinite(y_clipped)\\n \\n fit = np.polyfit(x[idx], y_clipped[idx], index_fit) \\n pp=np.poly1d(fit)\\n y_fit=pp(x)\\n y_fit_clipped =pp(x[idx])\\n \\n if verbose: \\n print(\\\"\\\\n> Fitting a polynomium of degree\\\",index_fit,\\\"using clip =\\\",clip,\\\"* std ...\\\")\\n print(\\\" Eliminated\\\",len(x)-len(x[idx]),\\\"outliers, the solution is: \\\",fit)\\n \\n if plot:\\n if ylabel is None: ylabel = \\\"y (x)\\\"\\n \\n if ptitle is None:\\n ptitle = \\\"Polyfit of degree \\\"+np.str(index_fit)+\\\" using clip = \\\"+np.str(clip)+\\\" * std\\\"\\n plot_plot(x, [y,y_smooth, y_clipped, y_fit], psym=[\\\"+\\\",\\\"-\\\", \\\"+\\\",\\\"-\\\"],\\n alpha=[0.5,0.5,0.8,1], color=[\\\"r\\\",\\\"b\\\",\\\"g\\\",\\\"k\\\"], label=label,\\n xlabel=xlabel, ylabel=ylabel, ptitle=ptitle, \\n xmin=xmin,xmax=xmax,ymin=ymin,ymax=ymax,percentile_min=percentile_min, percentile_max=percentile_max,\\n hlines=hlines, vlines=vlines,chlines=chlines, cvlines=cvlines, \\n axvspan=axvspan, hwidth =hwidth, vwidth =vwidth)\\n\\n return fit, pp, y_fit, y_fit_clipped, x[idx], y_clipped[idx] \\n else:\\n fit = np.polyfit(x, y, index_fit) \\n pp=np.poly1d(fit)\\n y_fit=pp(x)\\n return fit, pp, y_fit, y_fit, x, y\",\n \"def poly_scale(self,p,ind=5,groupby=None):\\n\\n time = self.data.index.values[:ind]\\n\\n if groupby is None:\\n #group = {(None,self.meta.index)}\\n for i in range(self.data.shape[1]):\\n temp = self.data.iloc[:,i]\\n od = temp.values[:ind]\\n\\n coeff = np.polyfit(time,od,p)\\n\\n temp = temp - np.polyval(coeff,self.data.index.values[0])\\n self.data.iloc[:,i] = temp\\n else:\\n group = self.meta.groupby(groupby)\\n for k,index in group.groups.items():\\n temp = self.data.loc[:,index]\\n od = temp.values[:ind,:].ravel()\\n\\n coeff = np.polyfit(time.tolist()*temp.shape[1],od,p)\\n\\n temp = temp - np.polyval(coeff,self.data.index.values[0])\\n self.data.loc[:,index] = temp\",\n \"def linear_regression(self, x_data, y_data, mask = None, ax = None):\\n if mask is None:\\n mask = full(len(y_data), True, dtype=bool)\\n poly = poly1d(polyfit(x_data[mask], y_data[mask], 1))\\n\\n if ax is not None:\\n ax.plot(x_data, polyval(poly, x_data), \\\"--r\\\",\\\\\\n label = \\\"Slope: %.2f\\\" %(poly[1]))\\n return poly\",\n \"def poly2mask(self):\\n self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)\\n self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)\\n img = Image.new(\\\"L\\\", (self.x_gridnum, self.y_gridnum), 0)\\n\\n self.perimeter = 0.0\\n for ii in self.polygons:\\n pp = np.array(ii) * self.CD # polygon\\n polygonlen = len(pp)\\n self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))\\n pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize\\n pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize\\n vetex_list = list(pp)\\n polygon = [tuple(y) for y in vetex_list]\\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\\n\\n self.data = np.array(img)\\n self.data = np.float64(self.data)\\n\\n self.spat_part = pyfftw.empty_aligned(\\n (self.y_gridnum, self.x_gridnum), dtype=\\\"complex128\\\"\\n )\\n self.freq_part = pyfftw.empty_aligned(\\n (self.y_gridnum, self.x_gridnum), dtype=\\\"complex128\\\"\\n )\\n self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))\",\n \"def test_linear_fit_2d_model_set_masked_values(self):\\n init_model = models.Polynomial2D(1, n_models=2)\\n x, y = np.mgrid[0:5, 0:5]\\n z = np.ma.masked_array(\\n [2 * x + 3 * y + 1, x - 0.5 * y - 2], mask=np.zeros_like([x, x])\\n )\\n\\n z[0, 3, 1] = -1000.0 # throw off fit coefficients if unmasked\\n z.mask[0, 3, 1] = True\\n\\n fitter = LinearLSQFitter()\\n fitted_model = fitter(init_model, x, y, z)\\n\\n assert_allclose(fitted_model.c0_0, [1.0, -2.0], atol=1e-14)\\n assert_allclose(fitted_model.c1_0, [2.0, 1.0], atol=1e-14)\\n assert_allclose(fitted_model.c0_1, [3.0, -0.5], atol=1e-14)\",\n \"def fitdata(X, Y, func, mask, p0 = None, filename = \\\"fit\\\", sigma = None,\\\\\\r\\n xlabel = None, ylabel = None, scatter = False):\\r\\n \\r\\n #gather indices that are within the masking region \\r\\n index = (X>mask[0]) & (X<mask[1])\\r\\n \\r\\n #get parameters of the fitting of the function using scipy\\r\\n (p, er) = optimize.curve_fit(func, X[index], Y[index], p0 = p0,\\\\\\r\\n sigma = sigma)\\r\\n \\r\\n #print out the parameter values and the errors\\r\\n print(\\\"###################\\\")\\r\\n print(p)\\r\\n print(np.sqrt(np.diag(er)))\\r\\n print(\\\"###################\\\")\\r\\n \\r\\n #create scatter plot if required\\r\\n if scatter:\\r\\n f = plt.figure()\\r\\n ax1 = f.add_subplot(111)\\r\\n ax1.scatter(X, Y, linewidth = 1, label = \\\"data\\\", marker = 'x')\\r\\n ax1.set_xlabel(xlabel)\\r\\n ax1.set_ylabel(ylabel)\\r\\n else:\\r\\n f = makeplot(X, [Y], [\\\"data\\\"], xlabel, ylabel, plainlines = True)\\r\\n f.axes[0].plot(np.linspace(X[index][0],X[index][-1],1000), \\\\\\r\\n func(np.linspace(X[index][0],X[index][-1],1000), p[0],p[1],p[2]), \\\\\\r\\n 'r-', label = \\\"fit\\\")\\r\\n f.axes[0].errorbar(X, Y, yerr = sigma, fmt = 'bx', elinewidth = 1,\\\\\\r\\n ecolor = 'black', capsize = 2)\\r\\n f.axes[0].legend(loc = 'best')\\r\\n f.axes[0].grid()\\r\\n f.savefig(filename+\\\".svg\\\")\",\n \"def fit_polynomial_regression(self, x_train, y_train):\\n x_poly = self.poly_reg.fit_transform(x_train)\\n self.lin_reg.fit(x_poly, y_train)\",\n \"def slopemap(inr,insp,dims): \\n slope,intercept = np.polyfit(inr,insp, 1)\\n slopemap = slope.reshape(dims)\\n\\n return slopemap\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit_1d_solution_sigclip(p, loc):\\n func_name = __NAME__ + '.fit_1d_solution_sigclip()'\\n # read constants from p\\n n_init = p['WAVE_N_ORD_START']\\n n_fin = p['WAVE_N_ORD_FINAL']\\n\\n # set up storage arrays\\n xpix = np.arange(loc['NBPIX'])\\n wave_map_final = np.zeros((n_fin - n_init, loc['NBPIX']))\\n poly_wave_sol_final = np.zeros((n_fin - n_init, p['IC_LL_DEGR_FIT'] + 1))\\n\\n # fit x v wavelength w/sigma-clipping\\n # we remove modulo 1 pixel errors in line centers - 3 iterations\\n n_ite_mod_x = 3\\n for ite in range(n_ite_mod_x):\\n # set up storage\\n wsumres = 0.0\\n wsumres2 = 0.0\\n sweight = 0.0\\n fp_x_final_clip = []\\n fp_x_in_clip = []\\n fp_ll_final_clip = []\\n fp_ll_in_clip = []\\n fp_ord_clip = []\\n res_clip = []\\n wei_clip = []\\n scale = []\\n res_modx = np.zeros_like(loc['FP_XX_NEW'])\\n # loop over the orders\\n for onum in range(n_fin - n_init):\\n # order mask\\n ord_mask = np.where(loc['FP_ORD_NEW'] == onum +\\n n_init)\\n # get FP line pixel positions for the order\\n fp_x_ord = loc['FP_XX_NEW'][ord_mask]\\n # get new FP line wavelengths for the order\\n fp_ll_new_ord = np.asarray(loc['FP_LL_NEW'])[ord_mask]\\n # get weights for the order\\n wei_ord = np.asarray(loc['FP_WEI'])[ord_mask]\\n # fit solution for the order w/sigma-clipping\\n coeffs, mask = sigclip_polyfit(p, fp_x_ord, fp_ll_new_ord,\\n p['IC_LL_DEGR_FIT'], wei_ord)\\n # store the coefficients\\n poly_wave_sol_final[onum] = coeffs[::-1]\\n # get the residuals modulo x\\n res_modx[ord_mask] = speed_of_light * (fp_ll_new_ord /\\n np.polyval(coeffs,\\n fp_x_ord) - 1)\\n # mask input arrays for statistics\\n fp_x_ord = fp_x_ord[mask]\\n fp_ll_new_ord = fp_ll_new_ord[mask]\\n wei_ord = wei_ord[mask]\\n # get final wavelengths\\n fp_ll_final_ord = np.polyval(coeffs, fp_x_ord)\\n # save wave map\\n wave_map_final[onum] = np.polyval(coeffs, xpix)\\n # save masked arrays\\n fp_x_final_clip.append(fp_x_ord)\\n fp_x_in_clip.append(loc['FP_XX_INIT'][ord_mask][mask])\\n fp_ll_final_clip.append(fp_ll_final_ord)\\n fp_ll_in_clip.append(fp_ll_new_ord)\\n fp_ord_clip.append(loc['FP_ORD_NEW'][ord_mask][mask])\\n wei_clip.append(wei_ord)\\n # residuals in km/s\\n # calculate the residuals for the final masked arrays\\n res = fp_ll_final_ord - fp_ll_new_ord\\n res_clip.append(res * speed_of_light / fp_ll_new_ord)\\n # save stats\\n # get the derivative of the coefficients\\n poly = np.poly1d(coeffs)\\n dldx = np.polyder(poly)(fp_x_ord)\\n # work out conversion factor\\n convert = speed_of_light * dldx / fp_ll_final_ord\\n scale.append(convert)\\n # sum the weights (recursively)\\n sweight += np.nansum(wei_clip[onum])\\n # sum the weighted residuals in km/s\\n wsumres += np.nansum(res_clip[onum] * wei_clip[onum])\\n # sum the weighted squared residuals in km/s\\n wsumres2 += np.nansum(wei_clip[onum] * res_clip[onum] ** 2)\\n\\n # we construct a sin/cos model of the error in line center position\\n # and fit it to the residuals\\n cos = np.cos(2 * np.pi * (loc['FP_XX_NEW'] % 1))\\n sin = np.sin(2 * np.pi * (loc['FP_XX_NEW'] % 1))\\n\\n # find points that are not residual outliers\\n # We fit a zeroth order polynomial, so it returns\\n # outliers to the mean value.\\n outl_fit, mask_all = sigclip_polyfit(p, loc['FP_XX_NEW'],\\n res_modx, 0)\\n # create model\\n acos = np.nansum(cos[mask_all] * res_modx[mask_all]) / \\\\\\n np.nansum(cos[mask_all] ** 2)\\n asin = np.nansum(sin[mask_all] * res_modx[mask_all]) / \\\\\\n np.nansum(sin[mask_all] ** 2)\\n model_sin = (cos * acos + sin * asin)\\n # update the xpeak positions with model\\n loc['FP_XX_NEW'] += model_sin / 2.2\\n\\n # calculate the final var and mean\\n total_lines = len(np.concatenate(fp_ll_in_clip))\\n final_mean = wsumres / sweight\\n final_var = (wsumres2 / sweight) - (final_mean ** 2)\\n # log the global stats\\n wmsg1 = 'On fiber {0} fit line statistic:'.format(p['FIBER'])\\n wargs2 = [final_mean * 1000.0, np.sqrt(final_var) * 1000.0,\\n total_lines, 1000.0 * np.sqrt(final_var / total_lines)]\\n wmsg2 = ('\\\\tmean={0:.3f}[m/s] rms={1:.1f} {2} lines (error on mean '\\n 'value:{3:.4f}[m/s])'.format(*wargs2))\\n WLOG(p, 'info', [wmsg1, wmsg2])\\n\\n # save final (sig-clipped) arrays to loc\\n loc['FP_ORD_CL'] = np.array(np.concatenate(fp_ord_clip).ravel())\\n loc['FP_LLIN_CL'] = np.array(np.concatenate(fp_ll_in_clip).ravel())\\n loc['FP_XIN_CL'] = np.array(np.concatenate(fp_x_in_clip).ravel())\\n loc['FP_XOUT_CL'] = np.array(np.concatenate(fp_x_final_clip).ravel())\\n loc['FP_WEI_CL'] = np.array(np.concatenate(wei_clip).ravel())\\n loc['RES_CL'] = np.array(np.concatenate(res_clip).ravel())\\n loc['LL_OUT_2'] = wave_map_final\\n loc['LL_PARAM_2'] = poly_wave_sol_final\\n loc['X_MEAN_2'] = final_mean\\n loc['X_VAR_2'] = final_var\\n loc['TOTAL_LINES_2'] = total_lines\\n loc['SCALE_2'] = scale\\n\\n # set up x_details and ll_details structures for line list table:\\n # X_DETAILS_i: list, [lines, xfit, cfit, weight] where\\n # lines= original wavelength-centers used for the fit\\n # xfit= original pixel-centers used for the fit\\n # cfit= fitted pixel-centers using fit coefficients\\n # weight=the line weights used\\n # LL_DETAILS_i: numpy array (1D), the [nres, wei] where\\n # nres = normalised residuals in km/s\\n # wei = the line weights\\n x_details = []\\n ll_details = []\\n for ord_num in range(n_init, n_fin):\\n omask = loc['FP_ORD_CL'] == ord_num\\n x_details.append([loc['FP_LLIN_CL'][omask], loc['FP_XIN_CL'][omask],\\n loc['FP_XOUT_CL'][omask], loc['FP_WEI_CL'][omask]])\\n ll_details.append([loc['RES_CL'][omask], loc['FP_WEI_CL'][omask]])\\n loc['X_DETAILS_2'] = x_details\\n loc['LL_DETAILS_2'] = ll_details\\n\\n # return\\n return loc\",\n \"def test_linear_fit_model_set_masked_values(self):\\n # NB. For single models, there is an equivalent doctest.\\n\\n init_model = models.Polynomial1D(degree=1, n_models=2)\\n x = np.arange(10)\\n y = np.ma.masked_array([2 * x + 1, x - 2], mask=np.zeros_like([x, x]))\\n\\n y[0, 7] = 100.0 # throw off fit coefficients if unmasked\\n y.mask[0, 7] = True\\n y[1, 1:3] = -100.0\\n y.mask[1, 1:3] = True\\n\\n fitter = LinearLSQFitter()\\n fitted_model = fitter(init_model, x, y)\\n\\n assert_allclose(fitted_model.c0, [1.0, -2.0], atol=1e-14)\\n assert_allclose(fitted_model.c1, [2.0, 1.0], atol=1e-14)\",\n \"def fit():\\n pass\",\n \"def fit_data(x, y, flag_thr, deg=9):\\n # Flag sorted data\\n xf, yf = diff_xy(x, y, flag_thr)\\n\\n # Fit polynomial to flagged data\\n p = np.polyfit(xf, yf, deg)\\n p = np.poly1d(p)\\n pg = p(x)\\n\\n return pg\",\n \"def smoothing(data, mask):\\n smooth_data = gaussian_filter(data, [2, 2, 2, 0])\\n\\n Y = smooth_data[mask].T\\n\\n return Y\",\n \"def polyfit(x, y, yerror, pinit=[0,0,0,0]):\\n x = np.array(x)\\n y = np.array(y)\\n pinit[2] = np.mean(y)\\n pinit[3] = x[len(x)/2]\\n if (type(yerror) != list and type(yerror) != np.ndarray):\\n yerror = np.ones(len(x)) * yerror\\n fitfunc = lambda p, x: p[2] + p[1]*(x-p[3]) + p[0]*(x-p[3])**2\\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\\n p = out[0]\\n covar = out[1]\\n return(p)\",\n \"def poly_regression_cubic(X, Y, Xs_test, Ys_test):\\n ## YOUR CODE HERE\\n #################\\n return 0\",\n \"def linearfit(x,y):\\n fit = np.polyfit(x,y,1)\\n fit_fn = np.poly1d(fit)\\n yy = fit_fn(x) \\n \\n return yy\",\n \"def polyfitr(x, y, N, s, fev=100, w=None, diag=False, clip='both', \\\\\\n verbose=False, plotfit=False, plotall=False, eps=1e-13, catchLinAlgError=False):\\n # 2008-10-01 13:01 IJC: Created & completed\\n # 2009-10-01 10:23 IJC: 1 year later! Moved \\\"import\\\" statements within func.\\n # 2009-10-22 14:01 IJC: Added 'clip' options for continuum fitting\\n # 2009-12-08 15:35 IJC: Automatically clip all non-finite points\\n # 2010-10-29 09:09 IJC: Moved pylab imports inside this function\\n # 2012-08-20 16:47 IJMC: Major change: now only reject one point per iteration!\\n # 2012-08-27 10:44 IJMC: Verbose < 0 now resets to 0\\n # 2013-05-21 23:15 IJMC: Added catchLinAlgError\\n\\n from CARSMath import polyfitw\\n from numpy import polyfit, polyval, isfinite, ones\\n from numpy.linalg import LinAlgError\\n from pylab import plot, legend, title\\n\\n if verbose < 0:\\n verbose = 0\\n\\n xx = array(x, copy=False)\\n yy = array(y, copy=False)\\n noweights = (w==None)\\n if noweights:\\n ww = ones(xx.shape, float)\\n else:\\n ww = array(w, copy=False)\\n\\n ii = 0\\n nrej = 1\\n\\n if noweights:\\n goodind = isfinite(xx)*isfinite(yy)\\n else:\\n goodind = isfinite(xx)*isfinite(yy)*isfinite(ww)\\n \\n xx2 = xx[goodind]\\n yy2 = yy[goodind]\\n ww2 = ww[goodind]\\n\\n while (ii<fev and (nrej<>0)):\\n if noweights:\\n p = polyfit(xx2,yy2,N)\\n residual = yy2 - polyval(p,xx2)\\n stdResidual = std(residual)\\n clipmetric = s * stdResidual\\n else:\\n if catchLinAlgError:\\n try:\\n p = polyfitw(xx2,yy2, ww2, N)\\n except LinAlgError:\\n p = np.zeros(N+1, dtype=float)\\n else:\\n p = polyfitw(xx2,yy2, ww2, N)\\n\\n p = p[::-1] # polyfitw uses reverse coefficient ordering\\n residual = (yy2 - polyval(p,xx2)) * np.sqrt(ww2)\\n clipmetric = s\\n\\n if clip=='both':\\n worstOffender = abs(residual).max()\\n if worstOffender <= clipmetric or worstOffender < eps:\\n ind = ones(residual.shape, dtype=bool)\\n else:\\n ind = abs(residual) <= worstOffender\\n elif clip=='above':\\n worstOffender = residual.max()\\n if worstOffender <= clipmetric:\\n ind = ones(residual.shape, dtype=bool)\\n else:\\n ind = residual < worstOffender\\n elif clip=='below':\\n worstOffender = residual.min()\\n if worstOffender >= -clipmetric:\\n ind = ones(residual.shape, dtype=bool)\\n else:\\n ind = residual > worstOffender\\n else:\\n ind = ones(residual.shape, dtype=bool)\\n \\n xx2 = xx2[ind]\\n yy2 = yy2[ind]\\n if (not noweights):\\n ww2 = ww2[ind]\\n ii = ii + 1\\n nrej = len(residual) - len(xx2)\\n if plotall:\\n plot(x,y, '.', xx2,yy2, 'x', x, polyval(p, x), '--')\\n legend(['data', 'fit data', 'fit'])\\n title('Iter. #' + str(ii) + ' -- Close all windows to continue....')\\n\\n if verbose:\\n print str(len(x)-len(xx2)) + ' points rejected on iteration #' + str(ii)\\n\\n if (plotfit or plotall):\\n plot(x,y, '.', xx2,yy2, 'x', x, polyval(p, x), '--')\\n legend(['data', 'fit data', 'fit'])\\n title('Close window to continue....')\\n\\n if diag:\\n chisq = ( (residual)**2 / yy2 ).sum()\\n p = (p, chisq, ii)\\n\\n return p\",\n \"def ApplyMask(data,mask):\\n \\n # loop through portions\\n for portion in data.keys():\\n # match data keys and apply mask \\n for key in data[portion].keys():\\n if key in 'xyerr':\\n if mask != 'UnMasked':\\n data[portion][key].mask = data[portion]['UnMasked']\\n data[portion][key].mask = data[portion][mask]\\n\\t\\n return data\",\n \"def fit_circle_func():\\n pass\",\n \"def fit(x, a, p, b):\\n return a * (p ** x) + b\",\n \"def fit_linreg_robust(x, y, mask=None, intercept=False, r2=True, est_method=\\\"rlm\\\"):\\n\\n x = x.A if issparse(x) else x\\n y = y.A if issparse(y) else y\\n\\n _mask = np.logical_and(~np.isnan(x), ~np.isnan(y))\\n if mask is not None:\\n _mask &= mask\\n xx = x[_mask]\\n yy = y[_mask]\\n\\n try:\\n if est_method.lower() == \\\"rlm\\\":\\n xx_ = sm.add_constant(xx) if intercept else xx\\n res = sm.RLM(yy, xx_).fit()\\n k, b = res.params[::-1] if intercept else (res.params[0], 0)\\n elif est_method.lower() == \\\"ransac\\\":\\n reg = RANSACRegressor(LinearRegression(fit_intercept=intercept), random_state=0)\\n reg.fit(xx.reshape(-1, 1), yy.reshape(-1, 1))\\n k, b = reg.estimator_.coef_[0, 0], (reg.estimator_.intercept_[0] if intercept else 0)\\n else:\\n raise ImportError(\\n f\\\"estimation method {est_method} is not implemented. \\\"\\n f\\\"Currently supported linear regression methods include `rlm` and `ransac`.\\\"\\n )\\n except:\\n if intercept:\\n ym = np.mean(yy)\\n xm = np.mean(xx)\\n\\n cov = np.mean(xx * yy) - xm * ym\\n var_x = np.mean(xx * xx) - xm * xm\\n k = cov / var_x\\n b = ym - k * xm\\n # # assume b is always positive\\n # if b < 0:\\n # k, b = np.mean(xx * yy) / np.mean(xx * xx), 0\\n else:\\n # use uncentered cov and var_x\\n cov = np.mean(xx * yy)\\n var_x = np.mean(xx * xx)\\n k = cov / var_x\\n b = 0\\n\\n if r2:\\n SS_tot_n, all_SS_tot_n = np.var(yy), np.var(y)\\n SS_res_n, all_SS_res_n = (\\n np.mean((yy - k * xx - b) ** 2),\\n np.mean((y - k * x - b) ** 2),\\n )\\n r2, all_r2 = 1 - SS_res_n / SS_tot_n, 1 - all_SS_res_n / all_SS_tot_n\\n\\n return k, b, r2, all_r2\\n else:\\n return k, b\",\n \"def fit_slope_with_zero_intercept_residue(X,Y):\\n X = np.array(X)\\n Y = np.array(Y)\\n slope = np.sum(Y*X)/np.sum(np.power(X,2))\\n return slope*X - Y\",\n \"def fit_poly(img_shape, leftx, lefty, rightx, righty):\\n left_fit = np.polyfit(lefty, leftx, deg=2)\\n right_fit = np.polyfit(righty, rightx, deg=2)\\n # Generate x and y values for plotting\\n ploty = np.linspace(0, img_shape[0]-1, img_shape[0])\\n ### TO-DO: Calc both polynomials using ploty, left_fit and right_fit ###\\n left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]\\n right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\\n \\n return left_fitx, right_fitx, ploty\",\n \"def fit(self, X, Y):\\n ...\",\n \"def scatter_singlet_fit(self):\\n return self._scatter_singlet_fit\",\n \"def partial_fit(self, X, y=...):\\n ...\",\n \"def partial_fit(self, X, y=...):\\n ...\",\n \"def fit(self, x):\\n pass\",\n \"def _fit_poly(y_data, deg=5):\\n x = np.arange(1, len(y_data) + 1)\\n coeffs = np.polynomial.polynomial.polyfit(\\n x, y_data, deg=deg)\\n y_pred = poly(x, coeffs)\\n return coeffs, np.mean((y_data - y_pred) ** 2)\",\n \"def fit_polynomial(binary_warped, plot = False):\\n image_shape = binary_warped.shape\\n left_curverad = left_line.radius_of_curvature\\n right_curverad = right_line.radius_of_curvature\\n # Find our lane pixels first\\n if (not left_line.detected and left_line.frames_not_detected > \\\\\\n reset_search) or len(left_line.last_n_fits) == 0:\\n leftx, lefty, rightx, righty = find_lane_pixels(binary_warped)\\n else:\\n leftx, lefty, rightx, righty = \\\\\\n polyfit_using_prev(binary_warped, left_line.last_n_fits[-1], right_line.last_n_fits[-1])\\n # leftx, lefty, rightx, righty = find_lane_pixels(binary_warped)\\n \\n # Generate x and y values for plotting\\n ploty = np.linspace(0, image_shape[0]-1, image_shape[0])\\n if len(lefty) !=0 and len(righty) != 0:\\n left_fit = np.polyfit(lefty, leftx, 2)\\n right_fit = np.polyfit(righty, rightx, 2)\\n left_curverad, right_curverad = measure_curvature_real(left_fit, right_fit, image_shape[0]-1)\\n left_line.radius_of_curvature = left_curverad\\n right_line.radius_of_curvature = right_curverad\\n \\n left_fitx = eval_at_y(left_fit, ploty)\\n right_fitx = eval_at_y(right_fit, ploty)\\n if not sanity_check(left_fitx, right_fitx):\\n left_line.detected = False\\n right_line.detected = False\\n else:\\n left_line.detected = True\\n right_line.detected = True\\n else:\\n left_fit =[]\\n right_fit = []\\n left_line.detected = False\\n right_line.detected = False\\n \\n \\n if not plot:\\n left_fit = left_line.calculate_fit(left_fit)\\n right_fit = right_line.calculate_fit(right_fit)\\n \\n \\n offset = 0\\n # calculate offset from center of lane\\n if len(left_fit) != 0:\\n left_fitx = eval_at_y(left_fit, ploty)\\n right_fitx = eval_at_y(right_fit, ploty)\\n\\n left_bottom_x = left_fitx[-1]\\n right_bottom_x = right_fitx[-1]\\n # offset calculation\\n lane_midpoint = (left_bottom_x + right_bottom_x)/2.0\\n camera_midpoint = (image_shape[1]-1)/2.0\\n offset = (camera_midpoint - lane_midpoint)*xm_per_pix\\n \\n if plot:\\n ## Visualization ##\\n # Colors in the left and right lane regions\\n # Create an output image to draw on and visualize the result\\n # Create an output image to draw on and visualize the result\\n out_img = np.dstack((binary_warped, binary_warped, binary_warped))\\n plt.figure(3)\\n if not left_line.detected:\\n print('Sanity check failed, displaying rejected lines')\\n out_img[lefty, leftx] = [255, 0, 0]\\n out_img[righty, rightx] = [0, 0, 255]\\n\\n # Plots the left and right polynomials on the lane lines\\n plt.plot(left_fitx, ploty, color='yellow')\\n plt.plot(right_fitx, ploty, color='yellow')\\n # plt.xlim(0, image_shape[1])\\n # plt.ylim(image_shape[0], 0)\\n plt.imshow(out_img)\\n plt.title(\\\"Lane lines identified\\\")\\n return left_fitx, right_fitx, ploty, left_curverad, right_curverad, offset\",\n \"def _forward_mask_point(self, features, mask_coarse_logits, instances):\\n if not self.mask_point_on:\\n return {} if self.training else mask_coarse_logits\\n\\n mask_features_list = [features[k] for k in self.mask_point_in_features]\\n features_scales = [self._feature_scales[k] for k in self.mask_point_in_features]\\n\\n if self.training:\\n proposal_boxes = [x.proposal_boxes for x in instances]\\n gt_classes = cat([x.gt_classes for x in instances])\\n with torch.no_grad():\\n point_coords = get_uncertain_point_coords_with_randomness(\\n mask_coarse_logits,\\n lambda logits: calculate_uncertainty_ins_seg(logits, gt_classes),\\n self.mask_point_train_num_points,\\n self.mask_point_oversample_ratio,\\n self.mask_point_importance_sample_ratio,\\n )\\n\\n fine_grained_features, point_coords_wrt_image = point_sample_fine_grained_features(\\n mask_features_list, features_scales, proposal_boxes, point_coords\\n )\\n coarse_features = point_sample(mask_coarse_logits, point_coords, align_corners=False)\\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\\n return {\\n \\\"loss_mask_point\\\": roi_mask_point_loss(\\n point_logits, instances, point_coords_wrt_image\\n )\\n }\\n else:\\n pred_boxes = [x.pred_boxes for x in instances]\\n pred_classes = cat([x.pred_classes for x in instances])\\n # The subdivision code will fail with the empty list of boxes\\n if len(pred_classes) == 0:\\n return mask_coarse_logits\\n\\n mask_logits = mask_coarse_logits.clone()\\n for subdivions_step in range(self.mask_point_subdivision_steps):\\n mask_logits = interpolate(\\n mask_logits, scale_factor=2, mode=\\\"bilinear\\\", align_corners=False\\n )\\n # If `mask_point_subdivision_num_points` is larger or equal to the\\n # resolution of the next step, then we can skip this step\\n H, W = mask_logits.shape[-2:]\\n if (\\n self.mask_point_subdivision_num_points >= 4 * H * W\\n and subdivions_step < self.mask_point_subdivision_steps - 1\\n ):\\n continue\\n uncertainty_map = calculate_uncertainty_ins_seg(mask_logits, pred_classes)\\n point_indices, point_coords = get_uncertain_point_coords_on_grid(\\n uncertainty_map, self.mask_point_subdivision_num_points\\n )\\n fine_grained_features, _ = point_sample_fine_grained_features(\\n mask_features_list, features_scales, pred_boxes, point_coords\\n )\\n coarse_features = point_sample(\\n mask_coarse_logits, point_coords, align_corners=False\\n )\\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\\n\\n # put mask point predictions to the right places on the upsampled grid.\\n R, C, H, W = mask_logits.shape\\n point_indices = point_indices.unsqueeze(1).expand(-1, C, -1)\\n mask_logits = (\\n mask_logits.reshape(R, C, H * W)\\n .scatter_(2, point_indices, point_logits)\\n .view(R, C, H, W)\\n )\\n return mask_logits\",\n \"def fit(self, X):\",\n \"def fitting_residual(x: np.ndarray, y: np.ndarray, func, args, mask_min: float = None,\\n standardized: bool = False) -> np.ndarray:\\n y_predict = func(x, *args)\\n res = np.subtract(y, y_predict)\\n norm = np.std(res)\\n if mask_min is not None:\\n res[np.where(abs(res) < mask_min)] = 0\\n if standardized and norm != 0:\\n res /= norm\\n return res\",\n \"def reduce_y(y, mask):\\n return y\",\n \"def mask_and_fit(mask, binary_warped, flag):\\n img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)\\n x, y = extract_pixels(img)\\n fit, foundFlag, confidence_index = check_and_fit(x, y, flag)\\n return fit, foundFlag, confidence_index\",\n \"def fit_transform(self, x: Array2D) -> Array2D:\",\n \"def limited_search(img_, window_size, flag='L'):\\n # Initialize Mask with Same Size as Image #\\n mask_poly = np.zeros_like(img_)\\n # Get previous Coefficients #\\n fit = get_last_fit(flag=flag)\\n if fit is not None:\\n mask_poly_smooth = smoothen_masks(fit, img_, window_size)\\n return mask_poly_smooth.astype(np.uint8)\\n else:\\n return mask_poly\",\n \"def fit_poly(x, y, n=5, log=False):\\n \\n x_g = x\\n x = np.ma.array(x, mask=y.mask).compressed()\\n y = y.compressed()\\n if log:\\n yl = np.log10(y)\\n else:\\n yl = y\\n fit = np.polyfit(x, yl, n)\\n p = np.poly1d(fit)\\n \\n if log:\\n return 10**(p(x_g))\\n else:\\n return p(x_g)\",\n \"def _lowess_robustify_fit(x_copy, y_copy, fitted, weights, k, n):\\n nn_indices = [0,k]\\n X = np.ones((k,2))\\n\\n residual_weights = np.copy(y_copy)\\n residual_weights.shape = (n,)\\n residual_weights -= fitted\\n residual_weights = np.absolute(residual_weights)#, out=residual_weights)\\n s = np.median(residual_weights)\\n residual_weights /= (6*s)\\n too_big = residual_weights>=1\\n _lowess_bisquare(residual_weights)\\n residual_weights[too_big] = 0\\n\\n\\n for i in range(n):\\n total_weights = weights[i,:] * np.sqrt(residual_weights[nn_indices[0]:\\n nn_indices[1]])\\n\\n X[:,1] = x_copy[nn_indices[0]:nn_indices[1]]\\n y_i = total_weights * y_copy[nn_indices[0]:nn_indices[1]]\\n total_weights.shape = (k,1)\\n\\n beta = lstsq(total_weights * X, y_i, rcond=-1)[0]\\n\\n fitted[i] = beta[0] + beta[1] * x_copy[i]\\n\\n _lowess_update_nn(x_copy, nn_indices, i+1)\",\n \"def regression_fit(self, x, y, deg):\\n return np.polyfit(x, y, deg=deg)\",\n \"def apply_mask(self, m, mask):\\n\\n m[0] *= mask[0]\\n if self.pol:\\n m[1:] *= (mask[1] if self.pol_mask else mask[0])[None, :]\\n\\n return m\",\n \"def polyfit(data, tvec, intfun):\\n\\n posx = intfun(tvec, data[:, 0])\\n posz = intfun(tvec, data[:, 1])\\n velx = posx.derivative(1)\\n velz = posz.derivative(1)\\n accx = posx.derivative(2)\\n accz = posz.derivative(2)\\n\\n pos = np.c_[posx(tvec), posz(tvec)]\\n vel = np.c_[velx(tvec), velz(tvec)]\\n acc = np.c_[accx(tvec), accz(tvec)]\\n\\n return pos, vel, acc\",\n \"def fit_slope_1d_residue(X,Y):\\n X = np.array(X)\\n Y = np.array(Y)\\n slope, alpha = fit_slope_1d(X,Y)\\n return slope*X + alpha - Y\",\n \"def lsq_coefficients(x, y, fit_intercept=False):\\n if fit_intercept:\\n x = np.vstack([x, np.ones(len(x))]).T\\n else:\\n x = np.vstack([x, np.zeros(len(x))]).T\\n return np.dot(np.dot(np.linalg.pinv(np.dot(x.T, x)), x.T), y)\",\n \"def _sparsify_from_mask(X, mask):\\n S = X.copy()\\n S.data[mask] = 0.\\n S.eliminate_zeros()\\n return S\",\n \"def line_fit(x,y):\\n\\t# clean\\n\\tx = np.squeeze(x)\\n\\ty = np.squeeze(y)\\n\\t# concatenate\\n\\txy = np.concatenate((x[:,np.newaxis],y[:,np.newaxis]),1)\\n\\t# sort by x values\\n\\txy = xy[xy[:,0].argsort()]\\n\\t#print(xy)\\n\\tf = lambda x,m,b : m*x+b\\n\\tpars,_ = opt.curve_fit(f,xy[:,0],xy[:,1])\\n\\tm = pars[0]\\n\\tb = pars[1]\\n\\tpts = np.zeros((2,2))\\n\\tpts[0,0] = xy[0,0]\\n\\tpts[1,0] = xy[-1,0]\\n\\tpts[:,1] = pts[:,0]*m+b\\n\\tsig = np.std((xy[:,1]-f(xy[:,0],m,b)))\\n\\treturn pts, sig\",\n \"def linearfit_s1(x, y):\\r\\n x *= N.ones(1); y *= N.ones(1)\\r\\n mx = N.mean(x); my = N.mean(y)\\r\\n slope = 1.; yint = my-mx\\r\\n rl_slope, sd_slope, rl_yint, sd_yint, s_yint, cov = robust_linefit(x, y)\\r\\n \\r\\n return slope, sd_slope, yint, sd_yint, s_yint, cov\",\n \"def fit(self, X,y):\\n pass\",\n \"def fit_transform(self, X, y=...):\\n ...\",\n \"def apply_mask(self):\\n for mask, param in self.masked_parameters:\\n param.mul_(mask)\",\n \"def dmsp_map_interpolate_NN_smooth(X_dmsp, Y_dmsp, X_map, Y_map, Obs_map, k = 5, tol = 3):\\n #reshape to N by 2 array where each row is (X, Y)\\n dmsp_points = np.hstack((X_dmsp.flatten().reshape(-1,1),Y_dmsp.flatten().reshape(-1,1)))\\n map_points = np.hstack((X_map.flatten().reshape(-1,1), Y_map.flatten().reshape(-1,1)))\\n N_points = dmsp_points.shape[0]\\n obs_val = Obs_map.flatten()\\n model = sklearn.neighbors.BallTree(map_points,leaf_size = 40 )\\n dists, inds = model.query(dmsp_points, k=k) \\n\\n obs_interp = np.empty(N_points)\\n for i in range(N_points):\\n norm = LA.norm(dists[i])\\n if (norm > tol):\\n obs_interp[i] = np.nan\\n else:\\n# weights = dists[i]/norm\\n\\n weights = dists[i]/np.nansum(dists[i])\\n obs_interp[i] = np.nansum( obs_val[inds[i]] * weights )\\n\\n return obs_interp\",\n \"def _smooth_profile(self, x, y, xbnds, usepts, nanrad):\\n\\n xz = np.hstack((x[:,np.newaxis],y[:,np.newaxis]))\\n xz, xloc = self._gridloc(xz, xbnds, 0)\\n\\n dx = np.diff(xbnds)\\n xnew = xbnds[:-1] + 0.5 * dx\\n\\n nanmask = np.array([np.sum(np.abs(xloc - ix+1) <= nanrad) == 0 \\\\\\n for ix in range(len(xnew))])\\n\\n frac = usepts/xz.shape[0]\\n\\n with np.errstate(invalid='ignore'):\\n try:\\n w = sm.nonparametric.lowess(xz[:,1], xz[:,0], frac=frac,\\n delta=np.nanmean(dx), it=0)\\n znew = np.interp(xnew, w[:,0], w[:,1])\\n except:\\n znew = np.nan\\n\\n znew[nanmask] = np.nan\\n return xnew, znew\",\n \"def fit(self, x, y):\\n for i in range(len(x)):\\n for j in range(len(x[i])):\\n\\n # init probability\\n if j == 0:\\n self.init_probability[y[i][j]] += 1\\n\\n # transition probability\\n else:\\n self.transition[y[i][j], y[i][j - 1]] += 1\\n\\n # emission probability\\n self.emission[x[i][j]][y[i][j]] += 1\\n\\n # laplace smoothing\\n self.init_probability = (self.init_probability + 1) / np.sum(self.init_probability)\\n self.transition = (self.transition + 1) / (np.sum(self.transition) + self.n_classes)\\n self.emission = (self.emission + 1) / (np.sum(self.emission) + self.n_feature)\",\n \"def _linear_wcs_fit(params, lon, lat, x, y, w_obj): # pragma: no cover\\n cd = params[0:4]\\n crpix = params[4:6]\\n\\n w_obj.wcs.cd = ((cd[0], cd[1]), (cd[2], cd[3]))\\n w_obj.wcs.crpix = crpix\\n lon2, lat2 = w_obj.wcs_pix2world(x, y, 0)\\n\\n resids = np.concatenate((lon-lon2, lat-lat2))\\n resids[resids > 180] = 360 - resids[resids > 180]\\n resids[resids < -180] = 360\\t+ resids[resids < -180]\\n\\n return resids\",\n \"def smooth(x, y, PLOT=False, **kwargs):\\n assert len(x) == len(y)\\n x = np.array(x)\\n y = np.array(y)\\n\\n # do a grid search to find the optimal polynomial degree\\n model = GridSearchCV(\\n # use a linear model with polynomial features\\n sklearn.pipeline.Pipeline([\\n ('poly', sklearn.preprocessing.PolynomialFeatures(degree=3)),\\n ('linear', sklearn.linear_model.LinearRegression())\\n ]),\\n cv=kwargs.get('cv', min(5, len(x))),\\n param_grid={\\n 'poly__degree': np.arange(\\n kwargs.get('min_degree', 3),\\n kwargs.get('max_degree', 14),\\n 2\\n )\\n }\\n )\\n x = x.reshape(-1, 1)\\n model.fit(x, y)\\n\\n def predict(_x):\\n return model.predict(np.array(_x).reshape(-1, 1))\\n\\n if PLOT:\\n yhat = predict(x)\\n fig, ax = plt.subplots(1, 1)\\n ax.plot(x, yhat, 'k--')\\n ax.plot(x, y, 'ko')\\n ax.set(xlabel='x', ylabel='y')\\n sns.despine()\\n return predict, fig, ax\\n if kwargs.get('PRINT'):\\n print(model)\\n return predict\",\n \"def LinearLeastSquaresFit(x,y):\\n \\n xavg = np.zeros(len(x),float) #<x> average\\n xavg = sum(x)/len(x)\\n \\n yavg = np.zeros(len(y),float) #<y> average\\n yavg = sum(y)/len(y)\\n \\n x2avg = np.zeros(len(x),float) #<x^2> average\\n x2avg = sum(x**2)/len(x)\\n \\n xyavg = np.zeros(len(x),float) #<xy> average\\n xyavg = sum(x*y)/len(x)\\n \\n m = (xyavg - xavg*yavg)/(x2avg-xavg**2) #slope\\n b = (x2avg*yavg-xavg*xyavg)/(x2avg-xavg**2) #intercept\\n \\n d = np.zeros(len(x),float)\\n for n in range(len(x)):\\n d[n] = y[n] -(m*x[n]+b)\\n \\n x2 = np.zeros(len(x),float)\\n for n in range(len(x)):\\n x2[n] = sum(d[n]**2)\\n \\n \\n d2avg = np.zeros(len(d),float) #<d^2> average\\n d2avg = sum(x2)/float(len(x))\\n \\n Dm = sqrt((1/float(len(x)-2))*(d2avg/(x2avg-xavg**2))) #slope error\\n Db = sqrt((1/float(len(x)-2))*((d2avg*x2avg)/(x2avg-xavg**2))) # intercept error\\n print \\\"slope=\\\", m, \\\"Slope Error=\\\", Dm,\\\"Intercept=\\\", b, \\\"Intercept Error=\\\", Db\\n return \\\"slope=\\\", m, \\\"Slope Error=\\\", Dm,\\\"Intercept=\\\", b, \\\"Intercept Error=\\\",Db\",\n \"def fit(self, X, y, l2regularize = None ) :\\n\\n X = self.generate_polynomial_features(X) # map features\\n\\n ### ========== TODO : START ========== ###\\n # part e: implement closed-form solution\\n # hint: use np.dot(...) and np.linalg.pinv(...)\\n # be sure to update self.coef_ with your solution\\n X_X_T = np.linalg.pinv(np.dot(X.transpose(),X) + l2regularize*np.identity(np.shape(X.transpose())[0]))\\n self.coef_ = np.dot(X_X_T,np.dot(X.transpose(),y))\\n\\n\\n ### ========== TODO : END ========== ###\\n\\n return self\",\n \"def polyLS(pd, x, y, f, X, Y \\\\\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\\n \\n numP = int((pd + 1) * (pd + 2) / 2)\\n \\n if (len(xmc) == 1) and (len(ymc) == 1) :\\n \\n\\n if coeff == [] :\\n p = poly(x, y, pd)\\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\\n\\n B = poly(X, Y, pd)\\n approx = B.dot(coeff).flatten()\\n coeff_copy = coeff\\n \\n else :\\n \\n approx = np.zeros(len(X), float)\\n \\n if coeff == [] :\\n for i in range(len(xmc)) :\\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\\n if len(IND) < int(1.5 * numP) :\\n raise ValueError(\\\"Not enough data for this polynomial \\\" \\\\\\n + \\\"degree.\\\\nEither lower the polynomial degree or \\\" \\\\\\n + \\\"decrease the number of subdivisions.\\\")\\n p = poly(x[IND], y[IND], pd)\\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\\n coeff.append(lam)\\n\\n coeff_copy = coeff.copy()\\n\\n for i in range(len(xmc) - 1, -1, -1) :\\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\\n B = poly(X[IND], Y[IND], pd)\\n lam = coeff.pop()\\n approx[IND] = B.dot(lam).flatten()\\n \\n return approx, coeff_copy\",\n \"def fitLine(x, y, n_chans, deg=1):\\n x_fine = np.linspace(x[0], x[-1], n_chans)\\n x = x[len(x)/4:3*len(x)/4]\\n y = y[len(y)/4:3*len(y)/4]\\n p = np.polyfit(x[::-1], y, deg) # poly fit\\n v = np.polyval(p, x_fine)\\n return v\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def test_partial_fit(self, pipeline):\\n pipeline.fit(X, Y)\\n pipeline.partial_fit(X, Y)\",\n \"def fit_curve(x,y,p0,func):\\n ifixx = np.zeros(np.array(x).shape)\\n data = sodr.Data(x,y)\\n model = sodr.Model(func)\\n worker = sodr.ODR(data,model,p0,ifixx=ifixx,maxit=500)\\n out = worker.run()\\n out = worker.restart()\\n return out\",\n \"def test_fit(self):\\n X,Y,Z = self.generate_data()\\n\\n p={'k':-1,'r':0}\\n key = (p['r'],p['k'])\\n\\n task = mmSCHPOLY()\\n fit_result = task.fit(X,Y,Z)\\n\\n self.assertEqual(fit_result.best_poly_df[key].shape[0]==4,True)\\n\\n task2 = mmSCH2W()\\n fit_result = task2.fit(X,Y,Z)\\n\\n self.assertEqual(fit_result.best_inter_df[key].shape[0]==6,True)\",\n \"def roi_mask_point_loss(mask_logits, instances, points_coord):\\n with torch.no_grad():\\n cls_agnostic_mask = mask_logits.size(1) == 1\\n total_num_masks = mask_logits.size(0)\\n\\n gt_classes = []\\n gt_mask_logits = []\\n idx = 0\\n for instances_per_image in instances:\\n if len(instances_per_image) == 0:\\n continue\\n assert isinstance(\\n instances_per_image.gt_masks, BitMasks\\n ), \\\"Point head works with GT in 'bitmask' format. Set INPUT.MASK_FORMAT to 'bitmask'.\\\"\\n\\n if not cls_agnostic_mask:\\n gt_classes_per_image = instances_per_image.gt_classes.to(dtype=torch.int64)\\n gt_classes.append(gt_classes_per_image)\\n\\n gt_bit_masks = instances_per_image.gt_masks.tensor\\n h, w = instances_per_image.gt_masks.image_size\\n scale = torch.tensor([w, h], dtype=torch.float, device=gt_bit_masks.device)\\n points_coord_grid_sample_format = (\\n points_coord[idx: idx + len(instances_per_image)] / scale\\n )\\n idx += len(instances_per_image)\\n gt_mask_logits.append(\\n point_sample(\\n gt_bit_masks.to(torch.float32).unsqueeze(1),\\n points_coord_grid_sample_format,\\n align_corners=False,\\n ).squeeze(1)\\n )\\n\\n if len(gt_mask_logits) == 0:\\n return mask_logits.sum() * 0\\n\\n gt_mask_logits = cat(gt_mask_logits)\\n assert gt_mask_logits.numel() > 0, gt_mask_logits.shape\\n\\n if cls_agnostic_mask:\\n mask_logits = mask_logits[:, 0]\\n else:\\n indices = torch.arange(total_num_masks)\\n gt_classes = cat(gt_classes, dim=0)\\n mask_logits = mask_logits[indices, gt_classes]\\n\\n # Log the training accuracy (using gt classes and 0.0 threshold for the logits)\\n mask_accurate = (mask_logits > 0.0) == gt_mask_logits.to(dtype=torch.uint8)\\n mask_accuracy = mask_accurate.nonzero(as_tuple=False).size(0) / mask_accurate.numel()\\n get_event_storage().put_scalar(\\\"point_rend/accuracy\\\", mask_accuracy)\\n\\n point_loss = F.binary_cross_entropy_with_logits(\\n mask_logits, gt_mask_logits.to(dtype=torch.float32), reduction=\\\"mean\\\"\\n )\\n return point_loss\",\n \"def fitfunc_SC(x, *p):\\n val = p[0]\\n for n in range(0, len(p) - 1, 2):\\n ind = n + 1\\n mode = (n / 2) + 1\\n val = (\\n val\\n + p[ind] * np.sin(2 * np.pi * mode * (x) / 360.0)\\n + p[ind + 1] * np.cos(2 * np.pi * mode * (x) / 360.0)\\n )\\n return val\",\n \"def check_and_fit(x, y, flag='L', threshold=1000):\\n \\n confidence_index = len(x)\\n if IsLaneFound is False:\\n threshold =500\\n if confidence_index < threshold:\\n fit = None\\n foundFlag = False\\n else:\\n fit, cov = curve_fit(lambda x, a, b, c:a*x*x+b*x + c , x, y)\\n foundFlag = True\\n return fit, foundFlag, confidence_index\",\n \"def _polyfit_coeffs(self, spec, specerr, scatter, labelA):\\n deno = specerr ** 2. + scatter ** 2.\\n Y = spec / deno\\n ATY = tf.tensordot(tf.transpose(labelA), Y, axes=[[1], [0]])\\n C = tf.expand_dims(1. / deno, 0)\\n CiA = labelA * tf.transpose(tf.tile(C, [tf.shape(labelA)[1], 1]))\\n ATCiA = tf.tensordot(tf.transpose(labelA), CiA, axes=[[1], [0]])\\n ATCiAinv = tf.linalg.inv(ATCiA)\\n return tf.tensordot(ATCiAinv, ATY, axes=[[1], [0]])\",\n \"def rls_fit0(xdata: np.ndarray,\\n ydata: np.ndarray | ma.MaskedArray) -> tuple:\\n if xdata.size < 2:\\n raise RuntimeError('too few points for a fit')\\n if xdata.size != ydata.shape[-1]:\\n raise RuntimeError('number of samples not equal for xdata, ydata')\\n\\n # perform all computations on 2 dimensional arrays\\n img_shape = ydata.shape[:-1]\\n yy1 = ydata.reshape(-1, xdata.size)\\n\\n # calculate weights\\n if ma.isMaskedArray(ydata):\\n wghts = calc_ma_weights(xdata, ma.getmaskarray(yy1))\\n else:\\n buff = np.concatenate(([2 * (xdata[1] - xdata[0])],\\n xdata[2:] - xdata[0:-2],\\n [2 * (xdata[-1] - xdata[-2])]))\\n wghts = np.repeat([buff], yy1.shape[0], axis=0)\\n wx1 = wghts / xdata\\n wx2 = wghts / xdata ** 2\\n\\n # calculate the Q elements\\n q00 = wghts.sum(axis=1)\\n q11 = (wx1 * yy1).sum(axis=1)\\n q22 = (wx2 * yy1 ** 2).sum(axis=1)\\n\\n # calculate fit parameter and its variance\\n num = yy1.count(axis=1) if ma.isMaskedArray(ydata) else len(xdata)\\n cc1 = q11 / q00\\n if ma.isMaskedArray(ydata):\\n cc1[num < 1] = ma.masked\\n chi2 = ma.abs(q22 - q00 * cc1 ** 2) / np.clip(num - 1, 1, None)\\n chi2[num <= 1] = ma.masked\\n sc1 = ma.sqrt(chi2 / q00)\\n return (cc1.reshape(img_shape).filled(np.nan),\\n sc1.reshape(img_shape).filled(np.nan))\\n\\n # using only non-MaskedArray functions\\n cc1[num < 1] = np.nan\\n chi2 = np.abs(q22 - q00 * cc1 ** 2) / np.clip(num - 1, 1, None)\\n chi2[num <= 1] = np.nan\\n sc1 = np.sqrt(chi2 / q00)\\n return cc1.reshape(img_shape), sc1.reshape(img_shape)\",\n \"def fit_polynomial(self, ym_per_pix, xm_per_pix):\\r\\n\\r\\n # Fit a second order polynomial\\r\\n self.current_fit = np.polyfit(self.ally, self.allx, 2)\\r\\n\\r\\n # Fit a second order polynomial (in meters)\\r\\n current_fit_real = np.polyfit(self.ally * ym_per_pix, self.allx * xm_per_pix, 2)\\r\\n\\r\\n # calculate the curvature (in meters)\\r\\n self.radius_of_curvature = ((1 + (2 * current_fit_real[0] * self.y_eval * ym_per_pix + current_fit_real[1])**2)**1.5) / np.absolute(2 * current_fit_real[0])\\r\\n\\r\\n # flag that a polynomial is found\\r\\n self.detected = True\",\n \"def get_mask(self, shape):\\n h, w = shape[0:2]\\n y, x = np.mgrid[:h, :w]\\n points = np.transpose((x.ravel(), y.ravel()))\\n\\n mask = _nxutils_points_inside_poly(points, self.verts)\\n #mask = nxutils.points_inside_poly(points, self.verts)\\n return mask.reshape(h, w)\",\n \"def fit_line_int(model,scaling,intercept):\\n\\treturn scaling*model + intercept\",\n \"def test_fit() -> None:\\n mapie = MapieRegressor()\\n mapie.fit(X_toy, y_toy)\",\n \"def partial_fit(self, X, y, sample_weight=...):\\n ...\",\n \"def apply_pafmap_mask(self, img_keypoints, input_shape, pafmap_joints, thickness=8):\\n paf_masks = [np.zeros((self.input_shape[0], self.input_shape[1], 1), dtype=np.float32)\\n for _ in range(len(pafmap_joints) * 2)]\\n n_pafs = [0 for _ in range(len(pafmap_joints))]\\n\\n for kp in img_keypoints:\\n for i, (kp0, kp1) in enumerate(pafmap_joints):\\n x1 = int(np.round(kp[kp0 * 3] / input_shape[1] * self.input_shape[1]))\\n y1 = int(np.round(kp[kp0 * 3 + 1] / input_shape[0] * self.input_shape[0]))\\n x2 = int(np.round(kp[kp1 * 3] / input_shape[1] * self.input_shape[1]))\\n y2 = int(np.round(kp[kp1 * 3 + 1] / input_shape[0] * self.input_shape[0]))\\n\\n if kp[kp0 * 3 + 2] != 0 and kp[kp1 * 3 + 2] != 0 and (x2 - x1 != 0 or y2 - y1 != 0):\\n tmp_paf_x = np.zeros((self.input_shape[0], self.input_shape[1], 1), dtype=np.float32)\\n tmp_paf_y = np.zeros((self.input_shape[0], self.input_shape[1], 1), dtype=np.float32)\\n\\n cv2.line(tmp_paf_x, (x1, y1), (x2, y2), 1, thickness)\\n cv2.line(tmp_paf_y, (x1, y1), (x2, y2), 1, thickness)\\n\\n x_val = (x2 - x1) / np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)\\n y_val = (y2 - y1) / np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)\\n\\n tmp_paf_x = tmp_paf_x * x_val\\n tmp_paf_y = tmp_paf_y * y_val\\n\\n paf_masks[i * 2][tmp_paf_x != 0] = tmp_paf_x[tmp_paf_x != 0]\\n paf_masks[i * 2 + 1][tmp_paf_y != 0] = tmp_paf_y[tmp_paf_y != 0]\\n\\n n_pafs[i] += 1\\n\\n paf_masks = np.array(paf_masks)\\n\\n return np.squeeze(paf_masks).transpose((1, 2, 0)), np.array(n_pafs)\",\n \"def flatspectrum(xarr, yarr, mode='mean', thresh=3, iter=5, order=3):\\n if mode == 'mean':\\n # subtract off the mean value\\n sarr = yarr - clipstats(yarr, thresh, iter)[0]\\n elif mode == 'poly':\\n # calculate the statistics and mask all of the mask with values above\\n # these\\n it = iterfit(xarr, yarr, function='poly', order=order)\\n it.iterfit()\\n sarr = yarr - it(xarr)\\n elif mode == 'mask':\\n # mask the values\\n mean, std = clipstats(yarr, thresh, iter)\\n mask = (yarr < mean + thresh * std)\\n sarr = yarr.copy()\\n sarr[mask] = 0\\n else:\\n sarr = yarr.copy()\\n return sarr\",\n \"def polyfit_2d(Xu,X):\\n\\txu = Xu[:,0]\\n\\tyu = Xu[:,1]\\n\\tX = np.squeeze(X) # an mx1 vector\\n\\tM = np.squeeze((np.ones(xu.size),xu,yu,xu**2,xu*yu,yu**2,\\n\\t\\txu**3,xu**2*yu,xu*yu**2,yu**3)) # a mxn matrix\\n\\tM = M.transpose()\\n\\tprint(\\\"solving for the polynomial fitting coefficients...\\\")\\n\\tK,resid,rnk,svs = np.linalg.lstsq(M,X,rcond=-1) # k has size n\\n\\tprint(\\\"residue:%0.8f\\trank:%0.8f\\\"%(np.sum(resid),rnk))\\n\\treturn K\",\n \"def fit(self, x):\\n raise NotImplementedError()\",\n \"def linearfit(x, y, runs=1e4):\\r\\n x *= N.ones(1); y *= N.ones(1)\\r\\n slope, yint, r, prob2, see = stats.linregress(x, y)\\r\\n scale = N.mean(y) - N.mean(x)\\r\\n nsig = Smad(N.log10(10**y/(10**x*10**scale)))\\r\\n bs_slope = N.zeros(runs); bs_yint = N.zeros(runs)\\r\\n for i in range(bs_slope.size):\\r\\n bsrun = bs.bootstrap_resample(N.arange(x.size))\\r\\n bsuse = N.where((10**y[bsrun]/(10**x[bsrun]*10**scale)>=10**(-1.*nsig)) & (10**y[bsrun]/(10**x[bsrun]*10**scale)<=10.**nsig))\\r\\n bs_slope[i], bs_yint[i] = stats.linregress(x[bsuse], y[bsuse])[:2]\\r\\n sd_slope = bs_slope.std(); sd_yint = N.sqrt(sd_slope**2/bs_yint.size*N.sum(bs_yint**2))\\r\\n \\r\\n return slope, sd_slope, yint, sd_yint\",\n \"def fit(self, x):\\n x = np.asarray(x)\\n _ = self.fit_transform(x)\",\n \"def fit(self, X, y=None):\\n #import pdb\\n #pdb.set_trace()\\n return self.partial_fit(X, y)\",\n \"def inner_fit(self):\\n pass\",\n \"def inner_fit(self):\\n pass\",\n \"def poisson_blend(source, mask, target, mix = False, strength = 1):\\n mask_points = np.argwhere(mask)\\n mask_points = list(map(tuple, mask_points))\\n\\n print(np.shape(mask_points))\\n \\n # Build Sparse\\n A, b = build_arrays(source, mask, target, mask_points, mix, strength)\\n A = A.tocsr()\\n\\n #regular solve to be clipped later\\n r = linalg.cg(A, b[:,0])[0]\\n g = linalg.cg(A, b[:,1])[0]\\n b = linalg.cg(A, b[:,2])[0]\\n \\n # go through the mask points and assign the new intensity\\n for i,index in enumerate(mask_points):\\n target[index][0] = np.clip(r[i], 0.0, 1.0)\\n target[index][1] = np.clip(g[i], 0.0, 1.0)\\n target[index][2] = np.clip(b[i], 0.0, 1.0)\\n\\n return target\",\n \"def direct_mask_loss(\\n self, pos_idx, idx_t, loc_data, mask_data, priors, masks\\n ):\\n loss_m = 0\\n for idx in range(mask_data.size(0)):\\n with torch.no_grad():\\n cur_pos_idx = pos_idx[idx, :, :]\\n cur_pos_idx_squeezed = cur_pos_idx[:, 1]\\n\\n # Shape: [num_priors, 4], decoded predicted bboxes\\n pos_bboxes = decode(\\n loc_data[idx, :, :], priors.data, cfg.use_yolo_regressors\\n )\\n pos_bboxes = pos_bboxes[cur_pos_idx].view(-1, 4).clamp(0, 1)\\n pos_lookup = idx_t[idx, cur_pos_idx_squeezed]\\n\\n cur_masks = masks[idx]\\n pos_masks = cur_masks[pos_lookup, :, :]\\n\\n # Convert bboxes to absolute coordinates\\n num_pos, img_height, img_width = pos_masks.size()\\n\\n x1, x2 = sanitize_coordinates(\\n pos_bboxes[:, 0], pos_bboxes[:, 2], img_width\\n )\\n y1, y2 = sanitize_coordinates(\\n pos_bboxes[:, 1], pos_bboxes[:, 3], img_height\\n )\\n\\n scaled_masks = []\\n for jdx in range(num_pos):\\n tmp_mask = pos_masks[\\n jdx, y1[jdx]: y2[jdx], x1[jdx]: x2[jdx]\\n ]\\n\\n while tmp_mask.dim() < 2:\\n tmp_mask = tmp_mask.unsqueeze(0)\\n\\n new_mask = F.adaptive_avg_pool2d(\\n tmp_mask.unsqueeze(0), cfg.mask_size\\n )\\n scaled_masks.append(new_mask.view(1, -1))\\n\\n mask_t = (\\n torch.cat(scaled_masks, 0).gt(0.5).float()\\n ) # Threshold downsampled mask\\n\\n pos_mask_data = mask_data[idx, cur_pos_idx_squeezed, :]\\n loss_m += (\\n F.binary_cross_entropy(\\n torch.clamp(pos_mask_data, 0, 1), mask_t, reduction=\\\"sum\\\"\\n )\\n * cfg.mask_alpha\\n )\\n\\n return loss_m\",\n \"def coefficients_to_slip(x, y, a):\\n partials = np.zeros((x.size, 3))\\n partials[:, 0] = (x / a) * (9 * (x / a) / 8 - 3 / 4)\\n partials[:, 1] = (1 - 3 * (x / a) / 2) * (1 + 3 * (x / a) / 2)\\n partials[:, 2] = (x / a) * (9 * (x / a) / 8 + 3 / 4)\\n slip = partials @ y\\n return slip\",\n \"def smooth(y, box_pts):\\r\\n box = np.ones(box_pts)/box_pts\\r\\n y_smooth = np.convolve(y, box, mode='same')\\r\\n return y_smooth\",\n \"def linear_slope_fit(wf, mean_y, sigma_y, slope, intercept):\\n\\n sum_x = sum_x2 = sum_xy = sum_y = mean_y[0] = sigma_y[0] = 0\\n isum = len(wf)\\n\\n for i,value in enumerate(wf):\\n sum_x += i \\n sum_x2 += i**2\\n sum_xy += (value * i)\\n sum_y += value\\n mean_y += (value-mean_y) / (i+1)\\n sigma_y += (value-mean_y)**2\\n\\n\\n sigma_y /= (isum + 1)\\n np.sqrt(sigma_y, sigma_y)\\n\\n\\n slope[0] = (isum * sum_xy - sum_x * sum_y) / (isum * sum_x2 - sum_x * sum_x)\\n intercept[0] = (sum_y - sum_x * slope[0])/isum\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62117845","0.62038964","0.60165256","0.5831612","0.5827311","0.57904327","0.572582","0.5706521","0.56874967","0.56852","0.56852","0.56852","0.56538486","0.5650198","0.5639281","0.5617409","0.5605478","0.5585841","0.557275","0.55547965","0.5492608","0.54752845","0.5471376","0.5469833","0.5465314","0.5464438","0.5464387","0.542986","0.54242533","0.5408492","0.5408492","0.5398255","0.53794223","0.5375679","0.5374172","0.5372648","0.5369802","0.536621","0.5364815","0.5352986","0.5351454","0.5348445","0.5343815","0.5340146","0.53107876","0.5308243","0.52935064","0.5292805","0.5287005","0.52810425","0.5271315","0.5258449","0.5248821","0.5246931","0.5225258","0.5218344","0.5204327","0.5200837","0.5194153","0.51934606","0.51921046","0.51821244","0.51801544","0.51628035","0.51628035","0.51628035","0.51628035","0.51628035","0.51628035","0.51628035","0.51628035","0.51628035","0.51628035","0.516115","0.5154271","0.5149257","0.5148186","0.5147821","0.5145903","0.51349956","0.51341313","0.51294136","0.5125295","0.51214457","0.5121339","0.5119496","0.5115786","0.51156205","0.5113988","0.5112446","0.509547","0.50911987","0.5091193","0.5091013","0.5091013","0.5084202","0.50812995","0.50792694","0.50741214","0.50722134"],"string":"[\n \"0.62117845\",\n \"0.62038964\",\n \"0.60165256\",\n \"0.5831612\",\n \"0.5827311\",\n \"0.57904327\",\n \"0.572582\",\n \"0.5706521\",\n \"0.56874967\",\n \"0.56852\",\n \"0.56852\",\n \"0.56852\",\n \"0.56538486\",\n \"0.5650198\",\n \"0.5639281\",\n \"0.5617409\",\n \"0.5605478\",\n \"0.5585841\",\n \"0.557275\",\n \"0.55547965\",\n \"0.5492608\",\n \"0.54752845\",\n \"0.5471376\",\n \"0.5469833\",\n \"0.5465314\",\n \"0.5464438\",\n \"0.5464387\",\n \"0.542986\",\n \"0.54242533\",\n \"0.5408492\",\n \"0.5408492\",\n \"0.5398255\",\n \"0.53794223\",\n \"0.5375679\",\n \"0.5374172\",\n \"0.5372648\",\n \"0.5369802\",\n \"0.536621\",\n \"0.5364815\",\n \"0.5352986\",\n \"0.5351454\",\n \"0.5348445\",\n \"0.5343815\",\n \"0.5340146\",\n \"0.53107876\",\n \"0.5308243\",\n \"0.52935064\",\n \"0.5292805\",\n \"0.5287005\",\n \"0.52810425\",\n \"0.5271315\",\n \"0.5258449\",\n \"0.5248821\",\n \"0.5246931\",\n \"0.5225258\",\n \"0.5218344\",\n \"0.5204327\",\n \"0.5200837\",\n \"0.5194153\",\n \"0.51934606\",\n \"0.51921046\",\n \"0.51821244\",\n \"0.51801544\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.51628035\",\n \"0.516115\",\n \"0.5154271\",\n \"0.5149257\",\n \"0.5148186\",\n \"0.5147821\",\n \"0.5145903\",\n \"0.51349956\",\n \"0.51341313\",\n \"0.51294136\",\n \"0.5125295\",\n \"0.51214457\",\n \"0.5121339\",\n \"0.5119496\",\n \"0.5115786\",\n \"0.51156205\",\n \"0.5113988\",\n \"0.5112446\",\n \"0.509547\",\n \"0.50911987\",\n \"0.5091193\",\n \"0.5091013\",\n \"0.5091013\",\n \"0.5084202\",\n \"0.50812995\",\n \"0.50792694\",\n \"0.50741214\",\n \"0.50722134\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7063888"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14791,"cells":{"query":{"kind":"string","value":"Polynomial search based on previous fit"},"document":{"kind":"string","value":"def limited_search(img_, window_size, flag='L'):\n # Initialize Mask with Same Size as Image #\n mask_poly = np.zeros_like(img_)\n # Get previous Coefficients #\n fit = get_last_fit(flag=flag)\n if fit is not None:\n mask_poly_smooth = smoothen_masks(fit, img_, window_size)\n return mask_poly_smooth.astype(np.uint8)\n else:\n return mask_poly"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_expected_polynomial_coefs(y, degree, with_intercept=True):\n poly_matrix = np.vander(np.arange(len(y)), degree + 1)\n if not with_intercept:\n poly_matrix = poly_matrix[:, :-1]\n return np.linalg.lstsq(poly_matrix, y.to_numpy(), rcond=None)[0]","def fit_polynomial(self, ym_per_pix, xm_per_pix):\r\n\r\n # Fit a second order polynomial\r\n self.current_fit = np.polyfit(self.ally, self.allx, 2)\r\n\r\n # Fit a second order polynomial (in meters)\r\n current_fit_real = np.polyfit(self.ally * ym_per_pix, self.allx * xm_per_pix, 2)\r\n\r\n # calculate the curvature (in meters)\r\n self.radius_of_curvature = ((1 + (2 * current_fit_real[0] * self.y_eval * ym_per_pix + current_fit_real[1])**2)**1.5) / np.absolute(2 * current_fit_real[0])\r\n\r\n # flag that a polynomial is found\r\n self.detected = True","def fit_polynomial_regression(self, x_train, y_train):\n x_poly = self.poly_reg.fit_transform(x_train)\n self.lin_reg.fit(x_poly, y_train)","def find_coefficients(self):\n self.make_matrix()\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition","def fit(self, X):","def build_poly(x, degree):\n \"\"\"\n Assemble the 3 label vectors with the original ordering \n Inputs:\n - x (ndarray) : binary prediction for set 1\n - degree (int) : binary prediction for set 2 \n Outputs: \n - p (ndarray) : predicted labels for test set ( with the original ordering)\n \"\"\"\n # forming a matrix containing the data points\n terms = np.hstack([np.ones([x.shape[0],1]),np.tile(x,(1,degree))])\n index = np.arange(degree)+1\n \n # forming a matrix contnaining the exponents\n exponents = np.multiply(np.ones((1, x.shape[1])), index[:, np.newaxis])\n exponents = exponents.reshape([1, x.shape[1]*degree])\n exponents = np.multiply(exponents, np.ones([x.shape[0], 1]))\n exponents = np.hstack([np.ones( (x.shape[0], 1) ),exponents])\n \n # using the exponent matrix as the element-wise exponents of the terms in the terms matrix\n p=np.power(terms,exponents)\n return p","def non_linear_polynomial_fit(self, seq, factor):\n B = np.array(seq[1:4])\n A = np.array([[seq[k], factor ** (k + 1), 1] for k in range(3)])\n return np.around(np.linalg.solve(A,B), decimals=2)","def fit_poly(data, error_func, degree=4): \n\n # generate initial guss for polynomial model (all coeffs = 1)\n guess = np.poly1d(np.ones(degree + 1, dtype=np.float32))\n\n # plot intial guess\n x = np.linspace(-5, 5, 21)\n plt.plot(x, np.polyval(guess, x), 'm--', linewidth=2.0, label=\"Initial guess\")\n\n # call optimizer to minimize error function\n result = spo.minimize(error_poly, guess, args=(data,), method='SLSQP', options={'disp':True})\n \n # convert optimal result into a poly1d object\n return np.poly1d(result.x)","def polyfit(x, y, yerror, pinit=[0,0,0,0]):\n x = np.array(x)\n y = np.array(y)\n pinit[2] = np.mean(y)\n pinit[3] = x[len(x)/2]\n if (type(yerror) != list and type(yerror) != np.ndarray):\n yerror = np.ones(len(x)) * yerror\n fitfunc = lambda p, x: p[2] + p[1]*(x-p[3]) + p[0]*(x-p[3])**2\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\n p = out[0]\n covar = out[1]\n return(p)","def fit(x, a, p, b):\n return a * (p ** x) + b","def _fit_poly(y_data, deg=5):\n x = np.arange(1, len(y_data) + 1)\n coeffs = np.polynomial.polynomial.polyfit(\n x, y_data, deg=deg)\n y_pred = poly(x, coeffs)\n return coeffs, np.mean((y_data - y_pred) ** 2)","def best_poly_fit(x_data, y_data, plot_fig=False):\n\tcentral_x = np.mean(x_data)\n\tmodels = []\n\tfor i in xrange(3):\n\t\twith warnings.catch_warnings():\n\t\t\twarnings.filterwarnings('error')\n\t\t\ttry: \n\t\t\t\tmodels.append(np.polyfit(x_data - central_x, y_data,i +1))\n\t\t\texcept np.RankWarning:\n\t\t\t\tprint \"not enought data for %d order\" % i\n\treduced_chi_squared = []\n\tif len(x_data) == 2:\n\t\treduced_chi_squared.append(0.0)\n\telse:\n\t\treduced_chi_squared.append(np.sum((np.polyval(models[0],x_data - central_x) - y_data)**2) / (len(y_data) - 1. - 1.))\n\t\treduced_chi_squared.append(np.sum((np.polyval(models[1],x_data - central_x) - y_data)**2) / (len(y_data) - 2. - 1.))\n\t\treduced_chi_squared.append(np.sum((np.polyval(models[2],x_data - central_x) - y_data)**2) / (len(y_data) - 3. - 1.))\n\n\treduced_chi_squared = np.array(reduced_chi_squared)\n\n\t# If there are only 3 data points or less, use 1st order\n\tif len(x_data) <= 3:\n\t\tmodel = models[0]\n\telse:\n\t\tmin_ind = np.argmin(reduced_chi_squared)\n\t\tmodel = models[min_ind]\n\n\tif plot_fig:\n\t\tfig1 = pl.figure(1)\n\t\tpl.plot(x_data,y_data,'o')\n\n\t\tmodel_x = np.linspace(np.min(x_data),np.max(x_data), 200)\n\t\tmodel_y = np.polyval(model,model_x - central_x)\n\t\treturn model_x,model_y # return arrays of values to plot. \n\telse:\n\t\t# parameters array, and central wavelength\n\t\treturn np.array(model),central_x","def fit(self, x):\n pass","def least_sqr_fit(self,x, y):\n A = np.array([ x, np.ones(len(x))])\n # linearly generated sequence\n a,f,g,h = np.linalg.lstsq(A.T,y) # obtaining the parameters\n print 'de gevonden rechte = %.10f x + %.10f' %(a[0], a[1])\n lined = map(lambda g: a[0]*g +a[1],x) # regression line\n return lined , a","def linearfit(x,y):\n fit = np.polyfit(x,y,1)\n fit_fn = np.poly1d(fit)\n yy = fit_fn(x) \n \n return yy","def polyLS(pd, x, y, f, X, Y \\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\n \n numP = int((pd + 1) * (pd + 2) / 2)\n \n if (len(xmc) == 1) and (len(ymc) == 1) :\n \n\n if coeff == [] :\n p = poly(x, y, pd)\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\n\n B = poly(X, Y, pd)\n approx = B.dot(coeff).flatten()\n coeff_copy = coeff\n \n else :\n \n approx = np.zeros(len(X), float)\n \n if coeff == [] :\n for i in range(len(xmc)) :\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\n if len(IND) < int(1.5 * numP) :\n raise ValueError(\"Not enough data for this polynomial \" \\\n + \"degree.\\nEither lower the polynomial degree or \" \\\n + \"decrease the number of subdivisions.\")\n p = poly(x[IND], y[IND], pd)\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\n coeff.append(lam)\n\n coeff_copy = coeff.copy()\n\n for i in range(len(xmc) - 1, -1, -1) :\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\n B = poly(X[IND], Y[IND], pd)\n lam = coeff.pop()\n approx[IND] = B.dot(lam).flatten()\n \n return approx, coeff_copy","def get_polyfit_function(self):\n N = len(self.coefficients)\n return lambda x: np.dot( self.get_poly(x).T , self.coefficients.reshape(N, 1) )","def fit(self, X, y):","def fit(self, X, y):","def fit(self, X, y):","def evaluate_polynomial(f,x):\n degree = len(f)-1\n ans = 0\n for i in f:\n ans += i*x**degree\n degree -= 1\n return(ans)","def polyFeat(X, p):\r\n # You need to return the following variables correctly.\r\n X_poly = np.zeros((X.shape[0], p))\r\n\r\n # ====================== YOUR CODE HERE ======================\r\n\r\n for i in range(p):\r\n X_poly[:, i] = X[:, 0] ** (i + 1)\r\n\r\n # ============================================================\r\n return X_poly","def fit():\n pass","def _linesearch_powell(func, p, xi, tol=1e-3):\n def myfunc(alpha):\n return func(p + alpha * xi)\n alpha_min, fret, iter, num = optimize.brent(myfunc, full_output=1, tol=tol)\n xi = alpha_min*xi\n return squeeze(fret), p+xi, xi","def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\r\n\r\n # replace these lines with your solution\r\n initial_T = time.time()\r\n\r\n def get_points(f, a, b, n):\r\n x = np.linspace(a, b, n)\r\n y_lst = f(x)\r\n y = np.array(y_lst)\r\n\r\n return x, y\r\n\r\n def build_vector(x, y, size, deg):\r\n if deg == size:\r\n y_n = y.sum()\r\n else:\r\n y_n = np.dot(y, (x ** (size - deg)))\r\n pol1 = np.zeros(size + 1)\r\n for i in range(size + 1):\r\n pol1[i] = (x ** (2 * size - deg - i)).sum()\r\n return pol1, y_n\r\n\r\n def build_coeff_matrix(f, a, b, n, d):\r\n x, y = get_points(f, a, b, n)\r\n deg = d\r\n b = np.array([])\r\n coeff_matrix = np.array([])\r\n for i in range(d + 1):\r\n x_n, y_n = build_vector(x, y, d, i)\r\n deg -= 1\r\n coeff_matrix = np.append(coeff_matrix, x_n)\r\n b = np.append(b, y_n)\r\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\r\n return coeff_matrix, b\r\n\r\n def solve_coeff_matrix(coeff_matrix, b):\r\n A_inverse = np.linalg.inv(coeff_matrix)\r\n coeffs = A_inverse.dot(b)\r\n return coeffs\r\n\r\n def build_function_from_coeffs(coeffs):\r\n f = np.poly1d(coeffs)\r\n return f\r\n\r\n n = 100 # fisrt sample size\r\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\r\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\r\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\r\n break\r\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\r\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\r\n break\r\n result = build_function_from_coeffs(coeffs)\r\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\r\n break\r\n n += 200 # increasing sample size\r\n\r\n return result","def fit(self, X, y, l2regularize = None ) :\n\n X = self.generate_polynomial_features(X) # map features\n\n ### ========== TODO : START ========== ###\n # part e: implement closed-form solution\n # hint: use np.dot(...) and np.linalg.pinv(...)\n # be sure to update self.coef_ with your solution\n X_X_T = np.linalg.pinv(np.dot(X.transpose(),X) + l2regularize*np.identity(np.shape(X.transpose())[0]))\n self.coef_ = np.dot(X_X_T,np.dot(X.transpose(),y))\n\n\n ### ========== TODO : END ========== ###\n\n return self","def poly_regression(self,precision=8):\n # return empty lists if input is empty\n if self.training == []:\n return [],[]\n\n latitudes = []\n longitudes = []\n for point in self.training[:-1]:\n latitudes.append(point[0])\n longitudes.append(point[1]) \n # store everything in a dataframe\n latDf = pd.DataFrame(numpy.array(latitudes), columns=['latitudes'])\n longDf = pd.DataFrame(numpy.array(longitudes), columns=['longitudes'])\n\n # learn how to do regression\n reg = linear_model.LinearRegression()\n\n # pass the order of your polynomial here \n poly = PolynomialFeatures(precision)\n\n \n # regression with latitude as domain\n vertical_predicted_path = []\n transform = poly.fit_transform(longDf)\n\n reg.fit(transform,latDf)\n predictions = reg.predict(transform)\n\n for i in range(len(predictions)):\n vertical_predicted_path.append([predictions[i][0],longDf[\"longitudes\"][i]])\n\n \n # regression with longitude domain\n horizontal_predicted_path = []\n transform = poly.fit_transform(latDf)\n\n reg.fit(transform,longDf)\n predictions = reg.predict(transform)\n\n for i in range(len(predictions)):\n horizontal_predicted_path.append([latDf[\"latitudes\"][i], predictions[i][0]])\n\n self.horizontal = sorted(horizontal_predicted_path, key=lambda k: [k[1], k[0]])\n self.vertical = sorted(vertical_predicted_path, key=lambda k: [k[0], k[1]])\n \n # return sorted horizontal and vertical prediction\n return self.horizontal, self.vertical","def regression(df_tot, fasit_key, chosen, max_p):\n\n with np.errstate(divide='ignore'):\n # First regression\n first_model = sm.OLS(df_tot[fasit_key], df_tot[chosen])\n\n # Initializing loop\n results = first_model.fit()\n chosen_p = chosen.copy()\n ant_break = 0\n\n # Looping through until final model is chosen\n while max(results.pvalues) > max_p or len(results.pvalues) >= max_final_numb_kandidater:\n if len(results.pvalues) <= min_kandidater:\n ant_break = 1 # count\n break\n chosen_p.remove(results.pvalues.idxmax()) # updating the chosen list\n\n with np.errstate(divide='ignore'):\n results = sm.OLS(df_tot[fasit_key], df_tot[chosen_p]).fit() # regression\n\n return results, chosen_p, ant_break","def fit_data(x, y, flag_thr, deg=9):\n # Flag sorted data\n xf, yf = diff_xy(x, y, flag_thr)\n\n # Fit polynomial to flagged data\n p = np.polyfit(xf, yf, deg)\n p = np.poly1d(p)\n pg = p(x)\n\n return pg","def partial_fit(self, X, y=...):\n ...","def partial_fit(self, X, y=...):\n ...","def plotBestFitOfAllData(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True):\n train(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True) \n plt.title(\"Polynomial function regression\")\n plt.grid()\n plt.plot(x_poly, y_poly, c='black', label='true function')\n plt.scatter(x_samples, y_samples, s=20, c='green', label='sample')\n plt.legend()\n plt.show()","def get_polyfit(self, stack_of_points, uq=False):\n N = len(self.coefficients)\n if uq:\n return np.dot(self.get_poly(stack_of_points).T , self.coefficients.reshape(N, 1)), self._get_polystd(stack_of_points)\n else:\n return np.dot(self.get_poly(stack_of_points).T , self.coefficients.reshape(N, 1))","def fit(self):\n\n fitdata = np.polyfit(self.v**(-2./3.), self.e, 3, full=True)\n ssr = fitdata[1]\n sst = np.sum((self.e - np.average(self.e))**2.)\n residuals0 = ssr/sst\n deriv0 = np.poly1d(fitdata[0])\n deriv1 = np.polyder(deriv0, 1)\n deriv2 = np.polyder(deriv1, 1)\n deriv3 = np.polyder(deriv2, 1)\n\n self.v0 = None\n for x in np.roots(deriv1):\n if x > 0 and deriv2(x) > 0:\n self.v0 = x**(-3./2.)\n break\n\n if self.v0 is None:\n raise ValueError('No minimum!')\n\n derivV2 = 4./9. * x**5. * deriv2(x)\n derivV3 = (-20./9. * x**(13./2.) * deriv2(x) -\n 8./27. * x**(15./2.) * deriv3(x))\n bulk_modulus0 = derivV2 / x**(3./2.)\n bulk_deriv0 = -1 - x**(-3./2.) * derivV3 / derivV2\n\n self.e0 = deriv0(x)\n self.B0 = bulk_modulus0\n self.B1 = bulk_deriv0\n\n return self.v0, self.e0, self.B0, self.B1, residuals0","def regression_fit(self, x, y, deg):\n return np.polyfit(x, y, deg=deg)","def fit_poly(x, y, n=5, log=False):\n \n x_g = x\n x = np.ma.array(x, mask=y.mask).compressed()\n y = y.compressed()\n if log:\n yl = np.log10(y)\n else:\n yl = y\n fit = np.polyfit(x, yl, n)\n p = np.poly1d(fit)\n \n if log:\n return 10**(p(x_g))\n else:\n return p(x_g)","def poly_regression_cubic(X, Y, Xs_test, Ys_test):\n ## YOUR CODE HERE\n #################\n return 0","def fit(self, X,y):\n pass","def polyfit_2d(Xu,X):\n\txu = Xu[:,0]\n\tyu = Xu[:,1]\n\tX = np.squeeze(X) # an mx1 vector\n\tM = np.squeeze((np.ones(xu.size),xu,yu,xu**2,xu*yu,yu**2,\n\t\txu**3,xu**2*yu,xu*yu**2,yu**3)) # a mxn matrix\n\tM = M.transpose()\n\tprint(\"solving for the polynomial fitting coefficients...\")\n\tK,resid,rnk,svs = np.linalg.lstsq(M,X,rcond=-1) # k has size n\n\tprint(\"residue:%0.8f\trank:%0.8f\"%(np.sum(resid),rnk))\n\treturn K","def fit(self, pressure, loading, param_guess, optimization_params=None, verbose=False):\n if verbose:\n logger.info(f\"Attempting to model using {self.name}\")\n\n # parameter names (cannot rely on order in Dict)\n param_names = [param for param in self.params]\n guess = numpy.array([param_guess[param] for param in param_names])\n bounds = [[self.param_bounds[param][0] for param in param_names],\n [self.param_bounds[param][1] for param in param_names]]\n\n # remove invalid values in function\n zero_values = ~numpy.logical_and(pressure > 0, loading > 0)\n if any(zero_values):\n logger.warning('Removed points which are equal to 0.')\n pressure = pressure[~zero_values]\n loading = loading[~zero_values]\n\n # define fitting function as polynomial transformed input\n ln_p_over_n = numpy.log(numpy.divide(pressure, loading))\n\n # add point\n add_point = False\n added_point = False\n if optimization_params:\n add_point = optimization_params.pop('add_point', None)\n fractional_loading = loading / max(loading)\n if len(fractional_loading[fractional_loading < 0.5]) < 3:\n if not add_point:\n raise CalculationError(\n \"\"\"\n The isotherm recorded has very few points below 0.5\n fractional loading. If a virial model fit is attempted\n the resulting polynomial will likely be unstable in the\n low loading region.\n\n You can pass ``add_point=True`` in ``optimization_params``\n to attempt to add a point in the low pressure region or\n record better isotherms.\n \"\"\"\n )\n added_point = True\n ln_p_over_n = numpy.hstack([ln_p_over_n[0], ln_p_over_n])\n loading = numpy.hstack([1e-1, loading])\n\n def fit_func(x, L, ln_p_over_n):\n for i, _ in enumerate(param_names):\n self.params[param_names[i]] = x[i]\n return self.params['C'] * L**3 + self.params['B'] * L**2 \\\n + self.params['A'] * L - numpy.log(self.params['K']) - ln_p_over_n\n\n kwargs = dict(\n fun=fit_func, # fitting function\n x0=guess, # initial guess\n bounds=bounds, # bounds of the parameters\n args=(loading, ln_p_over_n), # extra arguments to the fit function\n # loss='huber', # use a loss function against outliers\n # f_scale=0.1, # scale of outliers\n )\n if optimization_params:\n kwargs.update(optimization_params)\n\n opt_res = self.fit_leastsq(kwargs)\n\n # assign params\n for index, _ in enumerate(param_names):\n self.params[param_names[index]] = opt_res.x[index]\n\n self.rmse = numpy.sqrt(numpy.sum((opt_res.fun)**2) / len(loading))\n\n if verbose:\n logger.info(f\"Model {self.name} success, RMSE is {self.rmse:.4g}\")\n n_load = numpy.linspace(1e-2, numpy.amax(loading), 100)\n virial_plot(\n loading, ln_p_over_n, n_load,\n numpy.log(numpy.divide(self.pressure(n_load), n_load)), added_point\n )","def smooth(x, y, PLOT=False, **kwargs):\n assert len(x) == len(y)\n x = np.array(x)\n y = np.array(y)\n\n # do a grid search to find the optimal polynomial degree\n model = GridSearchCV(\n # use a linear model with polynomial features\n sklearn.pipeline.Pipeline([\n ('poly', sklearn.preprocessing.PolynomialFeatures(degree=3)),\n ('linear', sklearn.linear_model.LinearRegression())\n ]),\n cv=kwargs.get('cv', min(5, len(x))),\n param_grid={\n 'poly__degree': np.arange(\n kwargs.get('min_degree', 3),\n kwargs.get('max_degree', 14),\n 2\n )\n }\n )\n x = x.reshape(-1, 1)\n model.fit(x, y)\n\n def predict(_x):\n return model.predict(np.array(_x).reshape(-1, 1))\n\n if PLOT:\n yhat = predict(x)\n fig, ax = plt.subplots(1, 1)\n ax.plot(x, yhat, 'k--')\n ax.plot(x, y, 'ko')\n ax.set(xlabel='x', ylabel='y')\n sns.despine()\n return predict, fig, ax\n if kwargs.get('PRINT'):\n print(model)\n return predict","def _lin_regress(self, y, x, bias=True):\n n_samples = x.shape[0]\n x = self.make_polynomial(x[:, np.newaxis], fit_intercept=bias)\n l = np.linalg.cholesky(x.T @ x)\n v = solve_triangular(l, x.T @ y, lower=True)\n coefs = solve_triangular(l.T, v)\n pred = x @ coefs\n resid = y - pred\n rss = resid @ resid\n ddof = n_samples - (1 + bias)\n return rss, ddof","def get_poly(kwargs):\n from sklearn.preprocessing import PolynomialFeatures\n return PolynomialFeatures(**kwargs)","def __find_psi__(self):\r\n\r\n # Get data to fit the model\r\n x = self.train_x\r\n y = self.train_y\r\n\r\n # Initialize model parameters\r\n psi = self.__initialize_psi__()\r\n alpha = 0. # slope of the first segment is constrained to be zero\r\n beta = 10.\r\n gamma = 10.\r\n psi_p = np.inf\r\n\r\n # Max iterations (arbitrary choise)\r\n i = 1000\r\n\r\n # Iterative fit, stopping condition on gamma\r\n while abs(gamma) > 1e-2:\r\n self.psi = psi\r\n # Fitting procedure from [1]\r\n u = self.__Us__(x)\r\n v = self.__Vs__(x)\r\n c = np.ones_like(x)\r\n A = np.vstack([u, v, c]).T\r\n beta, gamma, intercept = np.linalg.lstsq(A, y)[0]\r\n psi_p = psi\r\n psi = psi + gamma / beta\r\n\r\n # Re-initialize breakpoint (psi) if it leaves the data's domain\r\n if psi > np.max(x) or psi < np.min(x):\r\n psi = self.__initialize_psi__()\r\n\r\n # Decrement iterations\r\n i -= 1\r\n\r\n # Give up if stopping condition not met after max iterations\r\n if i < 0:\r\n print('Max iteration reached, no breakpoint found')\r\n # Since no solution, put \"breakpoint\" at the end of the data\r\n beta = 0.\r\n gamma = 0.\r\n psi = np.max(x)\r\n intercept = np.mean(y)\r\n break\r\n\r\n if i >= 0:\r\n print('Found breakpoint at x = ' + str(psi))\r\n\r\n # Store the result of the fit\r\n self.alpha = alpha\r\n self.beta = beta\r\n self.gamma = gamma\r\n self.psi = psi\r\n self.intercept = intercept","def fit(self, x):\n raise NotImplementedError()","def fit(self, X, Y):\n ...","def coef_approximation(p, order):\n\n\t# maintain parity of order +1\n\tn = 50 + order +1\n\tr = 1\n\txs = np.linspace(-r, r, num=n)\n\tys = p(xs)\n\n\t# [TODO]: fix coeffients method\n\t# replace with 'c = coeffients(xs, ys)'\n\tdegree = n \n\tc = np.polyfit(xs,ys,degree)\n\n\treturn c","def polyfit(dates, levels, p):\n assert isinstance(p, int) and p > 0, f\"{p} is not a positive integer\"\n\n x = matplotlib.dates.date2num(dates)\n y = levels\n try:\n # Find coefficients of best-fit polynomial f(x) of degree p\n p_coeff = np.polyfit(x - x[0], y, p)\n # Convert coefficient into a polynomial that can be evaluated\n poly = np.poly1d(p_coeff)\n # Returns a 1D polynomial and time-axis shift\n return poly, x[0]\n except TypeError:\n # workaround to handle unexpected numpy polyfit errors\n return None, x[0]","def fitfunc(x_unshifted, p=default()):\n x = x_unshifted+p[4]\n xtr, ytr, gradtr = logcontinuity(p)\n if x < xtr:\n return logpeak(x, p)\n else:\n return logpowerlaw(x, p)","def __getPolynomial(self) -> 'func':\n return lambda x: sum(self.pts[i]*base(x)\n for i, base in enumerate(self.basis))","def fit(self, X, y=None):\n #import pdb\n #pdb.set_trace()\n return self.partial_fit(X, y)","def linfit(x, y, yerror, pinit=[0,0]):\n x = np.array(x)\n y = np.array(y)\n if (type(yerror) != list and type(yerror) != np.ndarray):\n yerror = np.ones(len(x)) * yerror\n fitfunc = lambda p, x: p[1] + p[0]*x\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\n p = out[0]\n covar = out[1]\n return(p)","def _fit_point_lens(self):\n\n def chi2_fun(theta, event, parameters_to_fit):\n \"\"\"\n for a given event set attributes from parameters_to_fit\n (list of str) to values from theta list\n \"\"\"\n for (key, val) in enumerate(parameters_to_fit):\n setattr(event.model.parameters, val, theta[key])\n chi2 = event.get_chi2()\n if chi2 < chi2_fun.best_chi2:\n chi2_fun.best_chi2 = chi2\n return chi2\n chi2_fun.best_chi2 = 1.e10\n\n def jacobian(theta, event, parameters_to_fit):\n \"\"\"\n Calculate chi^2 gradient (also called Jacobian).\n \"\"\"\n for (key, val) in enumerate(parameters_to_fit):\n setattr(event.model.parameters, val, theta[key])\n return event.chi2_gradient(parameters_to_fit)\n\n if self._event_PSPL is None:\n self._set_event_PSPL()\n\n parameters_to_fit = [\"t_0\", \"u_0\", \"t_E\"]\n initial_guess = [self._parameters[p] for p in parameters_to_fit]\n\n failed = False\n try:\n result = op.minimize(\n chi2_fun, x0=initial_guess,\n args=(self._event_PSPL, parameters_to_fit),\n method='Newton-CG', jac=jacobian, tol=3.e-4)\n except:\n failed = True\n\n if failed:\n try:\n result = op.minimize(\n chi2_fun, x0=initial_guess,\n args=(self._event_PSPL, parameters_to_fit),\n method='Newton-CG', jac=jacobian, tol=3.e-4)\n except:\n pass\n# XXX what if fit failed (i.e., .success is False)?\n\n self._LSST_PSPL_chi2 = chi2_fun.best_chi2","def residuals(self, p, data, X):\n err = data - self.fitfunc(X,p)\n return err","def pol_evl(x, coef, N):\n ans = coef[0]\n for i in range(1, N + 1):\n ans = ans * x + coef[i]\n return ans","def linfit(x, y, sigma_y):\n npar = 2 #Number of fitting parameters. If we were doing ax^2 + bx + c then npar = 3\n npts = len(x) #Number of data points\n\n if npts < npar:\n print(\"Not enough data points to fit a first order polynomial\")\n return\n\n if npts != len(y) or npts != len(sigma_y):\n print(\"Lengths of the inputs must be the same. len(x) = {}, len(y) = {},\"\n \"len(sigma_y) = {}\".format(len(x),len(y), len(sigma_y)))\n return\n\n #Make sure everything is a np.array that'll make the math easier\n x = np.array(x)\n y = np.array(y)\n sigma_y = np.array(sigma_y)\n\n sw = sum(1 / sigma_y**2)\n sy = sum(y / sigma_y**2)\n sx = sum(x / sigma_y**2)\n sx2= sum((x / sigma_y)**2)\n sxy= sum((y*x / sigma_y)**2)\n\n #Find the fit parameters\n Delta = sw*sx2 - sx**2\n a = (sx2*sy - sx*sxy)/Delta\n b = (sxy*sw - sx*sy)/Delta\n da = np.sqrt(sx2 / Delta)\n db = np.sqrt(sw / Delta)\n\n fit = a + b*x\n chi2 = sum(((y - fit) / sigma_y)**2)\n if npts > npar:\n chi2red = chi2 / (npts - npar)\n else:\n chi2red = 0\n\n return [a, da, b, db, chi2red]","def fit(self, x, y):\r\n\r\n self.train_x = x\r\n self.train_y = y\r\n self.__find_psi__()","def fit(self):\n raise NotImplementedError","def get_fit(self) -> np.poly1d:\n if self.log_fits is not None:\n return next(self.log_fits)\n x = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: [line.point1.y for line in m.marker_lines])\n .to_list()\n )\n y = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: [line.point1.x for line in m.marker_lines])\n .to_list()\n )\n if self.orientation == Orientation.UP_DOWN:\n fit = np.polyfit(x, y, 1)\n else:\n fit = np.polyfit(y, x, 1)\n return np.poly1d(fit)","def polyval(p, x):\r\n val = 0\r\n ii = len(p) - 1\r\n for i in range(len(p) - 1):\r\n val += p[i] * (x ** ii)\r\n ii -= 1\r\n return val + p[-1]","def find_poly_root(poly, initial_guess = 0.0, limit = 0.00001, max_iterations = 1000):\n # Calculate the polynomial derivatives\n dpoly = polynomial.derivative(poly)\n ddpoly = polynomial.derivative(dpoly)\n # Closures !!!\n f = lambda x: polynomial.eval(poly, x)\n df = lambda x: polynomial.eval(dpoly, x)\n ddf = lambda x: polynomial.eval(ddpoly, x)\n # Call the generic root finder\n return find_root(f, df, ddf, initial_guess, limit, max_iterations)","def get_poly_params(fun: XFunction, x: float, degree: int) -> tuple[float, ...]:\n if degree < 0:\n return (0.0,)\n rhs = np.array([fun(x, order=i) for i in range(degree, -1, -1)])\n mat = np.zeros((degree + 1, degree + 1))\n for i in range(degree + 1):\n for j in range(i + 1):\n mat[i, j] = factorial(degree - j) / factorial(i - j) * x ** (i - j)\n return tuple(np.linalg.solve(mat, rhs))","def search(y, x, optimize_on=\"te_loss\", split_method = 'mass'):\n\n \n\t# split the data (8 model)\n\tsplit_train = split.split(y, x, method= split_method)\n\n\t# large range of parameter\n\tdegrees = range(2, 15)\n\tlambdas = np.logspace(-5, 10)\n\n\n\tlambdas_star = []\n\tdegrees_star = []\n\tprint(\"start search\")\n\tfor i, splitted_set in enumerate(split_train):\n\t\tsub_y, sub_x, id_indices = splitted_set\n\n\t\t# first rough search with large scale\n\t\tlambda_star, degree_star, score = _inner_search(sub_y, sub_x, degrees, lambdas, optimize_on)\n\n\t\t# zoomed search around best parameters\n\t\t# zoomed_degree = range(degree_star-2, degree_star + 2)\n\t\tzoomed_lambda = np.logspace(lambda_star - 2, lambda_star + 2, 25)\n\t\tlambda_star, degree_star, score = _inner_search(sub_y, sub_x, degrees, zoomed_lambda, optimize_on)\n\n\t\t# store found values\n\t\tlambdas_star.append(lambda_star)\n\t\tdegrees_star.append(degree_star)\n\n\t\t# print summary\n\t\tprint(\"-------------------------------------\")\n\t\tprint(\"Set\", i)\n\t\tprint(\"-------------------------------------\")\n\t\tprint(\"lambda*:\", lambda_star)\n\t\tprint(\"degree: \", degree_star)\n\t\tif optimize_on == \"te_loss\":\n\t\t\tprint(\"test set loss: \", score)\n\t\telif optimize_on == \"accu\":\n\t\t\tprint(\"accuracy: \", score)\n\n\tprint(\"...............................\")\n\tprint(\"end\")\n\treturn lambdas_star, degrees_star","def _evaluate(self, x):\n if _isscalar(x):\n pos = np.searchsorted(self.x_list, x)\n if pos == 0:\n y = self.coeffs[0, 0] + self.coeffs[0, 1] * (x - self.x_list[0])\n elif pos < self.n:\n alpha = (x - self.x_list[pos - 1]) / (\n self.x_list[pos] - self.x_list[pos - 1]\n )\n y = self.coeffs[pos, 0] + alpha * (\n self.coeffs[pos, 1]\n + alpha * (self.coeffs[pos, 2] + alpha * self.coeffs[pos, 3])\n )\n else:\n alpha = x - self.x_list[self.n - 1]\n y = (\n self.coeffs[pos, 0]\n + x * self.coeffs[pos, 1]\n - self.coeffs[pos, 2] * np.exp(alpha * self.coeffs[pos, 3])\n )\n else:\n m = len(x)\n pos = np.searchsorted(self.x_list, x)\n y = np.zeros(m)\n if y.size > 0:\n out_bot = pos == 0\n out_top = pos == self.n\n in_bnds = np.logical_not(np.logical_or(out_bot, out_top))\n\n # Do the \"in bounds\" evaluation points\n i = pos[in_bnds]\n coeffs_in = self.coeffs[i, :]\n alpha = (x[in_bnds] - self.x_list[i - 1]) / (\n self.x_list[i] - self.x_list[i - 1]\n )\n y[in_bnds] = coeffs_in[:, 0] + alpha * (\n coeffs_in[:, 1]\n + alpha * (coeffs_in[:, 2] + alpha * coeffs_in[:, 3])\n )\n\n # Do the \"out of bounds\" evaluation points\n y[out_bot] = self.coeffs[0, 0] + self.coeffs[0, 1] * (\n x[out_bot] - self.x_list[0]\n )\n alpha = x[out_top] - self.x_list[self.n - 1]\n y[out_top] = (\n self.coeffs[self.n, 0]\n + x[out_top] * self.coeffs[self.n, 1]\n - self.coeffs[self.n, 2] * np.exp(alpha * self.coeffs[self.n, 3])\n )\n\n y[x == self.x_list[0]] = self.y_list[0]\n\n return y","def partial_fit(self, X, y=..., **fit_params):\n ...","def evaluate_poly(poly, x):\n exp = 0\n total = 0\n for coef in poly:\n total += coef * (x ** exp)\n exp += 1\n\n return total","def fit(self):\n self.eval_chisq([1, 1, 1, 1])","def lsq_coefficients(x, y, fit_intercept=False):\n if fit_intercept:\n x = np.vstack([x, np.ones(len(x))]).T\n else:\n x = np.vstack([x, np.zeros(len(x))]).T\n return np.dot(np.dot(np.linalg.pinv(np.dot(x.T, x)), x.T), y)","def fit_poly_model(order, train_data, feature: str, valid_data=None, output: str = 'price',\n l2_penalty=1e-9,\n normalization: bool = True, model_plot: bool = False, color_scheme: List[str] = None,\n pause_plotting_time=5):\n # an 'order' degree polynomial :\n poly_data = polynomial_dataframe(train_data[feature], order)\n poly_data[output] = train_data[output]\n\n # compute the regression weights for predicting sales[‘price’]\n # based on the 1 degree polynomial feature ‘sqft_living’:\n from sklearn.linear_model import Ridge\n # make a new instance of the object:\n model = Ridge(alpha=l2_penalty, normalize=normalization)\n # convert data frame to numpy array to prevent shape error with sikit-learn:\n x = np.array(poly_data.iloc[:, :-1])\n y = np.array(poly_data[output]).reshape(-1, 1)\n\n model.fit(x, y)\n\n # store all coefficient in poly1_weights array:\n poly_weights = model.intercept_\n for i in range(0, len(model.coef_)):\n poly_weights = np.append(poly_weights, model.coef_[i])\n\n # Plotting the model, features Xs vs observation Y:\n if model_plot:\n # produce a scatter plot of the training data (just square feet vs price) with fitted model:\n if color_scheme is not None:\n # plot without default color:\n plt.scatter(poly_data['power_1'], poly_data[output], c=color_scheme[0])\n plt.plot(x[:, 0], model.predict(x), c=color_scheme[1])\n else:\n # plot with default color but in different figures:\n import random\n num_figure = random.randint(0, 1000)\n plt.figure(num_figure)\n plt.scatter(poly_data['power_1'], poly_data[output])\n plt.plot(x[:, 0], model.predict(x), c='red')\n plt.figure(num_figure).show()\n plt.pause(pause_plotting_time)\n\n # compute rss:\n train_rss = get_residual_sum_squares(y, model.predict(x))\n # compute rss on validation set:\n if valid_data is None:\n # Then we don't need validation_rss:\n validation_rss = None\n else:\n poly_data_valid = polynomial_dataframe(valid_data[feature], order)\n poly_data_valid[output] = valid_data[output]\n\n x_valid = np.array(poly_data_valid.iloc[:, :-1])\n y_valid = np.array(poly_data_valid[output]).reshape(-1, 1)\n # get ready validation rss to return:\n validation_rss = get_residual_sum_squares(y_valid, model.predict(x_valid))\n\n return poly_weights, train_rss, validation_rss","def polyfit(dates, levels, p):\n x = matplotlib.dates.date2num(dates)\n\n y = levels\n\n # Using shifted x values, find coefficient of best-fit\n # polynomial f(x) of degree p\n shifted_times = [t-x[0] for t in x]\n p_coeff = np.polyfit(shifted_times, y, p)\n\n # Convert coefficient into a polynomial that can be evaluated\n # e.g. poly(0.3)\n poly = np.poly1d(p_coeff)\n\n return (poly, x[0])","def polyfit(data, tvec, intfun):\n\n posx = intfun(tvec, data[:, 0])\n posz = intfun(tvec, data[:, 1])\n velx = posx.derivative(1)\n velz = posz.derivative(1)\n accx = posx.derivative(2)\n accz = posz.derivative(2)\n\n pos = np.c_[posx(tvec), posz(tvec)]\n vel = np.c_[velx(tvec), velz(tvec)]\n acc = np.c_[accx(tvec), accz(tvec)]\n\n return pos, vel, acc","def fit(self, X):\n raise NotImplementedError","def get_poly_coeff(self, independent, dependent):\n\n try:\n x = self.df_input[[independent]]\n y = self.df_input[[dependent]]\n\n poly = PolynomialFeatures(degree = 2)\n x_poly = poly.fit_transform(x) \n\n model = LinearRegression()\n model.fit(x_poly, y)\n return model.coef_\n except Exception as e:\n print(e)","def fitfunc(self, x, p):\n S = np.zeros(self.npt)\n for i in range(0, len(p), self.maxparm):\n ptyp = self.peakTyp[int(i/self.maxparm)]\n xm = p[i]\n amp = p[i+1]\n w = p[i+2]\n a = p[i+3]\n m = p[i+4]\n if ptyp == 'G':\n # peak type = Gaussian\n S = S + self.gauss(x, xm, amp, w)\n elif ptyp == 'L':\n # peak type = Lorentzian\n S = S + self.lorentz(x, xm, amp, w)\n elif ptyp == 'P':\n # peak type = Pseudo-Voigt\n S = S + self.psVoigt(x, xm, amp, w, m)\n elif ptyp == 'AG':\n # peak type = Asymmetric Gaussian\n S = S + self.agauss(x, xm, amp, w, a)\n elif ptyp == 'AL':\n # peak type = Asymmetric Lorentzian\n S = S + self.alorentz(x, xm, amp, w, a)\n elif ptyp == 'AP':\n # peak type = Asymmetric Pseudo-Voigt\n S = S + self.aPsVoigt(x, xm, amp, w, a, m)\n return S","def partial_fit(self, X):\n return super().partial_fit(X)","def fit_psp(data, search_window, clamp_mode, sign=0, exp_baseline=True, baseline_like_psp=False, refine=True, init_params=None, fit_kws=None, ui=None): \n import pyqtgraph as pg\n prof = pg.debug.Profiler(disabled=True, delayed=False)\n prof(\"args: %s %s %s %s %s %s %s %s\" % (search_window, clamp_mode, sign, exp_baseline, baseline_like_psp, refine, init_params, fit_kws))\n \n if ui is not None:\n ui.clear()\n ui.console.setStack()\n ui.plt1.plot(data.time_values, data.data)\n ui.plt1.addLine(x=search_window[0], pen=0.3)\n ui.plt1.addLine(x=search_window[1], pen=0.3)\n prof('plot')\n\n if fit_kws is None:\n fit_kws = {}\n if init_params is None:\n init_params = {}\n\n method = 'leastsq'\n fit_kws.setdefault('maxfev', 500)\n\n # good fit, slow\n # method = 'Nelder-Mead'\n \n # fit_kws.setdefault('options', {\n # 'maxiter': 300, \n \n # # 'disp': True,\n # })\n \n # good fit\n # method = 'Powell'\n # fit_kws.setdefault('options', {'maxfev': 200, 'disp': True})\n\n # bad fit\n # method = 'CG'\n # fit_kws.setdefault('options', {'maxiter': 100, 'disp': True})\n\n # method = 'L-BFGS-B'\n # fit_kws.setdefault('options', {'maxiter': 100, 'disp': True})\n\n # take some measurements to help constrain fit\n data_min = data.data.min()\n data_max = data.data.max()\n data_mean = data.mean()\n \n baseline_mode = float_mode(data.time_slice(None, search_window[0]).data)\n \n # set initial conditions depending on whether in voltage or current clamp\n # note that sign of these will automatically be set later on based on the \n # the *sign* input\n if clamp_mode == 'ic':\n amp_init = init_params.get('amp', .2e-3)\n amp_max = min(100e-3, 3 * (data_max-data_min))\n rise_time_init = init_params.get('rise_time', 5e-3)\n decay_tau_init = init_params.get('decay_tau', 50e-3)\n exp_tau_init = init_params.get('exp_tau', 50e-3)\n exp_amp_max = 100e-3\n elif clamp_mode == 'vc':\n amp_init = init_params.get('amp', 20e-12)\n amp_max = min(500e-12, 3 * (data_max-data_min))\n rise_time_init = init_params.get('rise_time', 1e-3)\n decay_tau_init = init_params.get('decay_tau', 4e-3)\n exp_tau_init = init_params.get('exp_tau', 4e-3)\n exp_amp_max = 10e-9\n else:\n raise ValueError('clamp_mode must be \"ic\" or \"vc\"')\n\n # Set up amplitude initial values and boundaries depending on whether *sign* are positive or negative\n if sign == -1:\n amp = (-amp_init, -amp_max, 0)\n elif sign == 1:\n amp = (amp_init, 0, amp_max)\n elif sign == 0:\n amp = (0, -amp_max, amp_max)\n else:\n raise ValueError('sign must be 1, -1, or 0')\n \n # initial condition, lower boundary, upper boundary\n base_params = {\n 'yoffset': (init_params.get('yoffset', baseline_mode), data_min, data_max),\n 'rise_time': (rise_time_init, rise_time_init/10., rise_time_init*10.),\n 'decay_tau': (decay_tau_init, decay_tau_init/10., decay_tau_init*10.),\n 'rise_power': (2, 'fixed'),\n 'amp': amp,\n }\n \n # specify fitting function and set up conditions\n psp = StackedPsp()\n if exp_baseline:\n if baseline_like_psp:\n exp_min = 0 if sign == 1 else -exp_amp_max \n exp_max = 0 if sign == -1 else exp_amp_max \n base_params['exp_tau'] = 'decay_tau'\n else:\n exp_min = -exp_amp_max \n exp_max = exp_amp_max \n base_params['exp_tau'] = (exp_tau_init, exp_tau_init / 10., exp_tau_init * 20.)\n base_params['exp_amp'] = (0.01 * sign * amp_init, exp_min, exp_max)\n else:\n base_params.update({'exp_amp': (0, 'fixed'), 'exp_tau': (1, 'fixed')})\n \n # print(clamp_mode, base_params, sign, amp_init)\n \n # if weight is None: #use default weighting\n # weight = np.ones(len(y))\n # else: #works if there is a value specified in weight\n # if len(weight) != len(y):\n # raise Exception('the weight and array vectors are not the same length') \n # fit_kws['weights'] = weight\n\n # Round 1: coarse fit\n\n # Coarse search xoffset\n n_xoffset_chunks = max(1, int((search_window[1] - search_window[0]) / 1e-3))\n xoffset_chunks = np.linspace(search_window[0], search_window[1], n_xoffset_chunks+1)\n xoffset = [{'xoffset': ((a+b)/2., a, b)} for a,b in zip(xoffset_chunks[:-1], xoffset_chunks[1:])]\n \n prof('prep for coarse fit')\n\n # Find best coarse fit \n search = SearchFit(psp, [xoffset], params=base_params, x=data.time_values, data=data.data, fit_kws=fit_kws, method=method)\n for i,result in enumerate(search.iter_fit()):\n pass\n # prof(' coarse fit iteration %d/%d: %s %s' % (i, len(search), result['param_index'], result['params']))\n fit = search.best_result.best_values\n prof(\"coarse fit done (%d iter)\" % len(search))\n\n if ui is not None:\n br = search.best_result\n ui.plt1.plot(data.time_values, br.best_fit, pen=(0, 255, 0, 100))\n\n if not refine:\n return search.best_result\n\n # Round 2: fine fit\n \n # Fine search xoffset\n fine_search_window = (max(search_window[0], fit['xoffset']-1e-3), min(search_window[1], fit['xoffset']+1e-3))\n n_xoffset_chunks = max(1, int((fine_search_window[1] - fine_search_window[0]) / .2e-3))\n xoffset_chunks = np.linspace(fine_search_window[0], fine_search_window[1], n_xoffset_chunks + 1)\n xoffset = [{'xoffset': ((a+b)/2., a, b)} for a,b in zip(xoffset_chunks[:-1], xoffset_chunks[1:])]\n\n # Search amp / rise time / decay tau to avoid traps\n rise_time_inits = base_params['rise_time'][0] * 1.2**np.arange(-1,6)\n rise_time = [{'rise_time': (x,) + base_params['rise_time'][1:]} for x in rise_time_inits]\n\n decay_tau_inits = base_params['decay_tau'][0] * 2.0**np.arange(-1,2)\n decay_tau = [{'decay_tau': (x,) + base_params['decay_tau'][1:]} for x in decay_tau_inits]\n\n search_params = [\n rise_time, \n decay_tau, \n xoffset,\n ]\n \n # if 'fixed' not in base_params['exp_amp']:\n # exp_amp_inits = [0, amp_init*0.01, amp_init]\n # exp_amp = [{'exp_amp': (x,) + base_params['exp_amp'][1:]} for x in exp_amp_inits]\n # search_params.append(exp_amp)\n\n # if no sign was specified, search from both sides \n if sign == 0:\n amp = [{'amp': (amp_init, -amp_max, amp_max)}, {'amp': (-amp_init, -amp_max, amp_max)}]\n search_params.append(amp)\n\n prof(\"prepare for fine fit %r\" % base_params)\n\n # Find best fit \n search = SearchFit(psp, search_params, params=base_params, x=data.time_values, data=data.data, fit_kws=fit_kws, method=method)\n for i,result in enumerate(search.iter_fit()):\n pass\n prof(' fine fit iteration %d/%d: %s %s' % (i, len(search), result['param_index'], result['params']))\n fit = search.best_result\n prof('fine fit done (%d iter)' % len(search))\n\n return fit","def evaluate_poly(poly, x):\n value_of_poly = 0\n for i in range(0, len(poly)):\n var = x\n power = i\n coeff = poly[i]\n value_of_poly += (coeff * (var**power))\n return value_of_poly","def fitPolynomialAnalytically(\n deg, datapoints, crossCheckWithTGraphErrors = False):\n import ROOT, math\n from ROOT import Math, TMath, TGraphErrors, TF1\n ncoeffpol = deg + 1\n # check with ROOT's TGraphErrors, if caller wants us to\n if crossCheckWithTGraphErrors:\n gr = TGraphErrors(len(datapoints))\n i = 0\n for dp in datapoints:\n x, y, sigma = dp[0], dp[1], dp[2]\n gr.SetPoint(i, x, y)\n gr.SetPointError(i, 0., sigma)\n i = i + 1\n funcstr = '0'\n for i in xrange(0, ncoeffpol):\n funcstr = funcstr + ('+[%d]*x**%d' % (i, i))\n func = TF1('func', funcstr)\n print ''\n print 'RESULT OF PLAIN ROOT FIT TO TGRAPHERRORS'\n gr.Fit(func)\n # accumulate data points\n icov = ROOT.Math.SMatrix('double', ncoeffpol, ncoeffpol,\n ROOT.Math.MatRepSym('double', ncoeffpol))()\n rhs = ROOT.Math.SVector('double', ncoeffpol)()\n for dp in datapoints:\n x, y, sigma = dp[0], dp[1], dp[2]\n for i in xrange(0, ncoeffpol):\n rhs[i] += y * pow(x, i) / pow(sigma, 2)\n for j in xrange(0, i + 1):\n icov[i, j] = icov(i, j) + pow(x, i + j) / pow(sigma, 2)\n # data point for analytical fit accumulated\n # solve analytical fit\n cov = ROOT.Math.SMatrix('double', ncoeffpol, ncoeffpol,\n ROOT.Math.MatRepSym('double', ncoeffpol))(icov)\n if (not cov.InvertChol()):\n print (\"ERROR: analytical fit for calibration parameters ' + \\\n 'failed - HESSE matrix singular or with negative eigenvalues!\")\n return {}\n sol = ROOT.Math.SVector('double', ncoeffpol)()\n # python isn't smart enough to get the SMatrix matrix-vector\n # multiply, so we do it by hand...\n for i in xrange(0, ncoeffpol):\n tmp = 0.\n for j in xrange(0, ncoeffpol):\n tmp += cov(i, j) * rhs(j)\n sol[i] = tmp \n # work out number of degrees of freedom\n ndf = len(datapoints) - ncoeffpol\n # get chi2\n chi2 = 0.\n for dp in datapoints: # sum over measurements i\n x, y, sigma = dp[0], dp[1], dp[2]\n # evaluate om = sum_k p_k x^k\n yy = 0.\n for i in xrange(0, ncoeffpol):\n yy += sol(ncoeffpol - 1 - i)\n if i != ncoeffpol - 1:\n yy *= x\n # chi2 += ((yy - y) / sigma_i) ^ 2\n chi2 += pow((yy - y) / sigma, 2)\n # print result\n print ''\n print ('FIT RESULT OF ANALYTICAL FIT: CHI^2 %f NDF %d '\n 'CHI^2/NDF %f PROB %f') % (chi2, ndf, chi2 / float(ndf),\n ROOT.TMath.Prob(chi2, ndf))\n print ''\n for i in xrange(0, ncoeffpol):\n print '%10s = %f +/- %f' % ('p%d' % i, sol(i),\n math.sqrt(cov(i, i)))\n print ''\n print 'CORRELATION MATRIX:'\n for i in xrange(0, ncoeffpol):\n s = ''\n for j in xrange(0, ncoeffpol):\n rho = cov(i, j) / math.sqrt(cov(i, i) * cov(j, j))\n s = s + (' % 6.3f' % rho )\n print s\n # analytical fit all done\n return {\n 'ndf': ndf,\n 'chi2': chi2,\n 'prob': TMath.Prob(chi2, ndf),\n 'polycoeffs': [ sol(i) for i in xrange(0, ncoeffpol) ],\n 'polycoefferrors': [\n math.sqrt(cov(i, i)) for i in xrange(0, ncoeffpol) ],\n 'covariance': [\n [ cov(i, j) for j in xrange(0, ncoeffpol) ]\n for i in xrange(0, ncoeffpol) ],\n 'correlation': [\n [ cov(i, j) / math.sqrt(cov(i, i) * cov(j, j))\n for j in xrange(0, ncoeffpol) ]\n for i in xrange(0, ncoeffpol) ]\n }","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def fit(self, X, y=...):\n ...","def defining_polynomial(self):\n return self.defining_polynomials()[0]","def defining_polynomial(self):\n return self.defining_polynomials()[0]","def fit(init_params, data):\n snrs, ras, decs = data.transpose()\n errorfunction = lambda p: np.ravel(observed_snr(*p)(ras, decs) - snrs)\n if debug:\n output = opt.leastsq(errorfunction, init_params, maxfev=10000, full_output=1)\n print output[-1], output[-2]\n p = output[0]\n else:\n p, success = opt.leastsq(errorfunction, init_params, maxfev=10000)\n return p","def _reform_poly_coefficients(fit_poly_x, fit_poly_y):\n # Extract values for CD matrix and recombining\n c11 = fit_poly_x.c1_0.value\n c12 = fit_poly_x.c0_1.value\n c21 = fit_poly_y.c1_0.value\n c22 = fit_poly_y.c0_1.value\n sip_poly_x = fit_poly_x.copy()\n sip_poly_y = fit_poly_y.copy()\n # Force low order coefficients to be 0 as defined in SIP\n sip_poly_x.c0_0 = 0\n sip_poly_y.c0_0 = 0\n sip_poly_x.c1_0 = 0\n sip_poly_x.c0_1 = 0\n sip_poly_y.c1_0 = 0\n sip_poly_y.c0_1 = 0\n\n cdmat = ((c11, c12), (c21, c22))\n invcdmat = npla.inv(np.array(cdmat))\n degree = fit_poly_x.degree\n # Now loop through all remaining coefficients\n for i in range(0, degree + 1):\n for j in range(0, degree + 1):\n if (i + j > 1) and (i + j < degree + 1):\n old_x = getattr(fit_poly_x, f'c{i}_{j}').value\n old_y = getattr(fit_poly_y, f'c{i}_{j}').value\n newcoeff = np.dot(invcdmat, np.array([[old_x], [old_y]]))\n setattr(sip_poly_x, f'c{i}_{j}', newcoeff[0, 0])\n setattr(sip_poly_y, f'c{i}_{j}', newcoeff[1, 0])\n\n return cdmat, sip_poly_x, sip_poly_y","def solve(self):\r\n try:\r\n self.a_values_list.delete(0, tk.END)\r\n self.solved = False\r\n\r\n degree = int(self.degree_entry.get())\r\n self.a_values = FindPolynomialLeastSquaresFit(self.points, degree)\r\n\r\n # Display the As.\r\n for k in range(len(self.a_values)):\r\n self.a_values_list.insert(tk.END, f\"A[{k}] = {self.a_values[k]}\")\r\n self.solved = True\r\n except Exception as e:\r\n messagebox.showinfo(\"Error\", str(e))\r\n\r\n self.draw()","def fit_polynomial(self,x,t,m,lambda_reg=0):\n\n phi = self.designMatrix(x,m)\n phi_trans = np.transpose(phi)\n\n a = phi_trans.dot(phi) + lambda_reg*np.identity(phi.shape[1])\n b = np.linalg.inv(a)\n c = b.dot(phi_trans)\n\n w_ml = c.dot(t)\n\n return w_ml, phi","def poly(x, y, pd) :\n # Maximum polynomial degree allowed is 7.\n maxD = 7\n if pd > maxD :\n exit(\"Please choose a reasonable polynomial degree (0 <= pd <= \" + maxD + \").\")\n \n # Make the polynomial matrix one degree at a time.\n p = np.zeros((len(x), int((pd+1)*(pd+2)/2)), float)\n count = 0\n numP = 0\n for i in range(pd + 1) :\n for j in range(numP + 1) :\n if (j == 0) and (numP == 0) :\n p[:,count] = 1\n elif (j == 0) :\n p[:,count] = x**(numP-j)\n elif (numP-j == 0) :\n p[:,count] = y**j\n else :\n p[:,count] = x**(numP-j) * y**j\n count += 1\n numP += 1\n \n return p","def find_period(ticks, expected_period):\n best_slope = 1\n best_p = 1\n for p in np.linspace(expected_period - 5, expected_period + 5, 2000):\n slope, intercept, rval, pval, stderr = linregress(ticks/p, ticks % p)\n if stderr + abs(slope) < abs(best_slope): # search for a fit with zero slope and low error\n best_slope = stderr + abs(slope)\n best_p = p\n return best_p","def linesearch(f, x0, J0, g0, a, amax, mu1, mu2, p):\r\n J, g, a = bracketing(f, x0, J0, g0, a, amax, mu1, mu2, p)\r\n x = x0+a*p\r\n return x, J, g, a","def linear_fit(x, y):\n x = np.array(x)\n y = np.array(y)\n \n invalid_idx = np.isnan(x) | np.isinf(x) | np.isnan(y) | np.isinf(y)\n x = x[~invalid_idx]\n y = y[~invalid_idx]\n\n covs = sm.add_constant(x, prepend=True)\n model = sm.OLS(y, covs)\n result = model.fit()\n return result.params, result.rsquared","def __test_s_polynomial():\n poly_ring = PolynomialRing(QQ, 'x,y', order='deglex')\n x, y = poly_ring('x'), poly_ring('y')\n g = x ** 3 - 2 * x * y\n h = x ** 2 * y - 2 * y ** 2 + x\n print __s_polynomial(g, h) # Expected -x^2","def _regressor_partial_fit(X, y, js_model, n_iter):\n\n X_is_sparse = sp.issparse(X)\n y_is_sparse = sp.issparse(y)\n\n js_state = libpytsetlini.regressor_partial_fit(\n X, X_is_sparse,\n y, y_is_sparse,\n js_model,\n n_iter)\n\n return js_state"],"string":"[\n \"def get_expected_polynomial_coefs(y, degree, with_intercept=True):\\n poly_matrix = np.vander(np.arange(len(y)), degree + 1)\\n if not with_intercept:\\n poly_matrix = poly_matrix[:, :-1]\\n return np.linalg.lstsq(poly_matrix, y.to_numpy(), rcond=None)[0]\",\n \"def fit_polynomial(self, ym_per_pix, xm_per_pix):\\r\\n\\r\\n # Fit a second order polynomial\\r\\n self.current_fit = np.polyfit(self.ally, self.allx, 2)\\r\\n\\r\\n # Fit a second order polynomial (in meters)\\r\\n current_fit_real = np.polyfit(self.ally * ym_per_pix, self.allx * xm_per_pix, 2)\\r\\n\\r\\n # calculate the curvature (in meters)\\r\\n self.radius_of_curvature = ((1 + (2 * current_fit_real[0] * self.y_eval * ym_per_pix + current_fit_real[1])**2)**1.5) / np.absolute(2 * current_fit_real[0])\\r\\n\\r\\n # flag that a polynomial is found\\r\\n self.detected = True\",\n \"def fit_polynomial_regression(self, x_train, y_train):\\n x_poly = self.poly_reg.fit_transform(x_train)\\n self.lin_reg.fit(x_poly, y_train)\",\n \"def find_coefficients(self):\\n self.make_matrix()\\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition\",\n \"def fit(self, X):\",\n \"def build_poly(x, degree):\\n \\\"\\\"\\\"\\n Assemble the 3 label vectors with the original ordering \\n Inputs:\\n - x (ndarray) : binary prediction for set 1\\n - degree (int) : binary prediction for set 2 \\n Outputs: \\n - p (ndarray) : predicted labels for test set ( with the original ordering)\\n \\\"\\\"\\\"\\n # forming a matrix containing the data points\\n terms = np.hstack([np.ones([x.shape[0],1]),np.tile(x,(1,degree))])\\n index = np.arange(degree)+1\\n \\n # forming a matrix contnaining the exponents\\n exponents = np.multiply(np.ones((1, x.shape[1])), index[:, np.newaxis])\\n exponents = exponents.reshape([1, x.shape[1]*degree])\\n exponents = np.multiply(exponents, np.ones([x.shape[0], 1]))\\n exponents = np.hstack([np.ones( (x.shape[0], 1) ),exponents])\\n \\n # using the exponent matrix as the element-wise exponents of the terms in the terms matrix\\n p=np.power(terms,exponents)\\n return p\",\n \"def non_linear_polynomial_fit(self, seq, factor):\\n B = np.array(seq[1:4])\\n A = np.array([[seq[k], factor ** (k + 1), 1] for k in range(3)])\\n return np.around(np.linalg.solve(A,B), decimals=2)\",\n \"def fit_poly(data, error_func, degree=4): \\n\\n # generate initial guss for polynomial model (all coeffs = 1)\\n guess = np.poly1d(np.ones(degree + 1, dtype=np.float32))\\n\\n # plot intial guess\\n x = np.linspace(-5, 5, 21)\\n plt.plot(x, np.polyval(guess, x), 'm--', linewidth=2.0, label=\\\"Initial guess\\\")\\n\\n # call optimizer to minimize error function\\n result = spo.minimize(error_poly, guess, args=(data,), method='SLSQP', options={'disp':True})\\n \\n # convert optimal result into a poly1d object\\n return np.poly1d(result.x)\",\n \"def polyfit(x, y, yerror, pinit=[0,0,0,0]):\\n x = np.array(x)\\n y = np.array(y)\\n pinit[2] = np.mean(y)\\n pinit[3] = x[len(x)/2]\\n if (type(yerror) != list and type(yerror) != np.ndarray):\\n yerror = np.ones(len(x)) * yerror\\n fitfunc = lambda p, x: p[2] + p[1]*(x-p[3]) + p[0]*(x-p[3])**2\\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\\n p = out[0]\\n covar = out[1]\\n return(p)\",\n \"def fit(x, a, p, b):\\n return a * (p ** x) + b\",\n \"def _fit_poly(y_data, deg=5):\\n x = np.arange(1, len(y_data) + 1)\\n coeffs = np.polynomial.polynomial.polyfit(\\n x, y_data, deg=deg)\\n y_pred = poly(x, coeffs)\\n return coeffs, np.mean((y_data - y_pred) ** 2)\",\n \"def best_poly_fit(x_data, y_data, plot_fig=False):\\n\\tcentral_x = np.mean(x_data)\\n\\tmodels = []\\n\\tfor i in xrange(3):\\n\\t\\twith warnings.catch_warnings():\\n\\t\\t\\twarnings.filterwarnings('error')\\n\\t\\t\\ttry: \\n\\t\\t\\t\\tmodels.append(np.polyfit(x_data - central_x, y_data,i +1))\\n\\t\\t\\texcept np.RankWarning:\\n\\t\\t\\t\\tprint \\\"not enought data for %d order\\\" % i\\n\\treduced_chi_squared = []\\n\\tif len(x_data) == 2:\\n\\t\\treduced_chi_squared.append(0.0)\\n\\telse:\\n\\t\\treduced_chi_squared.append(np.sum((np.polyval(models[0],x_data - central_x) - y_data)**2) / (len(y_data) - 1. - 1.))\\n\\t\\treduced_chi_squared.append(np.sum((np.polyval(models[1],x_data - central_x) - y_data)**2) / (len(y_data) - 2. - 1.))\\n\\t\\treduced_chi_squared.append(np.sum((np.polyval(models[2],x_data - central_x) - y_data)**2) / (len(y_data) - 3. - 1.))\\n\\n\\treduced_chi_squared = np.array(reduced_chi_squared)\\n\\n\\t# If there are only 3 data points or less, use 1st order\\n\\tif len(x_data) <= 3:\\n\\t\\tmodel = models[0]\\n\\telse:\\n\\t\\tmin_ind = np.argmin(reduced_chi_squared)\\n\\t\\tmodel = models[min_ind]\\n\\n\\tif plot_fig:\\n\\t\\tfig1 = pl.figure(1)\\n\\t\\tpl.plot(x_data,y_data,'o')\\n\\n\\t\\tmodel_x = np.linspace(np.min(x_data),np.max(x_data), 200)\\n\\t\\tmodel_y = np.polyval(model,model_x - central_x)\\n\\t\\treturn model_x,model_y # return arrays of values to plot. \\n\\telse:\\n\\t\\t# parameters array, and central wavelength\\n\\t\\treturn np.array(model),central_x\",\n \"def fit(self, x):\\n pass\",\n \"def least_sqr_fit(self,x, y):\\n A = np.array([ x, np.ones(len(x))])\\n # linearly generated sequence\\n a,f,g,h = np.linalg.lstsq(A.T,y) # obtaining the parameters\\n print 'de gevonden rechte = %.10f x + %.10f' %(a[0], a[1])\\n lined = map(lambda g: a[0]*g +a[1],x) # regression line\\n return lined , a\",\n \"def linearfit(x,y):\\n fit = np.polyfit(x,y,1)\\n fit_fn = np.poly1d(fit)\\n yy = fit_fn(x) \\n \\n return yy\",\n \"def polyLS(pd, x, y, f, X, Y \\\\\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\\n \\n numP = int((pd + 1) * (pd + 2) / 2)\\n \\n if (len(xmc) == 1) and (len(ymc) == 1) :\\n \\n\\n if coeff == [] :\\n p = poly(x, y, pd)\\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\\n\\n B = poly(X, Y, pd)\\n approx = B.dot(coeff).flatten()\\n coeff_copy = coeff\\n \\n else :\\n \\n approx = np.zeros(len(X), float)\\n \\n if coeff == [] :\\n for i in range(len(xmc)) :\\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\\n if len(IND) < int(1.5 * numP) :\\n raise ValueError(\\\"Not enough data for this polynomial \\\" \\\\\\n + \\\"degree.\\\\nEither lower the polynomial degree or \\\" \\\\\\n + \\\"decrease the number of subdivisions.\\\")\\n p = poly(x[IND], y[IND], pd)\\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\\n coeff.append(lam)\\n\\n coeff_copy = coeff.copy()\\n\\n for i in range(len(xmc) - 1, -1, -1) :\\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\\n B = poly(X[IND], Y[IND], pd)\\n lam = coeff.pop()\\n approx[IND] = B.dot(lam).flatten()\\n \\n return approx, coeff_copy\",\n \"def get_polyfit_function(self):\\n N = len(self.coefficients)\\n return lambda x: np.dot( self.get_poly(x).T , self.coefficients.reshape(N, 1) )\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def fit(self, X, y):\",\n \"def evaluate_polynomial(f,x):\\n degree = len(f)-1\\n ans = 0\\n for i in f:\\n ans += i*x**degree\\n degree -= 1\\n return(ans)\",\n \"def polyFeat(X, p):\\r\\n # You need to return the following variables correctly.\\r\\n X_poly = np.zeros((X.shape[0], p))\\r\\n\\r\\n # ====================== YOUR CODE HERE ======================\\r\\n\\r\\n for i in range(p):\\r\\n X_poly[:, i] = X[:, 0] ** (i + 1)\\r\\n\\r\\n # ============================================================\\r\\n return X_poly\",\n \"def fit():\\n pass\",\n \"def _linesearch_powell(func, p, xi, tol=1e-3):\\n def myfunc(alpha):\\n return func(p + alpha * xi)\\n alpha_min, fret, iter, num = optimize.brent(myfunc, full_output=1, tol=tol)\\n xi = alpha_min*xi\\n return squeeze(fret), p+xi, xi\",\n \"def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\\r\\n\\r\\n # replace these lines with your solution\\r\\n initial_T = time.time()\\r\\n\\r\\n def get_points(f, a, b, n):\\r\\n x = np.linspace(a, b, n)\\r\\n y_lst = f(x)\\r\\n y = np.array(y_lst)\\r\\n\\r\\n return x, y\\r\\n\\r\\n def build_vector(x, y, size, deg):\\r\\n if deg == size:\\r\\n y_n = y.sum()\\r\\n else:\\r\\n y_n = np.dot(y, (x ** (size - deg)))\\r\\n pol1 = np.zeros(size + 1)\\r\\n for i in range(size + 1):\\r\\n pol1[i] = (x ** (2 * size - deg - i)).sum()\\r\\n return pol1, y_n\\r\\n\\r\\n def build_coeff_matrix(f, a, b, n, d):\\r\\n x, y = get_points(f, a, b, n)\\r\\n deg = d\\r\\n b = np.array([])\\r\\n coeff_matrix = np.array([])\\r\\n for i in range(d + 1):\\r\\n x_n, y_n = build_vector(x, y, d, i)\\r\\n deg -= 1\\r\\n coeff_matrix = np.append(coeff_matrix, x_n)\\r\\n b = np.append(b, y_n)\\r\\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\\r\\n return coeff_matrix, b\\r\\n\\r\\n def solve_coeff_matrix(coeff_matrix, b):\\r\\n A_inverse = np.linalg.inv(coeff_matrix)\\r\\n coeffs = A_inverse.dot(b)\\r\\n return coeffs\\r\\n\\r\\n def build_function_from_coeffs(coeffs):\\r\\n f = np.poly1d(coeffs)\\r\\n return f\\r\\n\\r\\n n = 100 # fisrt sample size\\r\\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\\r\\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\\r\\n break\\r\\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\\r\\n break\\r\\n result = build_function_from_coeffs(coeffs)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\\r\\n break\\r\\n n += 200 # increasing sample size\\r\\n\\r\\n return result\",\n \"def fit(self, X, y, l2regularize = None ) :\\n\\n X = self.generate_polynomial_features(X) # map features\\n\\n ### ========== TODO : START ========== ###\\n # part e: implement closed-form solution\\n # hint: use np.dot(...) and np.linalg.pinv(...)\\n # be sure to update self.coef_ with your solution\\n X_X_T = np.linalg.pinv(np.dot(X.transpose(),X) + l2regularize*np.identity(np.shape(X.transpose())[0]))\\n self.coef_ = np.dot(X_X_T,np.dot(X.transpose(),y))\\n\\n\\n ### ========== TODO : END ========== ###\\n\\n return self\",\n \"def poly_regression(self,precision=8):\\n # return empty lists if input is empty\\n if self.training == []:\\n return [],[]\\n\\n latitudes = []\\n longitudes = []\\n for point in self.training[:-1]:\\n latitudes.append(point[0])\\n longitudes.append(point[1]) \\n # store everything in a dataframe\\n latDf = pd.DataFrame(numpy.array(latitudes), columns=['latitudes'])\\n longDf = pd.DataFrame(numpy.array(longitudes), columns=['longitudes'])\\n\\n # learn how to do regression\\n reg = linear_model.LinearRegression()\\n\\n # pass the order of your polynomial here \\n poly = PolynomialFeatures(precision)\\n\\n \\n # regression with latitude as domain\\n vertical_predicted_path = []\\n transform = poly.fit_transform(longDf)\\n\\n reg.fit(transform,latDf)\\n predictions = reg.predict(transform)\\n\\n for i in range(len(predictions)):\\n vertical_predicted_path.append([predictions[i][0],longDf[\\\"longitudes\\\"][i]])\\n\\n \\n # regression with longitude domain\\n horizontal_predicted_path = []\\n transform = poly.fit_transform(latDf)\\n\\n reg.fit(transform,longDf)\\n predictions = reg.predict(transform)\\n\\n for i in range(len(predictions)):\\n horizontal_predicted_path.append([latDf[\\\"latitudes\\\"][i], predictions[i][0]])\\n\\n self.horizontal = sorted(horizontal_predicted_path, key=lambda k: [k[1], k[0]])\\n self.vertical = sorted(vertical_predicted_path, key=lambda k: [k[0], k[1]])\\n \\n # return sorted horizontal and vertical prediction\\n return self.horizontal, self.vertical\",\n \"def regression(df_tot, fasit_key, chosen, max_p):\\n\\n with np.errstate(divide='ignore'):\\n # First regression\\n first_model = sm.OLS(df_tot[fasit_key], df_tot[chosen])\\n\\n # Initializing loop\\n results = first_model.fit()\\n chosen_p = chosen.copy()\\n ant_break = 0\\n\\n # Looping through until final model is chosen\\n while max(results.pvalues) > max_p or len(results.pvalues) >= max_final_numb_kandidater:\\n if len(results.pvalues) <= min_kandidater:\\n ant_break = 1 # count\\n break\\n chosen_p.remove(results.pvalues.idxmax()) # updating the chosen list\\n\\n with np.errstate(divide='ignore'):\\n results = sm.OLS(df_tot[fasit_key], df_tot[chosen_p]).fit() # regression\\n\\n return results, chosen_p, ant_break\",\n \"def fit_data(x, y, flag_thr, deg=9):\\n # Flag sorted data\\n xf, yf = diff_xy(x, y, flag_thr)\\n\\n # Fit polynomial to flagged data\\n p = np.polyfit(xf, yf, deg)\\n p = np.poly1d(p)\\n pg = p(x)\\n\\n return pg\",\n \"def partial_fit(self, X, y=...):\\n ...\",\n \"def partial_fit(self, X, y=...):\\n ...\",\n \"def plotBestFitOfAllData(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True):\\n train(x_samples, y_samples, x_poly, y_poly, order, plotFlag= True) \\n plt.title(\\\"Polynomial function regression\\\")\\n plt.grid()\\n plt.plot(x_poly, y_poly, c='black', label='true function')\\n plt.scatter(x_samples, y_samples, s=20, c='green', label='sample')\\n plt.legend()\\n plt.show()\",\n \"def get_polyfit(self, stack_of_points, uq=False):\\n N = len(self.coefficients)\\n if uq:\\n return np.dot(self.get_poly(stack_of_points).T , self.coefficients.reshape(N, 1)), self._get_polystd(stack_of_points)\\n else:\\n return np.dot(self.get_poly(stack_of_points).T , self.coefficients.reshape(N, 1))\",\n \"def fit(self):\\n\\n fitdata = np.polyfit(self.v**(-2./3.), self.e, 3, full=True)\\n ssr = fitdata[1]\\n sst = np.sum((self.e - np.average(self.e))**2.)\\n residuals0 = ssr/sst\\n deriv0 = np.poly1d(fitdata[0])\\n deriv1 = np.polyder(deriv0, 1)\\n deriv2 = np.polyder(deriv1, 1)\\n deriv3 = np.polyder(deriv2, 1)\\n\\n self.v0 = None\\n for x in np.roots(deriv1):\\n if x > 0 and deriv2(x) > 0:\\n self.v0 = x**(-3./2.)\\n break\\n\\n if self.v0 is None:\\n raise ValueError('No minimum!')\\n\\n derivV2 = 4./9. * x**5. * deriv2(x)\\n derivV3 = (-20./9. * x**(13./2.) * deriv2(x) -\\n 8./27. * x**(15./2.) * deriv3(x))\\n bulk_modulus0 = derivV2 / x**(3./2.)\\n bulk_deriv0 = -1 - x**(-3./2.) * derivV3 / derivV2\\n\\n self.e0 = deriv0(x)\\n self.B0 = bulk_modulus0\\n self.B1 = bulk_deriv0\\n\\n return self.v0, self.e0, self.B0, self.B1, residuals0\",\n \"def regression_fit(self, x, y, deg):\\n return np.polyfit(x, y, deg=deg)\",\n \"def fit_poly(x, y, n=5, log=False):\\n \\n x_g = x\\n x = np.ma.array(x, mask=y.mask).compressed()\\n y = y.compressed()\\n if log:\\n yl = np.log10(y)\\n else:\\n yl = y\\n fit = np.polyfit(x, yl, n)\\n p = np.poly1d(fit)\\n \\n if log:\\n return 10**(p(x_g))\\n else:\\n return p(x_g)\",\n \"def poly_regression_cubic(X, Y, Xs_test, Ys_test):\\n ## YOUR CODE HERE\\n #################\\n return 0\",\n \"def fit(self, X,y):\\n pass\",\n \"def polyfit_2d(Xu,X):\\n\\txu = Xu[:,0]\\n\\tyu = Xu[:,1]\\n\\tX = np.squeeze(X) # an mx1 vector\\n\\tM = np.squeeze((np.ones(xu.size),xu,yu,xu**2,xu*yu,yu**2,\\n\\t\\txu**3,xu**2*yu,xu*yu**2,yu**3)) # a mxn matrix\\n\\tM = M.transpose()\\n\\tprint(\\\"solving for the polynomial fitting coefficients...\\\")\\n\\tK,resid,rnk,svs = np.linalg.lstsq(M,X,rcond=-1) # k has size n\\n\\tprint(\\\"residue:%0.8f\\trank:%0.8f\\\"%(np.sum(resid),rnk))\\n\\treturn K\",\n \"def fit(self, pressure, loading, param_guess, optimization_params=None, verbose=False):\\n if verbose:\\n logger.info(f\\\"Attempting to model using {self.name}\\\")\\n\\n # parameter names (cannot rely on order in Dict)\\n param_names = [param for param in self.params]\\n guess = numpy.array([param_guess[param] for param in param_names])\\n bounds = [[self.param_bounds[param][0] for param in param_names],\\n [self.param_bounds[param][1] for param in param_names]]\\n\\n # remove invalid values in function\\n zero_values = ~numpy.logical_and(pressure > 0, loading > 0)\\n if any(zero_values):\\n logger.warning('Removed points which are equal to 0.')\\n pressure = pressure[~zero_values]\\n loading = loading[~zero_values]\\n\\n # define fitting function as polynomial transformed input\\n ln_p_over_n = numpy.log(numpy.divide(pressure, loading))\\n\\n # add point\\n add_point = False\\n added_point = False\\n if optimization_params:\\n add_point = optimization_params.pop('add_point', None)\\n fractional_loading = loading / max(loading)\\n if len(fractional_loading[fractional_loading < 0.5]) < 3:\\n if not add_point:\\n raise CalculationError(\\n \\\"\\\"\\\"\\n The isotherm recorded has very few points below 0.5\\n fractional loading. If a virial model fit is attempted\\n the resulting polynomial will likely be unstable in the\\n low loading region.\\n\\n You can pass ``add_point=True`` in ``optimization_params``\\n to attempt to add a point in the low pressure region or\\n record better isotherms.\\n \\\"\\\"\\\"\\n )\\n added_point = True\\n ln_p_over_n = numpy.hstack([ln_p_over_n[0], ln_p_over_n])\\n loading = numpy.hstack([1e-1, loading])\\n\\n def fit_func(x, L, ln_p_over_n):\\n for i, _ in enumerate(param_names):\\n self.params[param_names[i]] = x[i]\\n return self.params['C'] * L**3 + self.params['B'] * L**2 \\\\\\n + self.params['A'] * L - numpy.log(self.params['K']) - ln_p_over_n\\n\\n kwargs = dict(\\n fun=fit_func, # fitting function\\n x0=guess, # initial guess\\n bounds=bounds, # bounds of the parameters\\n args=(loading, ln_p_over_n), # extra arguments to the fit function\\n # loss='huber', # use a loss function against outliers\\n # f_scale=0.1, # scale of outliers\\n )\\n if optimization_params:\\n kwargs.update(optimization_params)\\n\\n opt_res = self.fit_leastsq(kwargs)\\n\\n # assign params\\n for index, _ in enumerate(param_names):\\n self.params[param_names[index]] = opt_res.x[index]\\n\\n self.rmse = numpy.sqrt(numpy.sum((opt_res.fun)**2) / len(loading))\\n\\n if verbose:\\n logger.info(f\\\"Model {self.name} success, RMSE is {self.rmse:.4g}\\\")\\n n_load = numpy.linspace(1e-2, numpy.amax(loading), 100)\\n virial_plot(\\n loading, ln_p_over_n, n_load,\\n numpy.log(numpy.divide(self.pressure(n_load), n_load)), added_point\\n )\",\n \"def smooth(x, y, PLOT=False, **kwargs):\\n assert len(x) == len(y)\\n x = np.array(x)\\n y = np.array(y)\\n\\n # do a grid search to find the optimal polynomial degree\\n model = GridSearchCV(\\n # use a linear model with polynomial features\\n sklearn.pipeline.Pipeline([\\n ('poly', sklearn.preprocessing.PolynomialFeatures(degree=3)),\\n ('linear', sklearn.linear_model.LinearRegression())\\n ]),\\n cv=kwargs.get('cv', min(5, len(x))),\\n param_grid={\\n 'poly__degree': np.arange(\\n kwargs.get('min_degree', 3),\\n kwargs.get('max_degree', 14),\\n 2\\n )\\n }\\n )\\n x = x.reshape(-1, 1)\\n model.fit(x, y)\\n\\n def predict(_x):\\n return model.predict(np.array(_x).reshape(-1, 1))\\n\\n if PLOT:\\n yhat = predict(x)\\n fig, ax = plt.subplots(1, 1)\\n ax.plot(x, yhat, 'k--')\\n ax.plot(x, y, 'ko')\\n ax.set(xlabel='x', ylabel='y')\\n sns.despine()\\n return predict, fig, ax\\n if kwargs.get('PRINT'):\\n print(model)\\n return predict\",\n \"def _lin_regress(self, y, x, bias=True):\\n n_samples = x.shape[0]\\n x = self.make_polynomial(x[:, np.newaxis], fit_intercept=bias)\\n l = np.linalg.cholesky(x.T @ x)\\n v = solve_triangular(l, x.T @ y, lower=True)\\n coefs = solve_triangular(l.T, v)\\n pred = x @ coefs\\n resid = y - pred\\n rss = resid @ resid\\n ddof = n_samples - (1 + bias)\\n return rss, ddof\",\n \"def get_poly(kwargs):\\n from sklearn.preprocessing import PolynomialFeatures\\n return PolynomialFeatures(**kwargs)\",\n \"def __find_psi__(self):\\r\\n\\r\\n # Get data to fit the model\\r\\n x = self.train_x\\r\\n y = self.train_y\\r\\n\\r\\n # Initialize model parameters\\r\\n psi = self.__initialize_psi__()\\r\\n alpha = 0. # slope of the first segment is constrained to be zero\\r\\n beta = 10.\\r\\n gamma = 10.\\r\\n psi_p = np.inf\\r\\n\\r\\n # Max iterations (arbitrary choise)\\r\\n i = 1000\\r\\n\\r\\n # Iterative fit, stopping condition on gamma\\r\\n while abs(gamma) > 1e-2:\\r\\n self.psi = psi\\r\\n # Fitting procedure from [1]\\r\\n u = self.__Us__(x)\\r\\n v = self.__Vs__(x)\\r\\n c = np.ones_like(x)\\r\\n A = np.vstack([u, v, c]).T\\r\\n beta, gamma, intercept = np.linalg.lstsq(A, y)[0]\\r\\n psi_p = psi\\r\\n psi = psi + gamma / beta\\r\\n\\r\\n # Re-initialize breakpoint (psi) if it leaves the data's domain\\r\\n if psi > np.max(x) or psi < np.min(x):\\r\\n psi = self.__initialize_psi__()\\r\\n\\r\\n # Decrement iterations\\r\\n i -= 1\\r\\n\\r\\n # Give up if stopping condition not met after max iterations\\r\\n if i < 0:\\r\\n print('Max iteration reached, no breakpoint found')\\r\\n # Since no solution, put \\\"breakpoint\\\" at the end of the data\\r\\n beta = 0.\\r\\n gamma = 0.\\r\\n psi = np.max(x)\\r\\n intercept = np.mean(y)\\r\\n break\\r\\n\\r\\n if i >= 0:\\r\\n print('Found breakpoint at x = ' + str(psi))\\r\\n\\r\\n # Store the result of the fit\\r\\n self.alpha = alpha\\r\\n self.beta = beta\\r\\n self.gamma = gamma\\r\\n self.psi = psi\\r\\n self.intercept = intercept\",\n \"def fit(self, x):\\n raise NotImplementedError()\",\n \"def fit(self, X, Y):\\n ...\",\n \"def coef_approximation(p, order):\\n\\n\\t# maintain parity of order +1\\n\\tn = 50 + order +1\\n\\tr = 1\\n\\txs = np.linspace(-r, r, num=n)\\n\\tys = p(xs)\\n\\n\\t# [TODO]: fix coeffients method\\n\\t# replace with 'c = coeffients(xs, ys)'\\n\\tdegree = n \\n\\tc = np.polyfit(xs,ys,degree)\\n\\n\\treturn c\",\n \"def polyfit(dates, levels, p):\\n assert isinstance(p, int) and p > 0, f\\\"{p} is not a positive integer\\\"\\n\\n x = matplotlib.dates.date2num(dates)\\n y = levels\\n try:\\n # Find coefficients of best-fit polynomial f(x) of degree p\\n p_coeff = np.polyfit(x - x[0], y, p)\\n # Convert coefficient into a polynomial that can be evaluated\\n poly = np.poly1d(p_coeff)\\n # Returns a 1D polynomial and time-axis shift\\n return poly, x[0]\\n except TypeError:\\n # workaround to handle unexpected numpy polyfit errors\\n return None, x[0]\",\n \"def fitfunc(x_unshifted, p=default()):\\n x = x_unshifted+p[4]\\n xtr, ytr, gradtr = logcontinuity(p)\\n if x < xtr:\\n return logpeak(x, p)\\n else:\\n return logpowerlaw(x, p)\",\n \"def __getPolynomial(self) -> 'func':\\n return lambda x: sum(self.pts[i]*base(x)\\n for i, base in enumerate(self.basis))\",\n \"def fit(self, X, y=None):\\n #import pdb\\n #pdb.set_trace()\\n return self.partial_fit(X, y)\",\n \"def linfit(x, y, yerror, pinit=[0,0]):\\n x = np.array(x)\\n y = np.array(y)\\n if (type(yerror) != list and type(yerror) != np.ndarray):\\n yerror = np.ones(len(x)) * yerror\\n fitfunc = lambda p, x: p[1] + p[0]*x\\n errfunc = lambda p,x,y,err: (y-fitfunc(p,x))/(err**2)\\n out = scipy.optimize.leastsq(errfunc, pinit, args=(x,y,yerror/y), full_output=1)\\n p = out[0]\\n covar = out[1]\\n return(p)\",\n \"def _fit_point_lens(self):\\n\\n def chi2_fun(theta, event, parameters_to_fit):\\n \\\"\\\"\\\"\\n for a given event set attributes from parameters_to_fit\\n (list of str) to values from theta list\\n \\\"\\\"\\\"\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n chi2 = event.get_chi2()\\n if chi2 < chi2_fun.best_chi2:\\n chi2_fun.best_chi2 = chi2\\n return chi2\\n chi2_fun.best_chi2 = 1.e10\\n\\n def jacobian(theta, event, parameters_to_fit):\\n \\\"\\\"\\\"\\n Calculate chi^2 gradient (also called Jacobian).\\n \\\"\\\"\\\"\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n return event.chi2_gradient(parameters_to_fit)\\n\\n if self._event_PSPL is None:\\n self._set_event_PSPL()\\n\\n parameters_to_fit = [\\\"t_0\\\", \\\"u_0\\\", \\\"t_E\\\"]\\n initial_guess = [self._parameters[p] for p in parameters_to_fit]\\n\\n failed = False\\n try:\\n result = op.minimize(\\n chi2_fun, x0=initial_guess,\\n args=(self._event_PSPL, parameters_to_fit),\\n method='Newton-CG', jac=jacobian, tol=3.e-4)\\n except:\\n failed = True\\n\\n if failed:\\n try:\\n result = op.minimize(\\n chi2_fun, x0=initial_guess,\\n args=(self._event_PSPL, parameters_to_fit),\\n method='Newton-CG', jac=jacobian, tol=3.e-4)\\n except:\\n pass\\n# XXX what if fit failed (i.e., .success is False)?\\n\\n self._LSST_PSPL_chi2 = chi2_fun.best_chi2\",\n \"def residuals(self, p, data, X):\\n err = data - self.fitfunc(X,p)\\n return err\",\n \"def pol_evl(x, coef, N):\\n ans = coef[0]\\n for i in range(1, N + 1):\\n ans = ans * x + coef[i]\\n return ans\",\n \"def linfit(x, y, sigma_y):\\n npar = 2 #Number of fitting parameters. If we were doing ax^2 + bx + c then npar = 3\\n npts = len(x) #Number of data points\\n\\n if npts < npar:\\n print(\\\"Not enough data points to fit a first order polynomial\\\")\\n return\\n\\n if npts != len(y) or npts != len(sigma_y):\\n print(\\\"Lengths of the inputs must be the same. len(x) = {}, len(y) = {},\\\"\\n \\\"len(sigma_y) = {}\\\".format(len(x),len(y), len(sigma_y)))\\n return\\n\\n #Make sure everything is a np.array that'll make the math easier\\n x = np.array(x)\\n y = np.array(y)\\n sigma_y = np.array(sigma_y)\\n\\n sw = sum(1 / sigma_y**2)\\n sy = sum(y / sigma_y**2)\\n sx = sum(x / sigma_y**2)\\n sx2= sum((x / sigma_y)**2)\\n sxy= sum((y*x / sigma_y)**2)\\n\\n #Find the fit parameters\\n Delta = sw*sx2 - sx**2\\n a = (sx2*sy - sx*sxy)/Delta\\n b = (sxy*sw - sx*sy)/Delta\\n da = np.sqrt(sx2 / Delta)\\n db = np.sqrt(sw / Delta)\\n\\n fit = a + b*x\\n chi2 = sum(((y - fit) / sigma_y)**2)\\n if npts > npar:\\n chi2red = chi2 / (npts - npar)\\n else:\\n chi2red = 0\\n\\n return [a, da, b, db, chi2red]\",\n \"def fit(self, x, y):\\r\\n\\r\\n self.train_x = x\\r\\n self.train_y = y\\r\\n self.__find_psi__()\",\n \"def fit(self):\\n raise NotImplementedError\",\n \"def get_fit(self) -> np.poly1d:\\n if self.log_fits is not None:\\n return next(self.log_fits)\\n x = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: [line.point1.y for line in m.marker_lines])\\n .to_list()\\n )\\n y = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: [line.point1.x for line in m.marker_lines])\\n .to_list()\\n )\\n if self.orientation == Orientation.UP_DOWN:\\n fit = np.polyfit(x, y, 1)\\n else:\\n fit = np.polyfit(y, x, 1)\\n return np.poly1d(fit)\",\n \"def polyval(p, x):\\r\\n val = 0\\r\\n ii = len(p) - 1\\r\\n for i in range(len(p) - 1):\\r\\n val += p[i] * (x ** ii)\\r\\n ii -= 1\\r\\n return val + p[-1]\",\n \"def find_poly_root(poly, initial_guess = 0.0, limit = 0.00001, max_iterations = 1000):\\n # Calculate the polynomial derivatives\\n dpoly = polynomial.derivative(poly)\\n ddpoly = polynomial.derivative(dpoly)\\n # Closures !!!\\n f = lambda x: polynomial.eval(poly, x)\\n df = lambda x: polynomial.eval(dpoly, x)\\n ddf = lambda x: polynomial.eval(ddpoly, x)\\n # Call the generic root finder\\n return find_root(f, df, ddf, initial_guess, limit, max_iterations)\",\n \"def get_poly_params(fun: XFunction, x: float, degree: int) -> tuple[float, ...]:\\n if degree < 0:\\n return (0.0,)\\n rhs = np.array([fun(x, order=i) for i in range(degree, -1, -1)])\\n mat = np.zeros((degree + 1, degree + 1))\\n for i in range(degree + 1):\\n for j in range(i + 1):\\n mat[i, j] = factorial(degree - j) / factorial(i - j) * x ** (i - j)\\n return tuple(np.linalg.solve(mat, rhs))\",\n \"def search(y, x, optimize_on=\\\"te_loss\\\", split_method = 'mass'):\\n\\n \\n\\t# split the data (8 model)\\n\\tsplit_train = split.split(y, x, method= split_method)\\n\\n\\t# large range of parameter\\n\\tdegrees = range(2, 15)\\n\\tlambdas = np.logspace(-5, 10)\\n\\n\\n\\tlambdas_star = []\\n\\tdegrees_star = []\\n\\tprint(\\\"start search\\\")\\n\\tfor i, splitted_set in enumerate(split_train):\\n\\t\\tsub_y, sub_x, id_indices = splitted_set\\n\\n\\t\\t# first rough search with large scale\\n\\t\\tlambda_star, degree_star, score = _inner_search(sub_y, sub_x, degrees, lambdas, optimize_on)\\n\\n\\t\\t# zoomed search around best parameters\\n\\t\\t# zoomed_degree = range(degree_star-2, degree_star + 2)\\n\\t\\tzoomed_lambda = np.logspace(lambda_star - 2, lambda_star + 2, 25)\\n\\t\\tlambda_star, degree_star, score = _inner_search(sub_y, sub_x, degrees, zoomed_lambda, optimize_on)\\n\\n\\t\\t# store found values\\n\\t\\tlambdas_star.append(lambda_star)\\n\\t\\tdegrees_star.append(degree_star)\\n\\n\\t\\t# print summary\\n\\t\\tprint(\\\"-------------------------------------\\\")\\n\\t\\tprint(\\\"Set\\\", i)\\n\\t\\tprint(\\\"-------------------------------------\\\")\\n\\t\\tprint(\\\"lambda*:\\\", lambda_star)\\n\\t\\tprint(\\\"degree: \\\", degree_star)\\n\\t\\tif optimize_on == \\\"te_loss\\\":\\n\\t\\t\\tprint(\\\"test set loss: \\\", score)\\n\\t\\telif optimize_on == \\\"accu\\\":\\n\\t\\t\\tprint(\\\"accuracy: \\\", score)\\n\\n\\tprint(\\\"...............................\\\")\\n\\tprint(\\\"end\\\")\\n\\treturn lambdas_star, degrees_star\",\n \"def _evaluate(self, x):\\n if _isscalar(x):\\n pos = np.searchsorted(self.x_list, x)\\n if pos == 0:\\n y = self.coeffs[0, 0] + self.coeffs[0, 1] * (x - self.x_list[0])\\n elif pos < self.n:\\n alpha = (x - self.x_list[pos - 1]) / (\\n self.x_list[pos] - self.x_list[pos - 1]\\n )\\n y = self.coeffs[pos, 0] + alpha * (\\n self.coeffs[pos, 1]\\n + alpha * (self.coeffs[pos, 2] + alpha * self.coeffs[pos, 3])\\n )\\n else:\\n alpha = x - self.x_list[self.n - 1]\\n y = (\\n self.coeffs[pos, 0]\\n + x * self.coeffs[pos, 1]\\n - self.coeffs[pos, 2] * np.exp(alpha * self.coeffs[pos, 3])\\n )\\n else:\\n m = len(x)\\n pos = np.searchsorted(self.x_list, x)\\n y = np.zeros(m)\\n if y.size > 0:\\n out_bot = pos == 0\\n out_top = pos == self.n\\n in_bnds = np.logical_not(np.logical_or(out_bot, out_top))\\n\\n # Do the \\\"in bounds\\\" evaluation points\\n i = pos[in_bnds]\\n coeffs_in = self.coeffs[i, :]\\n alpha = (x[in_bnds] - self.x_list[i - 1]) / (\\n self.x_list[i] - self.x_list[i - 1]\\n )\\n y[in_bnds] = coeffs_in[:, 0] + alpha * (\\n coeffs_in[:, 1]\\n + alpha * (coeffs_in[:, 2] + alpha * coeffs_in[:, 3])\\n )\\n\\n # Do the \\\"out of bounds\\\" evaluation points\\n y[out_bot] = self.coeffs[0, 0] + self.coeffs[0, 1] * (\\n x[out_bot] - self.x_list[0]\\n )\\n alpha = x[out_top] - self.x_list[self.n - 1]\\n y[out_top] = (\\n self.coeffs[self.n, 0]\\n + x[out_top] * self.coeffs[self.n, 1]\\n - self.coeffs[self.n, 2] * np.exp(alpha * self.coeffs[self.n, 3])\\n )\\n\\n y[x == self.x_list[0]] = self.y_list[0]\\n\\n return y\",\n \"def partial_fit(self, X, y=..., **fit_params):\\n ...\",\n \"def evaluate_poly(poly, x):\\n exp = 0\\n total = 0\\n for coef in poly:\\n total += coef * (x ** exp)\\n exp += 1\\n\\n return total\",\n \"def fit(self):\\n self.eval_chisq([1, 1, 1, 1])\",\n \"def lsq_coefficients(x, y, fit_intercept=False):\\n if fit_intercept:\\n x = np.vstack([x, np.ones(len(x))]).T\\n else:\\n x = np.vstack([x, np.zeros(len(x))]).T\\n return np.dot(np.dot(np.linalg.pinv(np.dot(x.T, x)), x.T), y)\",\n \"def fit_poly_model(order, train_data, feature: str, valid_data=None, output: str = 'price',\\n l2_penalty=1e-9,\\n normalization: bool = True, model_plot: bool = False, color_scheme: List[str] = None,\\n pause_plotting_time=5):\\n # an 'order' degree polynomial :\\n poly_data = polynomial_dataframe(train_data[feature], order)\\n poly_data[output] = train_data[output]\\n\\n # compute the regression weights for predicting sales[‘price’]\\n # based on the 1 degree polynomial feature ‘sqft_living’:\\n from sklearn.linear_model import Ridge\\n # make a new instance of the object:\\n model = Ridge(alpha=l2_penalty, normalize=normalization)\\n # convert data frame to numpy array to prevent shape error with sikit-learn:\\n x = np.array(poly_data.iloc[:, :-1])\\n y = np.array(poly_data[output]).reshape(-1, 1)\\n\\n model.fit(x, y)\\n\\n # store all coefficient in poly1_weights array:\\n poly_weights = model.intercept_\\n for i in range(0, len(model.coef_)):\\n poly_weights = np.append(poly_weights, model.coef_[i])\\n\\n # Plotting the model, features Xs vs observation Y:\\n if model_plot:\\n # produce a scatter plot of the training data (just square feet vs price) with fitted model:\\n if color_scheme is not None:\\n # plot without default color:\\n plt.scatter(poly_data['power_1'], poly_data[output], c=color_scheme[0])\\n plt.plot(x[:, 0], model.predict(x), c=color_scheme[1])\\n else:\\n # plot with default color but in different figures:\\n import random\\n num_figure = random.randint(0, 1000)\\n plt.figure(num_figure)\\n plt.scatter(poly_data['power_1'], poly_data[output])\\n plt.plot(x[:, 0], model.predict(x), c='red')\\n plt.figure(num_figure).show()\\n plt.pause(pause_plotting_time)\\n\\n # compute rss:\\n train_rss = get_residual_sum_squares(y, model.predict(x))\\n # compute rss on validation set:\\n if valid_data is None:\\n # Then we don't need validation_rss:\\n validation_rss = None\\n else:\\n poly_data_valid = polynomial_dataframe(valid_data[feature], order)\\n poly_data_valid[output] = valid_data[output]\\n\\n x_valid = np.array(poly_data_valid.iloc[:, :-1])\\n y_valid = np.array(poly_data_valid[output]).reshape(-1, 1)\\n # get ready validation rss to return:\\n validation_rss = get_residual_sum_squares(y_valid, model.predict(x_valid))\\n\\n return poly_weights, train_rss, validation_rss\",\n \"def polyfit(dates, levels, p):\\n x = matplotlib.dates.date2num(dates)\\n\\n y = levels\\n\\n # Using shifted x values, find coefficient of best-fit\\n # polynomial f(x) of degree p\\n shifted_times = [t-x[0] for t in x]\\n p_coeff = np.polyfit(shifted_times, y, p)\\n\\n # Convert coefficient into a polynomial that can be evaluated\\n # e.g. poly(0.3)\\n poly = np.poly1d(p_coeff)\\n\\n return (poly, x[0])\",\n \"def polyfit(data, tvec, intfun):\\n\\n posx = intfun(tvec, data[:, 0])\\n posz = intfun(tvec, data[:, 1])\\n velx = posx.derivative(1)\\n velz = posz.derivative(1)\\n accx = posx.derivative(2)\\n accz = posz.derivative(2)\\n\\n pos = np.c_[posx(tvec), posz(tvec)]\\n vel = np.c_[velx(tvec), velz(tvec)]\\n acc = np.c_[accx(tvec), accz(tvec)]\\n\\n return pos, vel, acc\",\n \"def fit(self, X):\\n raise NotImplementedError\",\n \"def get_poly_coeff(self, independent, dependent):\\n\\n try:\\n x = self.df_input[[independent]]\\n y = self.df_input[[dependent]]\\n\\n poly = PolynomialFeatures(degree = 2)\\n x_poly = poly.fit_transform(x) \\n\\n model = LinearRegression()\\n model.fit(x_poly, y)\\n return model.coef_\\n except Exception as e:\\n print(e)\",\n \"def fitfunc(self, x, p):\\n S = np.zeros(self.npt)\\n for i in range(0, len(p), self.maxparm):\\n ptyp = self.peakTyp[int(i/self.maxparm)]\\n xm = p[i]\\n amp = p[i+1]\\n w = p[i+2]\\n a = p[i+3]\\n m = p[i+4]\\n if ptyp == 'G':\\n # peak type = Gaussian\\n S = S + self.gauss(x, xm, amp, w)\\n elif ptyp == 'L':\\n # peak type = Lorentzian\\n S = S + self.lorentz(x, xm, amp, w)\\n elif ptyp == 'P':\\n # peak type = Pseudo-Voigt\\n S = S + self.psVoigt(x, xm, amp, w, m)\\n elif ptyp == 'AG':\\n # peak type = Asymmetric Gaussian\\n S = S + self.agauss(x, xm, amp, w, a)\\n elif ptyp == 'AL':\\n # peak type = Asymmetric Lorentzian\\n S = S + self.alorentz(x, xm, amp, w, a)\\n elif ptyp == 'AP':\\n # peak type = Asymmetric Pseudo-Voigt\\n S = S + self.aPsVoigt(x, xm, amp, w, a, m)\\n return S\",\n \"def partial_fit(self, X):\\n return super().partial_fit(X)\",\n \"def fit_psp(data, search_window, clamp_mode, sign=0, exp_baseline=True, baseline_like_psp=False, refine=True, init_params=None, fit_kws=None, ui=None): \\n import pyqtgraph as pg\\n prof = pg.debug.Profiler(disabled=True, delayed=False)\\n prof(\\\"args: %s %s %s %s %s %s %s %s\\\" % (search_window, clamp_mode, sign, exp_baseline, baseline_like_psp, refine, init_params, fit_kws))\\n \\n if ui is not None:\\n ui.clear()\\n ui.console.setStack()\\n ui.plt1.plot(data.time_values, data.data)\\n ui.plt1.addLine(x=search_window[0], pen=0.3)\\n ui.plt1.addLine(x=search_window[1], pen=0.3)\\n prof('plot')\\n\\n if fit_kws is None:\\n fit_kws = {}\\n if init_params is None:\\n init_params = {}\\n\\n method = 'leastsq'\\n fit_kws.setdefault('maxfev', 500)\\n\\n # good fit, slow\\n # method = 'Nelder-Mead'\\n \\n # fit_kws.setdefault('options', {\\n # 'maxiter': 300, \\n \\n # # 'disp': True,\\n # })\\n \\n # good fit\\n # method = 'Powell'\\n # fit_kws.setdefault('options', {'maxfev': 200, 'disp': True})\\n\\n # bad fit\\n # method = 'CG'\\n # fit_kws.setdefault('options', {'maxiter': 100, 'disp': True})\\n\\n # method = 'L-BFGS-B'\\n # fit_kws.setdefault('options', {'maxiter': 100, 'disp': True})\\n\\n # take some measurements to help constrain fit\\n data_min = data.data.min()\\n data_max = data.data.max()\\n data_mean = data.mean()\\n \\n baseline_mode = float_mode(data.time_slice(None, search_window[0]).data)\\n \\n # set initial conditions depending on whether in voltage or current clamp\\n # note that sign of these will automatically be set later on based on the \\n # the *sign* input\\n if clamp_mode == 'ic':\\n amp_init = init_params.get('amp', .2e-3)\\n amp_max = min(100e-3, 3 * (data_max-data_min))\\n rise_time_init = init_params.get('rise_time', 5e-3)\\n decay_tau_init = init_params.get('decay_tau', 50e-3)\\n exp_tau_init = init_params.get('exp_tau', 50e-3)\\n exp_amp_max = 100e-3\\n elif clamp_mode == 'vc':\\n amp_init = init_params.get('amp', 20e-12)\\n amp_max = min(500e-12, 3 * (data_max-data_min))\\n rise_time_init = init_params.get('rise_time', 1e-3)\\n decay_tau_init = init_params.get('decay_tau', 4e-3)\\n exp_tau_init = init_params.get('exp_tau', 4e-3)\\n exp_amp_max = 10e-9\\n else:\\n raise ValueError('clamp_mode must be \\\"ic\\\" or \\\"vc\\\"')\\n\\n # Set up amplitude initial values and boundaries depending on whether *sign* are positive or negative\\n if sign == -1:\\n amp = (-amp_init, -amp_max, 0)\\n elif sign == 1:\\n amp = (amp_init, 0, amp_max)\\n elif sign == 0:\\n amp = (0, -amp_max, amp_max)\\n else:\\n raise ValueError('sign must be 1, -1, or 0')\\n \\n # initial condition, lower boundary, upper boundary\\n base_params = {\\n 'yoffset': (init_params.get('yoffset', baseline_mode), data_min, data_max),\\n 'rise_time': (rise_time_init, rise_time_init/10., rise_time_init*10.),\\n 'decay_tau': (decay_tau_init, decay_tau_init/10., decay_tau_init*10.),\\n 'rise_power': (2, 'fixed'),\\n 'amp': amp,\\n }\\n \\n # specify fitting function and set up conditions\\n psp = StackedPsp()\\n if exp_baseline:\\n if baseline_like_psp:\\n exp_min = 0 if sign == 1 else -exp_amp_max \\n exp_max = 0 if sign == -1 else exp_amp_max \\n base_params['exp_tau'] = 'decay_tau'\\n else:\\n exp_min = -exp_amp_max \\n exp_max = exp_amp_max \\n base_params['exp_tau'] = (exp_tau_init, exp_tau_init / 10., exp_tau_init * 20.)\\n base_params['exp_amp'] = (0.01 * sign * amp_init, exp_min, exp_max)\\n else:\\n base_params.update({'exp_amp': (0, 'fixed'), 'exp_tau': (1, 'fixed')})\\n \\n # print(clamp_mode, base_params, sign, amp_init)\\n \\n # if weight is None: #use default weighting\\n # weight = np.ones(len(y))\\n # else: #works if there is a value specified in weight\\n # if len(weight) != len(y):\\n # raise Exception('the weight and array vectors are not the same length') \\n # fit_kws['weights'] = weight\\n\\n # Round 1: coarse fit\\n\\n # Coarse search xoffset\\n n_xoffset_chunks = max(1, int((search_window[1] - search_window[0]) / 1e-3))\\n xoffset_chunks = np.linspace(search_window[0], search_window[1], n_xoffset_chunks+1)\\n xoffset = [{'xoffset': ((a+b)/2., a, b)} for a,b in zip(xoffset_chunks[:-1], xoffset_chunks[1:])]\\n \\n prof('prep for coarse fit')\\n\\n # Find best coarse fit \\n search = SearchFit(psp, [xoffset], params=base_params, x=data.time_values, data=data.data, fit_kws=fit_kws, method=method)\\n for i,result in enumerate(search.iter_fit()):\\n pass\\n # prof(' coarse fit iteration %d/%d: %s %s' % (i, len(search), result['param_index'], result['params']))\\n fit = search.best_result.best_values\\n prof(\\\"coarse fit done (%d iter)\\\" % len(search))\\n\\n if ui is not None:\\n br = search.best_result\\n ui.plt1.plot(data.time_values, br.best_fit, pen=(0, 255, 0, 100))\\n\\n if not refine:\\n return search.best_result\\n\\n # Round 2: fine fit\\n \\n # Fine search xoffset\\n fine_search_window = (max(search_window[0], fit['xoffset']-1e-3), min(search_window[1], fit['xoffset']+1e-3))\\n n_xoffset_chunks = max(1, int((fine_search_window[1] - fine_search_window[0]) / .2e-3))\\n xoffset_chunks = np.linspace(fine_search_window[0], fine_search_window[1], n_xoffset_chunks + 1)\\n xoffset = [{'xoffset': ((a+b)/2., a, b)} for a,b in zip(xoffset_chunks[:-1], xoffset_chunks[1:])]\\n\\n # Search amp / rise time / decay tau to avoid traps\\n rise_time_inits = base_params['rise_time'][0] * 1.2**np.arange(-1,6)\\n rise_time = [{'rise_time': (x,) + base_params['rise_time'][1:]} for x in rise_time_inits]\\n\\n decay_tau_inits = base_params['decay_tau'][0] * 2.0**np.arange(-1,2)\\n decay_tau = [{'decay_tau': (x,) + base_params['decay_tau'][1:]} for x in decay_tau_inits]\\n\\n search_params = [\\n rise_time, \\n decay_tau, \\n xoffset,\\n ]\\n \\n # if 'fixed' not in base_params['exp_amp']:\\n # exp_amp_inits = [0, amp_init*0.01, amp_init]\\n # exp_amp = [{'exp_amp': (x,) + base_params['exp_amp'][1:]} for x in exp_amp_inits]\\n # search_params.append(exp_amp)\\n\\n # if no sign was specified, search from both sides \\n if sign == 0:\\n amp = [{'amp': (amp_init, -amp_max, amp_max)}, {'amp': (-amp_init, -amp_max, amp_max)}]\\n search_params.append(amp)\\n\\n prof(\\\"prepare for fine fit %r\\\" % base_params)\\n\\n # Find best fit \\n search = SearchFit(psp, search_params, params=base_params, x=data.time_values, data=data.data, fit_kws=fit_kws, method=method)\\n for i,result in enumerate(search.iter_fit()):\\n pass\\n prof(' fine fit iteration %d/%d: %s %s' % (i, len(search), result['param_index'], result['params']))\\n fit = search.best_result\\n prof('fine fit done (%d iter)' % len(search))\\n\\n return fit\",\n \"def evaluate_poly(poly, x):\\n value_of_poly = 0\\n for i in range(0, len(poly)):\\n var = x\\n power = i\\n coeff = poly[i]\\n value_of_poly += (coeff * (var**power))\\n return value_of_poly\",\n \"def fitPolynomialAnalytically(\\n deg, datapoints, crossCheckWithTGraphErrors = False):\\n import ROOT, math\\n from ROOT import Math, TMath, TGraphErrors, TF1\\n ncoeffpol = deg + 1\\n # check with ROOT's TGraphErrors, if caller wants us to\\n if crossCheckWithTGraphErrors:\\n gr = TGraphErrors(len(datapoints))\\n i = 0\\n for dp in datapoints:\\n x, y, sigma = dp[0], dp[1], dp[2]\\n gr.SetPoint(i, x, y)\\n gr.SetPointError(i, 0., sigma)\\n i = i + 1\\n funcstr = '0'\\n for i in xrange(0, ncoeffpol):\\n funcstr = funcstr + ('+[%d]*x**%d' % (i, i))\\n func = TF1('func', funcstr)\\n print ''\\n print 'RESULT OF PLAIN ROOT FIT TO TGRAPHERRORS'\\n gr.Fit(func)\\n # accumulate data points\\n icov = ROOT.Math.SMatrix('double', ncoeffpol, ncoeffpol,\\n ROOT.Math.MatRepSym('double', ncoeffpol))()\\n rhs = ROOT.Math.SVector('double', ncoeffpol)()\\n for dp in datapoints:\\n x, y, sigma = dp[0], dp[1], dp[2]\\n for i in xrange(0, ncoeffpol):\\n rhs[i] += y * pow(x, i) / pow(sigma, 2)\\n for j in xrange(0, i + 1):\\n icov[i, j] = icov(i, j) + pow(x, i + j) / pow(sigma, 2)\\n # data point for analytical fit accumulated\\n # solve analytical fit\\n cov = ROOT.Math.SMatrix('double', ncoeffpol, ncoeffpol,\\n ROOT.Math.MatRepSym('double', ncoeffpol))(icov)\\n if (not cov.InvertChol()):\\n print (\\\"ERROR: analytical fit for calibration parameters ' + \\\\\\n 'failed - HESSE matrix singular or with negative eigenvalues!\\\")\\n return {}\\n sol = ROOT.Math.SVector('double', ncoeffpol)()\\n # python isn't smart enough to get the SMatrix matrix-vector\\n # multiply, so we do it by hand...\\n for i in xrange(0, ncoeffpol):\\n tmp = 0.\\n for j in xrange(0, ncoeffpol):\\n tmp += cov(i, j) * rhs(j)\\n sol[i] = tmp \\n # work out number of degrees of freedom\\n ndf = len(datapoints) - ncoeffpol\\n # get chi2\\n chi2 = 0.\\n for dp in datapoints: # sum over measurements i\\n x, y, sigma = dp[0], dp[1], dp[2]\\n # evaluate om = sum_k p_k x^k\\n yy = 0.\\n for i in xrange(0, ncoeffpol):\\n yy += sol(ncoeffpol - 1 - i)\\n if i != ncoeffpol - 1:\\n yy *= x\\n # chi2 += ((yy - y) / sigma_i) ^ 2\\n chi2 += pow((yy - y) / sigma, 2)\\n # print result\\n print ''\\n print ('FIT RESULT OF ANALYTICAL FIT: CHI^2 %f NDF %d '\\n 'CHI^2/NDF %f PROB %f') % (chi2, ndf, chi2 / float(ndf),\\n ROOT.TMath.Prob(chi2, ndf))\\n print ''\\n for i in xrange(0, ncoeffpol):\\n print '%10s = %f +/- %f' % ('p%d' % i, sol(i),\\n math.sqrt(cov(i, i)))\\n print ''\\n print 'CORRELATION MATRIX:'\\n for i in xrange(0, ncoeffpol):\\n s = ''\\n for j in xrange(0, ncoeffpol):\\n rho = cov(i, j) / math.sqrt(cov(i, i) * cov(j, j))\\n s = s + (' % 6.3f' % rho )\\n print s\\n # analytical fit all done\\n return {\\n 'ndf': ndf,\\n 'chi2': chi2,\\n 'prob': TMath.Prob(chi2, ndf),\\n 'polycoeffs': [ sol(i) for i in xrange(0, ncoeffpol) ],\\n 'polycoefferrors': [\\n math.sqrt(cov(i, i)) for i in xrange(0, ncoeffpol) ],\\n 'covariance': [\\n [ cov(i, j) for j in xrange(0, ncoeffpol) ]\\n for i in xrange(0, ncoeffpol) ],\\n 'correlation': [\\n [ cov(i, j) / math.sqrt(cov(i, i) * cov(j, j))\\n for j in xrange(0, ncoeffpol) ]\\n for i in xrange(0, ncoeffpol) ]\\n }\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def fit(self, X, y=...):\\n ...\",\n \"def defining_polynomial(self):\\n return self.defining_polynomials()[0]\",\n \"def defining_polynomial(self):\\n return self.defining_polynomials()[0]\",\n \"def fit(init_params, data):\\n snrs, ras, decs = data.transpose()\\n errorfunction = lambda p: np.ravel(observed_snr(*p)(ras, decs) - snrs)\\n if debug:\\n output = opt.leastsq(errorfunction, init_params, maxfev=10000, full_output=1)\\n print output[-1], output[-2]\\n p = output[0]\\n else:\\n p, success = opt.leastsq(errorfunction, init_params, maxfev=10000)\\n return p\",\n \"def _reform_poly_coefficients(fit_poly_x, fit_poly_y):\\n # Extract values for CD matrix and recombining\\n c11 = fit_poly_x.c1_0.value\\n c12 = fit_poly_x.c0_1.value\\n c21 = fit_poly_y.c1_0.value\\n c22 = fit_poly_y.c0_1.value\\n sip_poly_x = fit_poly_x.copy()\\n sip_poly_y = fit_poly_y.copy()\\n # Force low order coefficients to be 0 as defined in SIP\\n sip_poly_x.c0_0 = 0\\n sip_poly_y.c0_0 = 0\\n sip_poly_x.c1_0 = 0\\n sip_poly_x.c0_1 = 0\\n sip_poly_y.c1_0 = 0\\n sip_poly_y.c0_1 = 0\\n\\n cdmat = ((c11, c12), (c21, c22))\\n invcdmat = npla.inv(np.array(cdmat))\\n degree = fit_poly_x.degree\\n # Now loop through all remaining coefficients\\n for i in range(0, degree + 1):\\n for j in range(0, degree + 1):\\n if (i + j > 1) and (i + j < degree + 1):\\n old_x = getattr(fit_poly_x, f'c{i}_{j}').value\\n old_y = getattr(fit_poly_y, f'c{i}_{j}').value\\n newcoeff = np.dot(invcdmat, np.array([[old_x], [old_y]]))\\n setattr(sip_poly_x, f'c{i}_{j}', newcoeff[0, 0])\\n setattr(sip_poly_y, f'c{i}_{j}', newcoeff[1, 0])\\n\\n return cdmat, sip_poly_x, sip_poly_y\",\n \"def solve(self):\\r\\n try:\\r\\n self.a_values_list.delete(0, tk.END)\\r\\n self.solved = False\\r\\n\\r\\n degree = int(self.degree_entry.get())\\r\\n self.a_values = FindPolynomialLeastSquaresFit(self.points, degree)\\r\\n\\r\\n # Display the As.\\r\\n for k in range(len(self.a_values)):\\r\\n self.a_values_list.insert(tk.END, f\\\"A[{k}] = {self.a_values[k]}\\\")\\r\\n self.solved = True\\r\\n except Exception as e:\\r\\n messagebox.showinfo(\\\"Error\\\", str(e))\\r\\n\\r\\n self.draw()\",\n \"def fit_polynomial(self,x,t,m,lambda_reg=0):\\n\\n phi = self.designMatrix(x,m)\\n phi_trans = np.transpose(phi)\\n\\n a = phi_trans.dot(phi) + lambda_reg*np.identity(phi.shape[1])\\n b = np.linalg.inv(a)\\n c = b.dot(phi_trans)\\n\\n w_ml = c.dot(t)\\n\\n return w_ml, phi\",\n \"def poly(x, y, pd) :\\n # Maximum polynomial degree allowed is 7.\\n maxD = 7\\n if pd > maxD :\\n exit(\\\"Please choose a reasonable polynomial degree (0 <= pd <= \\\" + maxD + \\\").\\\")\\n \\n # Make the polynomial matrix one degree at a time.\\n p = np.zeros((len(x), int((pd+1)*(pd+2)/2)), float)\\n count = 0\\n numP = 0\\n for i in range(pd + 1) :\\n for j in range(numP + 1) :\\n if (j == 0) and (numP == 0) :\\n p[:,count] = 1\\n elif (j == 0) :\\n p[:,count] = x**(numP-j)\\n elif (numP-j == 0) :\\n p[:,count] = y**j\\n else :\\n p[:,count] = x**(numP-j) * y**j\\n count += 1\\n numP += 1\\n \\n return p\",\n \"def find_period(ticks, expected_period):\\n best_slope = 1\\n best_p = 1\\n for p in np.linspace(expected_period - 5, expected_period + 5, 2000):\\n slope, intercept, rval, pval, stderr = linregress(ticks/p, ticks % p)\\n if stderr + abs(slope) < abs(best_slope): # search for a fit with zero slope and low error\\n best_slope = stderr + abs(slope)\\n best_p = p\\n return best_p\",\n \"def linesearch(f, x0, J0, g0, a, amax, mu1, mu2, p):\\r\\n J, g, a = bracketing(f, x0, J0, g0, a, amax, mu1, mu2, p)\\r\\n x = x0+a*p\\r\\n return x, J, g, a\",\n \"def linear_fit(x, y):\\n x = np.array(x)\\n y = np.array(y)\\n \\n invalid_idx = np.isnan(x) | np.isinf(x) | np.isnan(y) | np.isinf(y)\\n x = x[~invalid_idx]\\n y = y[~invalid_idx]\\n\\n covs = sm.add_constant(x, prepend=True)\\n model = sm.OLS(y, covs)\\n result = model.fit()\\n return result.params, result.rsquared\",\n \"def __test_s_polynomial():\\n poly_ring = PolynomialRing(QQ, 'x,y', order='deglex')\\n x, y = poly_ring('x'), poly_ring('y')\\n g = x ** 3 - 2 * x * y\\n h = x ** 2 * y - 2 * y ** 2 + x\\n print __s_polynomial(g, h) # Expected -x^2\",\n \"def _regressor_partial_fit(X, y, js_model, n_iter):\\n\\n X_is_sparse = sp.issparse(X)\\n y_is_sparse = sp.issparse(y)\\n\\n js_state = libpytsetlini.regressor_partial_fit(\\n X, X_is_sparse,\\n y, y_is_sparse,\\n js_model,\\n n_iter)\\n\\n return js_state\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6252983","0.60985476","0.60769516","0.6001327","0.59808683","0.5978871","0.59773546","0.5953325","0.59510887","0.5937711","0.593213","0.58654374","0.58370185","0.58306885","0.57615274","0.57519823","0.57093227","0.5706699","0.5706699","0.5706699","0.57018423","0.56814533","0.5670656","0.56614804","0.56530225","0.56411105","0.56257445","0.5614455","0.559032","0.55884695","0.55884695","0.5571983","0.5562714","0.55428606","0.5538557","0.551653","0.55133194","0.5505973","0.5486755","0.54837966","0.54830426","0.54469323","0.54452145","0.5444603","0.5440992","0.5440098","0.5434491","0.5433839","0.54323334","0.5427322","0.54225945","0.5415445","0.53984416","0.53954667","0.5378637","0.5374188","0.5371981","0.5370311","0.5370218","0.5363885","0.53613853","0.5357435","0.53571457","0.53531253","0.5349238","0.5345881","0.533593","0.5330185","0.5316135","0.53160214","0.53095317","0.53047067","0.5304529","0.5301049","0.53008103","0.5297346","0.52944696","0.5285792","0.52857876","0.52857876","0.52857876","0.52857876","0.52857876","0.52857876","0.52857876","0.52857876","0.52857876","0.52857876","0.52741","0.52741","0.5265066","0.526482","0.5263235","0.5259942","0.525435","0.5249447","0.5244769","0.5240327","0.5237227","0.5235265"],"string":"[\n \"0.6252983\",\n \"0.60985476\",\n \"0.60769516\",\n \"0.6001327\",\n \"0.59808683\",\n \"0.5978871\",\n \"0.59773546\",\n \"0.5953325\",\n \"0.59510887\",\n \"0.5937711\",\n \"0.593213\",\n \"0.58654374\",\n \"0.58370185\",\n \"0.58306885\",\n \"0.57615274\",\n \"0.57519823\",\n \"0.57093227\",\n \"0.5706699\",\n \"0.5706699\",\n \"0.5706699\",\n \"0.57018423\",\n \"0.56814533\",\n \"0.5670656\",\n \"0.56614804\",\n \"0.56530225\",\n \"0.56411105\",\n \"0.56257445\",\n \"0.5614455\",\n \"0.559032\",\n \"0.55884695\",\n \"0.55884695\",\n \"0.5571983\",\n \"0.5562714\",\n \"0.55428606\",\n \"0.5538557\",\n \"0.551653\",\n \"0.55133194\",\n \"0.5505973\",\n \"0.5486755\",\n \"0.54837966\",\n \"0.54830426\",\n \"0.54469323\",\n \"0.54452145\",\n \"0.5444603\",\n \"0.5440992\",\n \"0.5440098\",\n \"0.5434491\",\n \"0.5433839\",\n \"0.54323334\",\n \"0.5427322\",\n \"0.54225945\",\n \"0.5415445\",\n \"0.53984416\",\n \"0.53954667\",\n \"0.5378637\",\n \"0.5374188\",\n \"0.5371981\",\n \"0.5370311\",\n \"0.5370218\",\n \"0.5363885\",\n \"0.53613853\",\n \"0.5357435\",\n \"0.53571457\",\n \"0.53531253\",\n \"0.5349238\",\n \"0.5345881\",\n \"0.533593\",\n \"0.5330185\",\n \"0.5316135\",\n \"0.53160214\",\n \"0.53095317\",\n \"0.53047067\",\n \"0.5304529\",\n \"0.5301049\",\n \"0.53008103\",\n \"0.5297346\",\n \"0.52944696\",\n \"0.5285792\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52857876\",\n \"0.52741\",\n \"0.52741\",\n \"0.5265066\",\n \"0.526482\",\n \"0.5263235\",\n \"0.5259942\",\n \"0.525435\",\n \"0.5249447\",\n \"0.5244769\",\n \"0.5240327\",\n \"0.5237227\",\n \"0.5235265\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52596563"},"document_rank":{"kind":"string","value":"94"}}},{"rowIdx":14792,"cells":{"query":{"kind":"string","value":"Get the mean value of fit \"Left\" and \"Right\" based on flag"},"document":{"kind":"string","value":"def get_mean_fit(flag='L'):\n if flag == 'L':\n return np.mean(np.vstack(l_coeff_queue), axis =0) if len(l_coeff_queue)>1 else l_coeff_queue[-1]\n else:\n return np.mean(np.vstack(r_coeff_queue), axis =0) if len(r_coeff_queue)>1 else r_coeff_queue[-1]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _mask_and_avg(values, padding_mask):\n\tdec_lens = torch.sum(padding_mask,dim=1)\n\tlosses = torch.stack(values, dim=1)\n\tlosses = losses * padding_mask\n\tvalues_per_ex = torch.sum(losses, dim=1)/dec_lens\n\treturn torch.sum(values_per_ex)","def mean(self):\n\n\t\tif not self._masked:\n\t\t\t\n\t\t\treturn self.data.mean()\n\t\t\n\t\telse:\n\t\t\t\n\t\t\tif not hasattr(self,\"_full_mask\"):\n\t\t\t\tself.maskBoundaries()\n\t\t\t\n\t\t\treturn self.data[self._full_mask].mean()","def _get_mean(self):\n return self._get_conditional_negative_energy()","def right_or_left(self): \n right_sum = 0\n right_avg = 0\n left_sum = 0\n left_avg = 0\n self.scan()\n for angle in self.scan_data:\n if angle < self.MIDPOINT:\n right_sum += self.scan_data[angle]\n right_avg += 1\n else: \n left_avg += self.scan_data[angle]\n left_avg += 1\n\n left_avg = left_sum / left_avg \n right_avg = right_sum / right_avg\n\n if left_avg > right_avg: \n return 'l' \n else:\n return 'r'","def get_mean(self):\n self.meanval = np.mean(self.adulist)","def mean_baseline(d, mode='test'):\n m = d.trainY.mean()\n y = getattr(d, mode + \"Y\")\n preds = np.array([m] * y.shape[0])\n return (get_mse(d, preds, mode), get_mae(d, preds, mode),\n get_mape(d, preds, mode))","def measure(mode, x, y, x0, x1):\n xm = ma.masked_outside(x, x0, x1)\n ym = ma.array(y, mask = ma.getmask(xm))\n if mode == 'mean':\n r1 = ma.mean(ym)\n r2 = ma.std(ym)\n if mode == 'max':\n r1 = ma.max(ym)\n r2 = 0\n if mode == 'min':\n r1 = ma.min(ym)\n r2 = 0\n if mode == 'median':\n r1 = ma.median(ym)\n r2 = 0\n if mode == 'p2p': # peak to peak\n r1 = ma.ptp(ym)\n r2 = 0\n return(r1, r2)","def _get_average(self):\n norm = 1.0\n for pos, idx in enumerate(self.idx):\n norm *= (self.high[pos] - self.low[pos])\n return 1.0/norm","def _get_mean(self):\n mu = self._get_conditional_negative_energy()\n return sigmoid(mu)","def _mask_and_avg(values, padding_mask):\n\n dec_lens = tf.reduce_sum(padding_mask, axis=1) # shape batch_size. float32\n values_per_step = [v * padding_mask[:,dec_step] for dec_step,v in enumerate(values)]\n values_per_ex = sum(values_per_step)/dec_lens # shape (batch_size); normalized value for each batch member\n return tf.reduce_mean(values_per_ex) # overall average","def update_average_best_fit(self):\r\n # print(result_buffer)\r\n total = len(self.result_buffer)\r\n left_fit, right_fit = np.empty((0, 3)), np.empty((0, 3))\r\n left_curve_rad, right_curve_rad = [], []\r\n vehicle_offset = []\r\n for i in range(total):\r\n calc_fit_dict = self.result_buffer[i]\r\n left_fit = np.append(left_fit, [calc_fit_dict['left_fit']], axis=0)\r\n right_fit = np.append(right_fit, [calc_fit_dict['right_fit']], axis=0)\r\n left_curve_rad.append(calc_fit_dict['left_curve_rad'])\r\n right_curve_rad.append(calc_fit_dict['right_curve_rad'])\r\n vehicle_offset.append(calc_fit_dict['vehicle_offset'])\r\n self.avg_fit_dict['left_fit'] = np.mean(left_fit, axis=0)\r\n self.avg_fit_dict['right_fit'] = np.mean(right_fit, axis=0)\r\n self.avg_fit_dict['left_curve_rad'] = np.mean(left_curve_rad)\r\n self.avg_fit_dict['right_curve_rad'] = np.mean(right_curve_rad)\r\n self.avg_fit_dict['vehicle_offset'] = np.mean(vehicle_offset)\r\n # print(avg_fit_dict)\r\n return","def mean_average_position():\n pass","def _get_reference_fit(self, img):\n bw_img = 255 * (img >= self.contrast)\n fit = [center_on_box(bw_img, self.radius, self.min_ref, *ref) for ref in self.refzone]\n meanfit = num.mean(num.ma.masked_array(fit, fit == -9999), axis=0).astype('i')\n if meanfit[0] is num.ma.masked:\n raise StandardError('At least one reference box match required')\n\n return meanfit, fit","def _ave(self):\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def mean(vals):","def mean(self, weight_by_area=True):\n if weight_by_area:\n return self.integral() / self.indicator.integral()\n else:\n return self.sum() / self.indicator.sum()","def calculate_mean(self) -> float:\n\n if self.data:\n return np.mean(self.data)\n else:\n return self.mu","def _ave(self):\n\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def _get_mean(self):\n return (0.485, 0.456, 0.406)","def measure(mode, x, y, x0, x1, thresh = 0):\n xt = x.view(numpy.ndarray) # strip Metaarray stuff -much faster!\n v = y.view(numpy.ndarray)\n \n xm = ma.masked_outside(xt, x0, x1).T\n ym = ma.array(v, mask = ma.getmask(xm))\n if mode == 'mean':\n r1 = ma.mean(ym)\n r2 = ma.std(ym)\n if mode == 'max' or mode == 'maximum':\n r1 = ma.max(ym)\n r2 = xm[ma.argmax(ym)]\n if mode == 'min' or mode == 'minimum':\n r1 = ma.min(ym)\n r2 = xm[ma.argmin(ym)]\n if mode == 'median':\n r1 = ma.median(ym)\n r2 = 0\n if mode == 'p2p': # peak to peak\n r1 = ma.ptp(ym)\n r2 = 0\n if mode == 'std': # standard deviation\n r1 = ma.std(ym)\n r2 = 0\n if mode == 'var': # variance\n r1 = ma.var(ym)\n r2 = 0\n if mode == 'cumsum': # cumulative sum\n r1 = ma.cumsum(ym) # Note: returns an array\n r2 = 0\n if mode == 'anom': # anomalies = difference from averge\n r1 = ma.anom(ym) # returns an array\n r2 = 0\n if mode == 'sum':\n r1 = ma.sum(ym)\n r2 = 0\n if mode == 'area' or mode == 'charge':\n r1 = ma.sum(ym)/(ma.max(xm)-ma.min(xm))\n r2 = 0\n if mode == 'latency': # return first point that is > threshold\n sm = ma.nonzero(ym > thresh)\n r1 = -1 # use this to indicate no event detected\n r2 = 0\n if ma.count(sm) > 0:\n r1 = sm[0][0]\n r2 = len(sm[0])\n if mode == 'count':\n r1 = ma.count(ym)\n r2 = 0\n if mode == 'maxslope':\n return(0,0)\n slope = numpy.array([])\n win = ma.flatnotmasked_contiguous(ym)\n st = int(len(win)/20) # look over small ranges\n for k in win: # move through the slope measurementwindow\n tb = range(k-st, k+st) # get tb array\n newa = numpy.array(self.dat[i][j, thisaxis, tb])\n ppars = numpy.polyfit(x[tb], ym[tb], 1) # do a linear fit - smooths the slope measures\n slope = numpy.append(slope, ppars[0]) # keep track of max slope\n r1 = numpy.amax(slope)\n r2 = numpy.argmax(slope)\n return(r1, r2)","def mean(self):\r\n\t\treturn sum(self.sample)/len(self.sample)","def mean(image, selem, out=None, mask=None, shift_x=False, shift_y=False):\n\n return _apply(_crank8.mean, _crank16.mean, image, selem, out=out,\n mask=mask, shift_x=shift_x, shift_y=shift_y)","def mean(self):\n return self.cond_proba.mean","def meanEnergy(self, count=False):\n \n _E = (self.E).groupby(pd.cut(self.E, self.binEdges))\n try:\n def wm(x):\n try:\n return np.average(x, weights=self.Weight.loc[x.index])\n except ZeroDivisionError:\n return np.nan\n wc = lambda x: np.sum(self.Weight.loc[x.index])\n if count:\n E_count = _E.apply(wc)\n E_mean = _E.apply(wm)\n except AttributeError:\n if count:\n E_count = _E.count()\n E_mean = _E.mean()\n \n E_masked = np.ma.masked_invalid(E_mean)\n \n if count:\n C_masked = np.ma.masked_array(E_count, mask=E_masked.mask)\n return C_masked, E_masked\n return E_masked","def masked_mean(x: torch.FloatTensor, m: torch.BoolTensor):\n if m.bool().sum() == len(m):\n return torch.full((1, ), fill_value=float('inf'), device=x.device)\n return x[m.bool()].mean()","def compute_means(opts, train_data, sampler):\n exp_names = train_data[\"exp_names\"].value\n means = []\n stds = []\n if opts[\"flags\"].normalize is True:\n running_stats = []\n # a running stat for each channel\n running_stats = RunningStats(3)\n # loop over the experiments\n\n # for exp_name in exp_names:\n for j in range(0, len(exp_names), 2):\n batch = sampler.get_minibatch()\n exp_name = batch[2][0]\n print(exp_name)\n # loop over the keys\n\n seq_len = train_data[\"exps\"][exp_name][\"labels\"].shape[0]\n temp_feat = batch[0].cpu().numpy()\n temp_feat = temp_feat[:seq_len, :, :, :]\n\n channel_feats = []\n for i in range(3):\n # channel_feat = temp_feat[0, :, i, :]\n # sample frames\n channel_feat = temp_feat[::100, i, :]\n channel_feat = channel_feat.reshape(-1, 1)\n channel_feats.append(channel_feat)\n\n channel_feats = np.concatenate(channel_feats, axis=1)\n running_stats.add_data(\n channel_feat\n )\n\n means = running_stats.mean.tolist()\n stds = running_stats.compute_std().tolist()\n else:\n means = [.5, .5, .5]\n stds = [1, 1, 1]\n # for key in opts[\"flags\"].feat_keys:\n # temp_feat = train_data[\"exps\"][exp_names[0]][key].value\n # mean = np.zeros((temp_feat.shape[2], ))\n # std = np.ones((temp_feat.shape[2], ))\n # means.append(mean)\n # stds.append(std)\n normalize = transforms.Normalize(mean=means,\n std=stds)\n\n return normalize","def getMean(self):\n return self.mean","def get_fitness_mean(self):\n return self.get_fitness_stat(mean)","def get_mean(self):\n mean = np.array(np.zeros((4,8)))\n for i,c in enumerate(self.cellLines):\n for j,l in enumerate(self.ligands):\n mean[i][j] = self.aucs[c][l]['mean']\n return mean","def mean_absolute_percentage_error(y_true, y_pred, sample_weight=..., multioutput=...):\n ...","def calculate_mean(cls, sensor):\n try:\n if sensor == 't':\n return cls.calculate_y_pos(sum(cls.mean_t) / len(cls.mean_t), sensor)\n if sensor == 'l':\n return cls.calculate_y_pos(sum(cls.mean_l) / len(cls.mean_l), sensor)\n except ZeroDivisionError:\n return None","def mean_height(data):","def mean_height(data):","def mean_STD(self,counter):\n \n \n pass","def get_mean_accuracy(self):\n return self.df.correct.mean()","def mean_absolute_error(y_true, y_pred, *, sample_weight=..., multioutput=...):\n ...","def em_mean(self) -> float:\n if self.__total_pulls == 0:\n raise Exception('Number of pulls is 0. No empirical mean.')\n return self.__total_rewards / self.__total_pulls","def mean(self):\n return self.vmean","def mean(self):\n return self.sum / self.sum_weights","def mean_std_calc(dataloader):\n mean = 0\n std = 0\n samples = 0\n for data, _, _ in dataloader:\n batch_samples = data.size(0)\n data = data.view(batch_samples, data.size(1), -1)\n mean += data.mean(2).sum(0)\n std += data.std(2).sum(0)\n samples += batch_samples\n\n return (mean / samples),(std / samples)","def _get_mean(self):\n return [layer._get_mean() for layer in self.layers]","def conditional_mean(self, gp):\n raise NotImplementedError","def getMean(self, field):\n\n return np.mean([self.fitnesses[i][field] for i in range(len(self.fitnesses))])","def get_mean(self):\n return numpy.mean(self._x) - numpy.mean(self._y)","def get_means(self):\n if self.cv_method == 'fixed':\n perf = np.mean(self.evaluations, axis=0)\n perf = np.nanmean(perf, axis=-1)\n elif self.cv_method == 'crossvalidation':\n perf = np.mean(self.evaluations, axis=0)\n perf = np.nanmean(perf, axis=-1)\n else:\n perf = self.evaluations\n while len(perf.shape) > 2:\n perf = np.nanmean(perf, axis=-1)\n perf = perf[~np.isnan(perf[:, 0])]\n perf = np.mean(perf, axis=0)\n return perf","def rmae (y_true, y_pred):\n return tf.math.reduce_mean(tf.math.abs(y_true-y_pred)/y_true)","def meanVal(img):\n\tmean = cv2.mean(img)\n\tif img is None:\n\t\tprint \"ERROR: MeanValue: Sent in None-Type Object\"\n\t\treturn -1\n\tif len(img.shape) == 3:\n\t\treturn (mean[0], mean[1], mean[2])\n\telif len(img.shape) == 2:\n\t\treturn (mean[0])\n\telse:\n\t\treturn mean","def get_average_mark(self, test):\n return","def mare(self) -> float:\n return float(np.mean(np.abs(self._error(self.true, self.predicted) / self.true)))","def modelmean(self, model_params, this_data, this_suff_stat):\n pass","def meanAP(gt_box, pred_box, labelsPred, labelsTrue):\n # pred_box = getBoxFromHeatMap(pred_heatMap)\n softmax = nn.Softmax(dim=1)\n labelsPred = softmax(labelsPred)\n confidenceCorrectLabel = torch.tensor([labelsPred[i][labelsTrue[i]] for i in range(0, len(labelsTrue))])\n iou, intersection, union, binaryIOU = intersection_over_union(gt_box, pred_box)\n limits = np.arange(start=0.0, stop=1.0, step=0.05)\n precicions=[]\n for limit in limits:\n corrects = 0\n for j in range(0, len(labelsTrue)):\n if confidenceCorrectLabel[j] >= limit and (iou[j] >= 0.5 or labelsTrue[j] == 0):\n corrects += 1\n precicion = corrects/len(labelsTrue)\n precicions.append(precicion)\n mAP = np.mean(np.array(precicions))\n return mAP","def should_average(self):\n return self._should_average","def value(self):\n if self.buffer:\n return np.mean([ep['l'] for ep in self.buffer])\n else:\n return 0","def get_mean(self, X):\n raise NotImplementedError","def conditional_mean(self, F):\n raise NotImplementedError","def getAvg(self):\r\n\t\tdata = self.pair.data\r\n\t\tif data['avg'] == None:\r\n\t\t\treturn None\r\n\t\treturn 1. / self.pair.data['avg']","def get_mean(cls, data: tuple or list) -> float:\n cls._data_validation(data)\n sum_ = fsum(data)\n n = cls.get_n(data)\n try:\n return float(sum_ / n)\n except ZeroDivisionError as exc:\n # for hyp score calculation, n = 0 for empty set is useful\n return 0","def mean(self):\n return self._lift(\"mean\")","def calc_mean(sig):\n # m = mean(sig)\n return np.mean(sig)","def calculate(self):\n\n gt = self.ground_truth.flatten()\n seg = self.segmentation.flatten()\n\n n = gt.size\n mean_gt = gt.mean()\n mean_seg = seg.mean()\n mean = (mean_gt + mean_seg) / 2\n\n m = (gt + seg) / 2\n ssw = np.power(gt - m, 2).sum() + np.power(seg - m, 2).sum()\n ssb = np.power(m - mean, 2).sum()\n\n ssw /= n\n ssb = ssb / (n - 1) * 2\n\n return (ssb - ssw) / (ssb + ssw)","def get_mean(self):\n raise NotImplementedError(\"This is an abstract method and needs to be implemented in derived classes.\")","def test_roi_averaging(self):\n filename = get_test_data_path() + 'sgacc_mask.nii.gz'\n regions = self.dataset.masker.mask(filename, in_global_mask=True)\n avg_vox = reduce.average_within_regions(self.dataset, regions)\n n_studies = self.dataset.image_table.data.shape[1]\n self.assertEqual(n_studies, avg_vox.shape[1])\n self.assertGreater(avg_vox.sum(), 0.05)","def avgX(self):\n return np.mean(self.getx())","def calculateAverage(self, data):\n\n nValidTrials = data['nValid'][-1]\n nRewardTrials = data['nRewarded'][-1]\n return float(nRewardTrials)/nValidTrials","def average(self):\n return self.summation() / self.count()","def get_ave(self, recalc=False):\n if self.ave is not None and not recalc:\n return self.ave\n\n self.ave = np.mean(self.img.ravel())\n return self.ave","def select_data(\n self, flag_mean: bool\n ) -> np.ndarray[tuple[Ifm, Chn], np.float64]:\n return self.mean if flag_mean else self.data","def gmrae(self, benchmark: np.ndarray = None) -> float:\n return _geometric_mean(np.abs(self._relative_error(benchmark)))","def calculate(self):\n\n gt_n = np.count_nonzero(self.ground_truth)\n gt_indices = np.flip(np.where(self.ground_truth == 1), axis=0)\n gt_mean = gt_indices.mean(axis=1)\n gt_cov = np.cov(gt_indices)\n\n seg_n = np.count_nonzero(self.segmentation)\n seg_indices = np.flip(np.where(self.segmentation == 1), axis=0)\n seg_mean = seg_indices.mean(axis=1)\n seg_cov = np.cov(seg_indices)\n\n # calculate common covariance matrix\n common_cov = (gt_n * gt_cov + seg_n * seg_cov) / (gt_n + seg_n)\n common_cov_inv = np.linalg.inv(common_cov)\n\n mean = np.matrix(np.array(gt_mean) - np.array(seg_mean))\n\n return math.sqrt(mean * np.matrix(common_cov_inv) * mean.T)","def testMeanClip(self):\n stats = afwMath.makeStatistics(self.image, afwMath.MEANCLIP)\n self.assertEqual(stats.getValue(afwMath.MEANCLIP), self.val)","def calculate(self):\n self.results['max'] = numpy.max(self.data)\n self.results['min'] = numpy.min(self.data)\n if self.type == 0:\n self.group_discrete_data()\n if self.type == 1:\n self.group_continuous_data()\n\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences)\n self.results['quadAvg'] = math.sqrt(\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n if self.results['min'] > 0:\n self.results['geoAvg'] = math.exp(\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n self.results['harmAvg'] = 1 / self.average(\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\n self.totalOccurrences)\n else:\n self.results['geoAvg'] = self.results['harmAvg'] = \"N/A\"\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\n self.occurrences, 4)\n self.results['std'] = self.average(\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\n self.totalOccurrences)","def _get_mean_value(self, pos, var, method='median'):\n x = []\n for k in self.pos:\n if (self.pos[k] == pos) & ('_' + var + '_' in k):\n x.append(self.data[k])\n x = np.asarray(x)\n\n if method == 'median':\n return np.median(x) # todo unittest for this!\n elif method == 'mean':\n return x.mean()\n else:\n raise ValueError('Invalid option in _get_mean_value() %s' % method)","def test_mean(self):\n pass","def test_mean(self):\n pass","def global_mean(self):\n return self.interaction_data.label.mean()","def mean(self) -> typing.Tuple[float, float]:\r\n self.clean_window()\r\n return (\r\n (self.sum_frames_rec / self.window_size),\r\n (self.sum_frames_proc / self.window_size)\r\n )","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def _mean_prediction(op, g_td, y_train):\n fl, ufl = _make_flatten_uflatten(g_td, y_train)\n\n mean_pred = op(fl(y_train))\n mean_pred = np.dot(g_td, mean_pred)\n return ufl(mean_pred)","def value(self):\n if self.buffer:\n return np.mean([ep['r'] for ep in self.buffer])\n else:\n return 0.0","def mean(self, avg=True):\n if not self.fp_init:\n if not avg:\n return self._calc_mean(self.f, self.a, self.b, self.Z)\n else:\n return self._calc_mean(self.f_avg, self.a_avg, self.b_avg,\n self.Z_avg)\n return self._mean if not avg else self._mean_avg","def average(self):\n return (self.current + self.last) / 2.0","def mask_and_fit(mask, binary_warped, flag):\n img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)\n x, y = extract_pixels(img)\n fit, foundFlag, confidence_index = check_and_fit(x, y, flag)\n return fit, foundFlag, confidence_index","def mape(true, predictions):\n true = np.array(true)\n predictions = np.array(predictions) \n return np.mean(np.abs((true - predictions)) / true) * 100","def calculate(data, data_top):\n size, intensity, age = np.array([data[\"Size\"]]), np.array([data[\"Intensity\"]]), data_top.iat[1,0]\n size_avg, intensity_avg = np.average(size), np.average(intensity)\n return size_avg, intensity_avg, age","def get_mean(self):\n return self.serie.mean()","def mean(self) -> FrameLike:\n return super().mean()","def mean(self) -> FrameLike:\n return super().mean()","def mean(self) -> FrameLike:\n return super().mean()","def mean(self) -> FrameLike:\n return super().mean()","def mean(self) -> FrameLike:\n return super().mean()","def mean(self) -> FrameLike:\n return super().mean()","def get_normal_acc(self, normal_all_pass):\n normal_tups = self.operator.normal\n num_normal = len(normal_tups)\n filtered_normal_tups = normal_tups[normal_all_pass]\n\n both_acc = sum(1 for _, XpC in filtered_normal_tups if XpC)/num_normal\n det_only_acc = sum(1 for XC, XpC in filtered_normal_tups if XC)/num_normal\n ref_only_acc = sum([1 for _, XpC in normal_tups if XpC])/num_normal\n none_acc = sum([1 for XC, _ in normal_tups if XC])/num_normal\n\n return both_acc, det_only_acc, ref_only_acc, none_acc","def getMeanE(self):\n\n\n\t\tEBefore, EAfter = self.getEnergyEvolution()\n\n\t\tmeanBefore = np.mean(EBefore[-self.__Nkicks//5:])\n\t\tmeanAfter = np.mean(EAfter[-self.__Nkicks//5:])\n\t\tmeanTot = (meanBefore+meanAfter)/2\n\n\t\treturn meanBefore, meanAfter, meanTot","def get_brightness(img,mask):\r\n\r\n bright = cv2.meanStdDev(img, mask=mask)\r\n return {\"bright_avg\":bright[0][0,0],\"bright_sd\":bright[1][0,0]}","def get_reward(self, physics):\n current_mask = np.any(self.image < 100, axis=-1).astype(int)\n area = np.sum(current_mask * self.mask)\n reward = area / np.sum(self.mask)\n\n return reward","def mean(self):\n return self._mean","def mean(self):\n return self._mean","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)"],"string":"[\n \"def _mask_and_avg(values, padding_mask):\\n\\tdec_lens = torch.sum(padding_mask,dim=1)\\n\\tlosses = torch.stack(values, dim=1)\\n\\tlosses = losses * padding_mask\\n\\tvalues_per_ex = torch.sum(losses, dim=1)/dec_lens\\n\\treturn torch.sum(values_per_ex)\",\n \"def mean(self):\\n\\n\\t\\tif not self._masked:\\n\\t\\t\\t\\n\\t\\t\\treturn self.data.mean()\\n\\t\\t\\n\\t\\telse:\\n\\t\\t\\t\\n\\t\\t\\tif not hasattr(self,\\\"_full_mask\\\"):\\n\\t\\t\\t\\tself.maskBoundaries()\\n\\t\\t\\t\\n\\t\\t\\treturn self.data[self._full_mask].mean()\",\n \"def _get_mean(self):\\n return self._get_conditional_negative_energy()\",\n \"def right_or_left(self): \\n right_sum = 0\\n right_avg = 0\\n left_sum = 0\\n left_avg = 0\\n self.scan()\\n for angle in self.scan_data:\\n if angle < self.MIDPOINT:\\n right_sum += self.scan_data[angle]\\n right_avg += 1\\n else: \\n left_avg += self.scan_data[angle]\\n left_avg += 1\\n\\n left_avg = left_sum / left_avg \\n right_avg = right_sum / right_avg\\n\\n if left_avg > right_avg: \\n return 'l' \\n else:\\n return 'r'\",\n \"def get_mean(self):\\n self.meanval = np.mean(self.adulist)\",\n \"def mean_baseline(d, mode='test'):\\n m = d.trainY.mean()\\n y = getattr(d, mode + \\\"Y\\\")\\n preds = np.array([m] * y.shape[0])\\n return (get_mse(d, preds, mode), get_mae(d, preds, mode),\\n get_mape(d, preds, mode))\",\n \"def measure(mode, x, y, x0, x1):\\n xm = ma.masked_outside(x, x0, x1)\\n ym = ma.array(y, mask = ma.getmask(xm))\\n if mode == 'mean':\\n r1 = ma.mean(ym)\\n r2 = ma.std(ym)\\n if mode == 'max':\\n r1 = ma.max(ym)\\n r2 = 0\\n if mode == 'min':\\n r1 = ma.min(ym)\\n r2 = 0\\n if mode == 'median':\\n r1 = ma.median(ym)\\n r2 = 0\\n if mode == 'p2p': # peak to peak\\n r1 = ma.ptp(ym)\\n r2 = 0\\n return(r1, r2)\",\n \"def _get_average(self):\\n norm = 1.0\\n for pos, idx in enumerate(self.idx):\\n norm *= (self.high[pos] - self.low[pos])\\n return 1.0/norm\",\n \"def _get_mean(self):\\n mu = self._get_conditional_negative_energy()\\n return sigmoid(mu)\",\n \"def _mask_and_avg(values, padding_mask):\\n\\n dec_lens = tf.reduce_sum(padding_mask, axis=1) # shape batch_size. float32\\n values_per_step = [v * padding_mask[:,dec_step] for dec_step,v in enumerate(values)]\\n values_per_ex = sum(values_per_step)/dec_lens # shape (batch_size); normalized value for each batch member\\n return tf.reduce_mean(values_per_ex) # overall average\",\n \"def update_average_best_fit(self):\\r\\n # print(result_buffer)\\r\\n total = len(self.result_buffer)\\r\\n left_fit, right_fit = np.empty((0, 3)), np.empty((0, 3))\\r\\n left_curve_rad, right_curve_rad = [], []\\r\\n vehicle_offset = []\\r\\n for i in range(total):\\r\\n calc_fit_dict = self.result_buffer[i]\\r\\n left_fit = np.append(left_fit, [calc_fit_dict['left_fit']], axis=0)\\r\\n right_fit = np.append(right_fit, [calc_fit_dict['right_fit']], axis=0)\\r\\n left_curve_rad.append(calc_fit_dict['left_curve_rad'])\\r\\n right_curve_rad.append(calc_fit_dict['right_curve_rad'])\\r\\n vehicle_offset.append(calc_fit_dict['vehicle_offset'])\\r\\n self.avg_fit_dict['left_fit'] = np.mean(left_fit, axis=0)\\r\\n self.avg_fit_dict['right_fit'] = np.mean(right_fit, axis=0)\\r\\n self.avg_fit_dict['left_curve_rad'] = np.mean(left_curve_rad)\\r\\n self.avg_fit_dict['right_curve_rad'] = np.mean(right_curve_rad)\\r\\n self.avg_fit_dict['vehicle_offset'] = np.mean(vehicle_offset)\\r\\n # print(avg_fit_dict)\\r\\n return\",\n \"def mean_average_position():\\n pass\",\n \"def _get_reference_fit(self, img):\\n bw_img = 255 * (img >= self.contrast)\\n fit = [center_on_box(bw_img, self.radius, self.min_ref, *ref) for ref in self.refzone]\\n meanfit = num.mean(num.ma.masked_array(fit, fit == -9999), axis=0).astype('i')\\n if meanfit[0] is num.ma.masked:\\n raise StandardError('At least one reference box match required')\\n\\n return meanfit, fit\",\n \"def _ave(self):\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def mean(vals):\",\n \"def mean(self, weight_by_area=True):\\n if weight_by_area:\\n return self.integral() / self.indicator.integral()\\n else:\\n return self.sum() / self.indicator.sum()\",\n \"def calculate_mean(self) -> float:\\n\\n if self.data:\\n return np.mean(self.data)\\n else:\\n return self.mu\",\n \"def _ave(self):\\n\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def _get_mean(self):\\n return (0.485, 0.456, 0.406)\",\n \"def measure(mode, x, y, x0, x1, thresh = 0):\\n xt = x.view(numpy.ndarray) # strip Metaarray stuff -much faster!\\n v = y.view(numpy.ndarray)\\n \\n xm = ma.masked_outside(xt, x0, x1).T\\n ym = ma.array(v, mask = ma.getmask(xm))\\n if mode == 'mean':\\n r1 = ma.mean(ym)\\n r2 = ma.std(ym)\\n if mode == 'max' or mode == 'maximum':\\n r1 = ma.max(ym)\\n r2 = xm[ma.argmax(ym)]\\n if mode == 'min' or mode == 'minimum':\\n r1 = ma.min(ym)\\n r2 = xm[ma.argmin(ym)]\\n if mode == 'median':\\n r1 = ma.median(ym)\\n r2 = 0\\n if mode == 'p2p': # peak to peak\\n r1 = ma.ptp(ym)\\n r2 = 0\\n if mode == 'std': # standard deviation\\n r1 = ma.std(ym)\\n r2 = 0\\n if mode == 'var': # variance\\n r1 = ma.var(ym)\\n r2 = 0\\n if mode == 'cumsum': # cumulative sum\\n r1 = ma.cumsum(ym) # Note: returns an array\\n r2 = 0\\n if mode == 'anom': # anomalies = difference from averge\\n r1 = ma.anom(ym) # returns an array\\n r2 = 0\\n if mode == 'sum':\\n r1 = ma.sum(ym)\\n r2 = 0\\n if mode == 'area' or mode == 'charge':\\n r1 = ma.sum(ym)/(ma.max(xm)-ma.min(xm))\\n r2 = 0\\n if mode == 'latency': # return first point that is > threshold\\n sm = ma.nonzero(ym > thresh)\\n r1 = -1 # use this to indicate no event detected\\n r2 = 0\\n if ma.count(sm) > 0:\\n r1 = sm[0][0]\\n r2 = len(sm[0])\\n if mode == 'count':\\n r1 = ma.count(ym)\\n r2 = 0\\n if mode == 'maxslope':\\n return(0,0)\\n slope = numpy.array([])\\n win = ma.flatnotmasked_contiguous(ym)\\n st = int(len(win)/20) # look over small ranges\\n for k in win: # move through the slope measurementwindow\\n tb = range(k-st, k+st) # get tb array\\n newa = numpy.array(self.dat[i][j, thisaxis, tb])\\n ppars = numpy.polyfit(x[tb], ym[tb], 1) # do a linear fit - smooths the slope measures\\n slope = numpy.append(slope, ppars[0]) # keep track of max slope\\n r1 = numpy.amax(slope)\\n r2 = numpy.argmax(slope)\\n return(r1, r2)\",\n \"def mean(self):\\r\\n\\t\\treturn sum(self.sample)/len(self.sample)\",\n \"def mean(image, selem, out=None, mask=None, shift_x=False, shift_y=False):\\n\\n return _apply(_crank8.mean, _crank16.mean, image, selem, out=out,\\n mask=mask, shift_x=shift_x, shift_y=shift_y)\",\n \"def mean(self):\\n return self.cond_proba.mean\",\n \"def meanEnergy(self, count=False):\\n \\n _E = (self.E).groupby(pd.cut(self.E, self.binEdges))\\n try:\\n def wm(x):\\n try:\\n return np.average(x, weights=self.Weight.loc[x.index])\\n except ZeroDivisionError:\\n return np.nan\\n wc = lambda x: np.sum(self.Weight.loc[x.index])\\n if count:\\n E_count = _E.apply(wc)\\n E_mean = _E.apply(wm)\\n except AttributeError:\\n if count:\\n E_count = _E.count()\\n E_mean = _E.mean()\\n \\n E_masked = np.ma.masked_invalid(E_mean)\\n \\n if count:\\n C_masked = np.ma.masked_array(E_count, mask=E_masked.mask)\\n return C_masked, E_masked\\n return E_masked\",\n \"def masked_mean(x: torch.FloatTensor, m: torch.BoolTensor):\\n if m.bool().sum() == len(m):\\n return torch.full((1, ), fill_value=float('inf'), device=x.device)\\n return x[m.bool()].mean()\",\n \"def compute_means(opts, train_data, sampler):\\n exp_names = train_data[\\\"exp_names\\\"].value\\n means = []\\n stds = []\\n if opts[\\\"flags\\\"].normalize is True:\\n running_stats = []\\n # a running stat for each channel\\n running_stats = RunningStats(3)\\n # loop over the experiments\\n\\n # for exp_name in exp_names:\\n for j in range(0, len(exp_names), 2):\\n batch = sampler.get_minibatch()\\n exp_name = batch[2][0]\\n print(exp_name)\\n # loop over the keys\\n\\n seq_len = train_data[\\\"exps\\\"][exp_name][\\\"labels\\\"].shape[0]\\n temp_feat = batch[0].cpu().numpy()\\n temp_feat = temp_feat[:seq_len, :, :, :]\\n\\n channel_feats = []\\n for i in range(3):\\n # channel_feat = temp_feat[0, :, i, :]\\n # sample frames\\n channel_feat = temp_feat[::100, i, :]\\n channel_feat = channel_feat.reshape(-1, 1)\\n channel_feats.append(channel_feat)\\n\\n channel_feats = np.concatenate(channel_feats, axis=1)\\n running_stats.add_data(\\n channel_feat\\n )\\n\\n means = running_stats.mean.tolist()\\n stds = running_stats.compute_std().tolist()\\n else:\\n means = [.5, .5, .5]\\n stds = [1, 1, 1]\\n # for key in opts[\\\"flags\\\"].feat_keys:\\n # temp_feat = train_data[\\\"exps\\\"][exp_names[0]][key].value\\n # mean = np.zeros((temp_feat.shape[2], ))\\n # std = np.ones((temp_feat.shape[2], ))\\n # means.append(mean)\\n # stds.append(std)\\n normalize = transforms.Normalize(mean=means,\\n std=stds)\\n\\n return normalize\",\n \"def getMean(self):\\n return self.mean\",\n \"def get_fitness_mean(self):\\n return self.get_fitness_stat(mean)\",\n \"def get_mean(self):\\n mean = np.array(np.zeros((4,8)))\\n for i,c in enumerate(self.cellLines):\\n for j,l in enumerate(self.ligands):\\n mean[i][j] = self.aucs[c][l]['mean']\\n return mean\",\n \"def mean_absolute_percentage_error(y_true, y_pred, sample_weight=..., multioutput=...):\\n ...\",\n \"def calculate_mean(cls, sensor):\\n try:\\n if sensor == 't':\\n return cls.calculate_y_pos(sum(cls.mean_t) / len(cls.mean_t), sensor)\\n if sensor == 'l':\\n return cls.calculate_y_pos(sum(cls.mean_l) / len(cls.mean_l), sensor)\\n except ZeroDivisionError:\\n return None\",\n \"def mean_height(data):\",\n \"def mean_height(data):\",\n \"def mean_STD(self,counter):\\n \\n \\n pass\",\n \"def get_mean_accuracy(self):\\n return self.df.correct.mean()\",\n \"def mean_absolute_error(y_true, y_pred, *, sample_weight=..., multioutput=...):\\n ...\",\n \"def em_mean(self) -> float:\\n if self.__total_pulls == 0:\\n raise Exception('Number of pulls is 0. No empirical mean.')\\n return self.__total_rewards / self.__total_pulls\",\n \"def mean(self):\\n return self.vmean\",\n \"def mean(self):\\n return self.sum / self.sum_weights\",\n \"def mean_std_calc(dataloader):\\n mean = 0\\n std = 0\\n samples = 0\\n for data, _, _ in dataloader:\\n batch_samples = data.size(0)\\n data = data.view(batch_samples, data.size(1), -1)\\n mean += data.mean(2).sum(0)\\n std += data.std(2).sum(0)\\n samples += batch_samples\\n\\n return (mean / samples),(std / samples)\",\n \"def _get_mean(self):\\n return [layer._get_mean() for layer in self.layers]\",\n \"def conditional_mean(self, gp):\\n raise NotImplementedError\",\n \"def getMean(self, field):\\n\\n return np.mean([self.fitnesses[i][field] for i in range(len(self.fitnesses))])\",\n \"def get_mean(self):\\n return numpy.mean(self._x) - numpy.mean(self._y)\",\n \"def get_means(self):\\n if self.cv_method == 'fixed':\\n perf = np.mean(self.evaluations, axis=0)\\n perf = np.nanmean(perf, axis=-1)\\n elif self.cv_method == 'crossvalidation':\\n perf = np.mean(self.evaluations, axis=0)\\n perf = np.nanmean(perf, axis=-1)\\n else:\\n perf = self.evaluations\\n while len(perf.shape) > 2:\\n perf = np.nanmean(perf, axis=-1)\\n perf = perf[~np.isnan(perf[:, 0])]\\n perf = np.mean(perf, axis=0)\\n return perf\",\n \"def rmae (y_true, y_pred):\\n return tf.math.reduce_mean(tf.math.abs(y_true-y_pred)/y_true)\",\n \"def meanVal(img):\\n\\tmean = cv2.mean(img)\\n\\tif img is None:\\n\\t\\tprint \\\"ERROR: MeanValue: Sent in None-Type Object\\\"\\n\\t\\treturn -1\\n\\tif len(img.shape) == 3:\\n\\t\\treturn (mean[0], mean[1], mean[2])\\n\\telif len(img.shape) == 2:\\n\\t\\treturn (mean[0])\\n\\telse:\\n\\t\\treturn mean\",\n \"def get_average_mark(self, test):\\n return\",\n \"def mare(self) -> float:\\n return float(np.mean(np.abs(self._error(self.true, self.predicted) / self.true)))\",\n \"def modelmean(self, model_params, this_data, this_suff_stat):\\n pass\",\n \"def meanAP(gt_box, pred_box, labelsPred, labelsTrue):\\n # pred_box = getBoxFromHeatMap(pred_heatMap)\\n softmax = nn.Softmax(dim=1)\\n labelsPred = softmax(labelsPred)\\n confidenceCorrectLabel = torch.tensor([labelsPred[i][labelsTrue[i]] for i in range(0, len(labelsTrue))])\\n iou, intersection, union, binaryIOU = intersection_over_union(gt_box, pred_box)\\n limits = np.arange(start=0.0, stop=1.0, step=0.05)\\n precicions=[]\\n for limit in limits:\\n corrects = 0\\n for j in range(0, len(labelsTrue)):\\n if confidenceCorrectLabel[j] >= limit and (iou[j] >= 0.5 or labelsTrue[j] == 0):\\n corrects += 1\\n precicion = corrects/len(labelsTrue)\\n precicions.append(precicion)\\n mAP = np.mean(np.array(precicions))\\n return mAP\",\n \"def should_average(self):\\n return self._should_average\",\n \"def value(self):\\n if self.buffer:\\n return np.mean([ep['l'] for ep in self.buffer])\\n else:\\n return 0\",\n \"def get_mean(self, X):\\n raise NotImplementedError\",\n \"def conditional_mean(self, F):\\n raise NotImplementedError\",\n \"def getAvg(self):\\r\\n\\t\\tdata = self.pair.data\\r\\n\\t\\tif data['avg'] == None:\\r\\n\\t\\t\\treturn None\\r\\n\\t\\treturn 1. / self.pair.data['avg']\",\n \"def get_mean(cls, data: tuple or list) -> float:\\n cls._data_validation(data)\\n sum_ = fsum(data)\\n n = cls.get_n(data)\\n try:\\n return float(sum_ / n)\\n except ZeroDivisionError as exc:\\n # for hyp score calculation, n = 0 for empty set is useful\\n return 0\",\n \"def mean(self):\\n return self._lift(\\\"mean\\\")\",\n \"def calc_mean(sig):\\n # m = mean(sig)\\n return np.mean(sig)\",\n \"def calculate(self):\\n\\n gt = self.ground_truth.flatten()\\n seg = self.segmentation.flatten()\\n\\n n = gt.size\\n mean_gt = gt.mean()\\n mean_seg = seg.mean()\\n mean = (mean_gt + mean_seg) / 2\\n\\n m = (gt + seg) / 2\\n ssw = np.power(gt - m, 2).sum() + np.power(seg - m, 2).sum()\\n ssb = np.power(m - mean, 2).sum()\\n\\n ssw /= n\\n ssb = ssb / (n - 1) * 2\\n\\n return (ssb - ssw) / (ssb + ssw)\",\n \"def get_mean(self):\\n raise NotImplementedError(\\\"This is an abstract method and needs to be implemented in derived classes.\\\")\",\n \"def test_roi_averaging(self):\\n filename = get_test_data_path() + 'sgacc_mask.nii.gz'\\n regions = self.dataset.masker.mask(filename, in_global_mask=True)\\n avg_vox = reduce.average_within_regions(self.dataset, regions)\\n n_studies = self.dataset.image_table.data.shape[1]\\n self.assertEqual(n_studies, avg_vox.shape[1])\\n self.assertGreater(avg_vox.sum(), 0.05)\",\n \"def avgX(self):\\n return np.mean(self.getx())\",\n \"def calculateAverage(self, data):\\n\\n nValidTrials = data['nValid'][-1]\\n nRewardTrials = data['nRewarded'][-1]\\n return float(nRewardTrials)/nValidTrials\",\n \"def average(self):\\n return self.summation() / self.count()\",\n \"def get_ave(self, recalc=False):\\n if self.ave is not None and not recalc:\\n return self.ave\\n\\n self.ave = np.mean(self.img.ravel())\\n return self.ave\",\n \"def select_data(\\n self, flag_mean: bool\\n ) -> np.ndarray[tuple[Ifm, Chn], np.float64]:\\n return self.mean if flag_mean else self.data\",\n \"def gmrae(self, benchmark: np.ndarray = None) -> float:\\n return _geometric_mean(np.abs(self._relative_error(benchmark)))\",\n \"def calculate(self):\\n\\n gt_n = np.count_nonzero(self.ground_truth)\\n gt_indices = np.flip(np.where(self.ground_truth == 1), axis=0)\\n gt_mean = gt_indices.mean(axis=1)\\n gt_cov = np.cov(gt_indices)\\n\\n seg_n = np.count_nonzero(self.segmentation)\\n seg_indices = np.flip(np.where(self.segmentation == 1), axis=0)\\n seg_mean = seg_indices.mean(axis=1)\\n seg_cov = np.cov(seg_indices)\\n\\n # calculate common covariance matrix\\n common_cov = (gt_n * gt_cov + seg_n * seg_cov) / (gt_n + seg_n)\\n common_cov_inv = np.linalg.inv(common_cov)\\n\\n mean = np.matrix(np.array(gt_mean) - np.array(seg_mean))\\n\\n return math.sqrt(mean * np.matrix(common_cov_inv) * mean.T)\",\n \"def testMeanClip(self):\\n stats = afwMath.makeStatistics(self.image, afwMath.MEANCLIP)\\n self.assertEqual(stats.getValue(afwMath.MEANCLIP), self.val)\",\n \"def calculate(self):\\n self.results['max'] = numpy.max(self.data)\\n self.results['min'] = numpy.min(self.data)\\n if self.type == 0:\\n self.group_discrete_data()\\n if self.type == 1:\\n self.group_continuous_data()\\n\\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences)\\n self.results['quadAvg'] = math.sqrt(\\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n if self.results['min'] > 0:\\n self.results['geoAvg'] = math.exp(\\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n self.results['harmAvg'] = 1 / self.average(\\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\\n self.totalOccurrences)\\n else:\\n self.results['geoAvg'] = self.results['harmAvg'] = \\\"N/A\\\"\\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\\n self.occurrences, 4)\\n self.results['std'] = self.average(\\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\\n self.totalOccurrences)\",\n \"def _get_mean_value(self, pos, var, method='median'):\\n x = []\\n for k in self.pos:\\n if (self.pos[k] == pos) & ('_' + var + '_' in k):\\n x.append(self.data[k])\\n x = np.asarray(x)\\n\\n if method == 'median':\\n return np.median(x) # todo unittest for this!\\n elif method == 'mean':\\n return x.mean()\\n else:\\n raise ValueError('Invalid option in _get_mean_value() %s' % method)\",\n \"def test_mean(self):\\n pass\",\n \"def test_mean(self):\\n pass\",\n \"def global_mean(self):\\n return self.interaction_data.label.mean()\",\n \"def mean(self) -> typing.Tuple[float, float]:\\r\\n self.clean_window()\\r\\n return (\\r\\n (self.sum_frames_rec / self.window_size),\\r\\n (self.sum_frames_proc / self.window_size)\\r\\n )\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def _mean_prediction(op, g_td, y_train):\\n fl, ufl = _make_flatten_uflatten(g_td, y_train)\\n\\n mean_pred = op(fl(y_train))\\n mean_pred = np.dot(g_td, mean_pred)\\n return ufl(mean_pred)\",\n \"def value(self):\\n if self.buffer:\\n return np.mean([ep['r'] for ep in self.buffer])\\n else:\\n return 0.0\",\n \"def mean(self, avg=True):\\n if not self.fp_init:\\n if not avg:\\n return self._calc_mean(self.f, self.a, self.b, self.Z)\\n else:\\n return self._calc_mean(self.f_avg, self.a_avg, self.b_avg,\\n self.Z_avg)\\n return self._mean if not avg else self._mean_avg\",\n \"def average(self):\\n return (self.current + self.last) / 2.0\",\n \"def mask_and_fit(mask, binary_warped, flag):\\n img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)\\n x, y = extract_pixels(img)\\n fit, foundFlag, confidence_index = check_and_fit(x, y, flag)\\n return fit, foundFlag, confidence_index\",\n \"def mape(true, predictions):\\n true = np.array(true)\\n predictions = np.array(predictions) \\n return np.mean(np.abs((true - predictions)) / true) * 100\",\n \"def calculate(data, data_top):\\n size, intensity, age = np.array([data[\\\"Size\\\"]]), np.array([data[\\\"Intensity\\\"]]), data_top.iat[1,0]\\n size_avg, intensity_avg = np.average(size), np.average(intensity)\\n return size_avg, intensity_avg, age\",\n \"def get_mean(self):\\n return self.serie.mean()\",\n \"def mean(self) -> FrameLike:\\n return super().mean()\",\n \"def mean(self) -> FrameLike:\\n return super().mean()\",\n \"def mean(self) -> FrameLike:\\n return super().mean()\",\n \"def mean(self) -> FrameLike:\\n return super().mean()\",\n \"def mean(self) -> FrameLike:\\n return super().mean()\",\n \"def mean(self) -> FrameLike:\\n return super().mean()\",\n \"def get_normal_acc(self, normal_all_pass):\\n normal_tups = self.operator.normal\\n num_normal = len(normal_tups)\\n filtered_normal_tups = normal_tups[normal_all_pass]\\n\\n both_acc = sum(1 for _, XpC in filtered_normal_tups if XpC)/num_normal\\n det_only_acc = sum(1 for XC, XpC in filtered_normal_tups if XC)/num_normal\\n ref_only_acc = sum([1 for _, XpC in normal_tups if XpC])/num_normal\\n none_acc = sum([1 for XC, _ in normal_tups if XC])/num_normal\\n\\n return both_acc, det_only_acc, ref_only_acc, none_acc\",\n \"def getMeanE(self):\\n\\n\\n\\t\\tEBefore, EAfter = self.getEnergyEvolution()\\n\\n\\t\\tmeanBefore = np.mean(EBefore[-self.__Nkicks//5:])\\n\\t\\tmeanAfter = np.mean(EAfter[-self.__Nkicks//5:])\\n\\t\\tmeanTot = (meanBefore+meanAfter)/2\\n\\n\\t\\treturn meanBefore, meanAfter, meanTot\",\n \"def get_brightness(img,mask):\\r\\n\\r\\n bright = cv2.meanStdDev(img, mask=mask)\\r\\n return {\\\"bright_avg\\\":bright[0][0,0],\\\"bright_sd\\\":bright[1][0,0]}\",\n \"def get_reward(self, physics):\\n current_mask = np.any(self.image < 100, axis=-1).astype(int)\\n area = np.sum(current_mask * self.mask)\\n reward = area / np.sum(self.mask)\\n\\n return reward\",\n \"def mean(self):\\n return self._mean\",\n \"def mean(self):\\n return self._mean\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60307616","0.59903556","0.5989535","0.5927027","0.58250964","0.58250463","0.58083445","0.5792237","0.57348174","0.57280666","0.57189894","0.571298","0.56587595","0.5591607","0.5536695","0.55357367","0.5512962","0.55089694","0.5496177","0.5463986","0.54556686","0.5437334","0.5435072","0.5426911","0.541448","0.54117227","0.53799963","0.5377896","0.5362354","0.53585285","0.5339502","0.5316522","0.5316522","0.53122836","0.5297703","0.5297405","0.52923375","0.5289062","0.52758145","0.52680725","0.52665204","0.5265928","0.5262363","0.526048","0.52547526","0.52545947","0.5251635","0.5245547","0.5239668","0.52376515","0.523623","0.52160084","0.5214122","0.52140856","0.520621","0.5203388","0.5189898","0.5184188","0.51818544","0.51787776","0.5174963","0.5173974","0.5170686","0.51585704","0.5154515","0.5152993","0.51518065","0.51466465","0.5145435","0.51430607","0.51339537","0.5132379","0.512989","0.512989","0.5127547","0.51258975","0.51208174","0.51208174","0.5118748","0.51149595","0.511308","0.51017946","0.5101754","0.5095304","0.5094659","0.50893074","0.50844055","0.50844055","0.50844055","0.50844055","0.50844055","0.50844055","0.5083596","0.50829864","0.50828314","0.5080781","0.507918","0.507918","0.50743353","0.50743353"],"string":"[\n \"0.60307616\",\n \"0.59903556\",\n \"0.5989535\",\n \"0.5927027\",\n \"0.58250964\",\n \"0.58250463\",\n \"0.58083445\",\n \"0.5792237\",\n \"0.57348174\",\n \"0.57280666\",\n \"0.57189894\",\n \"0.571298\",\n \"0.56587595\",\n \"0.5591607\",\n \"0.5536695\",\n \"0.55357367\",\n \"0.5512962\",\n \"0.55089694\",\n \"0.5496177\",\n \"0.5463986\",\n \"0.54556686\",\n \"0.5437334\",\n \"0.5435072\",\n \"0.5426911\",\n \"0.541448\",\n \"0.54117227\",\n \"0.53799963\",\n \"0.5377896\",\n \"0.5362354\",\n \"0.53585285\",\n \"0.5339502\",\n \"0.5316522\",\n \"0.5316522\",\n \"0.53122836\",\n \"0.5297703\",\n \"0.5297405\",\n \"0.52923375\",\n \"0.5289062\",\n \"0.52758145\",\n \"0.52680725\",\n \"0.52665204\",\n \"0.5265928\",\n \"0.5262363\",\n \"0.526048\",\n \"0.52547526\",\n \"0.52545947\",\n \"0.5251635\",\n \"0.5245547\",\n \"0.5239668\",\n \"0.52376515\",\n \"0.523623\",\n \"0.52160084\",\n \"0.5214122\",\n \"0.52140856\",\n \"0.520621\",\n \"0.5203388\",\n \"0.5189898\",\n \"0.5184188\",\n \"0.51818544\",\n \"0.51787776\",\n \"0.5174963\",\n \"0.5173974\",\n \"0.5170686\",\n \"0.51585704\",\n \"0.5154515\",\n \"0.5152993\",\n \"0.51518065\",\n \"0.51466465\",\n \"0.5145435\",\n \"0.51430607\",\n \"0.51339537\",\n \"0.5132379\",\n \"0.512989\",\n \"0.512989\",\n \"0.5127547\",\n \"0.51258975\",\n \"0.51208174\",\n \"0.51208174\",\n \"0.5118748\",\n \"0.51149595\",\n \"0.511308\",\n \"0.51017946\",\n \"0.5101754\",\n \"0.5095304\",\n \"0.5094659\",\n \"0.50893074\",\n \"0.50844055\",\n \"0.50844055\",\n \"0.50844055\",\n \"0.50844055\",\n \"0.50844055\",\n \"0.50844055\",\n \"0.5083596\",\n \"0.50829864\",\n \"0.50828314\",\n \"0.5080781\",\n \"0.507918\",\n \"0.507918\",\n \"0.50743353\",\n \"0.50743353\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7186115"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14793,"cells":{"query":{"kind":"string","value":"Gets the Last Fit depending on the flag"},"document":{"kind":"string","value":"def get_last_fit(flag='L'):\n if flag == 'L':\n return l_coeff_queue[-1]\n else:\n return r_coeff_queue[-1]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getFit(self):\n if self.fits.has_key('default'):\n return self.fits['default']\n else:\n return None","def last_fmeasure(self):\n return self.get_fvalue(self.last_position())","def get_last_saved_estimation(self):\n return None","def get_fit(self, space=False):\n\n if space:\n model_type = 'space'\n else:\n model_type = 'risk'\n\n fit_type = 'likelihood'\n\n fitter = self.fits[model_type].linear_fits[fit_type]\n\n return fitter","def get_last_save(self) -> Optional[float]:\n return None if self._save_marker is None else self._save_marker + self._offset","def get_last_measurement(self, param):\n return self.__buffer[param][-1]","def restore_last(self, points_x = None, points_y = None):\n\n # when calling with no parameter, we just keep the last state activated\n # and keep signaling a detected line to absorb small flaws of a few\n # frames - otherwise calculate with new input data\n\n # on new input points, reset and update lane\n if (points_x is not None) and (points_y is not None):\n #self.reset(self.roi_warped_points)\n self.update(points_x, points_y)\n\n return self.detected\n\n elif len(self.recent_fit) >= 2:\n # ensure detected\n self.detected = True\n\n # remove current broken fit from recent fits\n self.recent_fit = self.recent_fit[:-1]\n\n # make last valid recent fit to current fit\n self.current_fit = self.recent_fit[-1]\n\n # calculate new best fit\n sum = [np.array([False])]\n \"\"\"\n current_weight = self.max_n + 1\n divisor = 0\n\n for r in self.recent_fit:\n current_weight = current_weight - 1\n sum = sum + current_weight * r\n divisor = divisor + current_weight\n\n self.best_fit = (sum / divisor)[0]\n \"\"\"\n\n for r in self.recent_fit:\n sum = sum + r\n\n self.best_fit = (sum / len(self.recent_fit))[0]\n\n # re calculate diffs\n self.riffs = self.current_fit - self.best_fit\n\n # we need to re-calculate the metrics\n self.calculate_metrics()\n\n return True\n else:\n # if not, there's currently no way out\n return False","def getBestOption(self):\n if len(self.Data) < 1:\n return None\n else:\n bestR = max(self.Data.items(), key=lambda x: x[1]['SPat'].I)\n return bestR[1]","def get_lip_best(self) -> float:\n if self._fitted:\n if self._ready_lip_best:\n return self._lip_best\n else:\n lip_best = self._get_lip_best()\n self._set(\"_lip_best\", lip_best)\n self._set(\"_ready_lip_best\", True)\n return lip_best\n else:\n raise ValueError(\"call ``fit`` before calling ``get_lip_best``\")","def last_value(self):\n return self.samples[-1]","def best_step(self):\r\n return self._best_value_step","def is_fitted(self):\n\n return self.isFitted","def scatter_back_fit(self):\n return self._scatter_back_fit","def max_log_likelihood_fit(self) -> FitInterferometer:\r\n return self.analysis.fit_interferometer_via_instance_from(\r\n instance=self.instance\r\n )","def get_fit(self) -> np.poly1d:\n if self.log_fits is not None:\n return next(self.log_fits)\n x = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: [line.point1.y for line in m.marker_lines])\n .to_list()\n )\n y = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: [line.point1.x for line in m.marker_lines])\n .to_list()\n )\n if self.orientation == Orientation.UP_DOWN:\n fit = np.polyfit(x, y, 1)\n else:\n fit = np.polyfit(y, x, 1)\n return np.poly1d(fit)","def stop_fit(self):\n self._stop_fit = True","def get_last_solution(self):\n return self.last_result","def _get_max_estimated_bandit(self)->Bandit:\n # print(\"mus - \", self.mu)\n # print(\"actions - \", np.argmax(self.mu))\n unique, counts = np.unique(self.mu, return_counts=True)\n lens = counts[np.argmax(unique)] \n if lens>1: # if two actions have same argmax\n # then return arbitrarily from those max ones\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\n return np.random.choice(maxs)\n # otherwise return the max one\n return self.bandits[np.argmax(self.mu)]","def max_log_likelihood_fit(self) -> ag.FitQuantity:\r\n\r\n return self.analysis.fit_quantity_for_instance(instance=self.instance)","def last_percept(self):\n return self.percept","def _get_lip_best(self) -> float:\n pass","def best_value(self):\n return np.max(self.y.numpy())","def has_been_fit(self):\n return self.predictor.has_been_fit","def get_bestparameter(self):\n if self._df_test is None:\n raise RuntimeError('get_bestparameter: please the '\n 'train model first')\n mean = self._df_test.mean(axis=1)\n if len(mean) == 1:\n result = mean.idxmax()\n elif len(mean) == 2:\n result = mean.loc[mean.index > 1].idxmax()\n else:\n result = mean.loc[mean.index > 2].idxmax()\n return result","def get_bestparameter(self):\n if self._df_test is None:\n raise RuntimeError('get_bestparameter: please the '\n 'train model first')\n mean = self._df_test.mean(axis=1)\n if len(mean) == 1:\n result = mean.idxmax()\n elif len(mean) == 2:\n result = mean.loc[mean.index > 1].idxmax()\n else:\n result = mean.loc[mean.index > 2].idxmax()\n return result","def get_last_save(self) -> Optional[int]:\n return self._bin_iter.get_last_save()","def last_value(self):\n return self._stop","def get_score(self):\n return np.max(self._scores) if self._scores is not None else self._score_history[-1]","def last_hit(self):\n return self._last_hit","def is_fitted(self):\n return self.__fdata is not None","def getFitness(self):\n\n if self.extraAsFitness!=None:\n return self.extra[self.extraAsFitness]\n \n fit = self.getMeanFitness('F')\n if (np.isnan(fit)):\n return 0 \n return float(int(fit*1000.0))/1000.0","def get_last_save(self) -> Optional[int]:\n return self._save_marker","def _find_last_checkpoint(self):\n highest_num, last_checkpoint = -np.inf, None\n for filename in os.listdir(self.logdir):\n # checkpoints look like logdir/model.ckpt-N\n # self._save_path is \"logdir/model.ckpt\"\n if os.path.basename(self._save_path) in filename:\n try:\n N = int(filename.split(\"-\")[1].split(\".\")[0])\n if N > highest_num:\n highest_num = N\n last_checkpoint = \"model.ckpt-\" + str(N)\n except ValueError:\n pass\n return os.path.join(self.logdir, last_checkpoint)","def y_flag(self):\n if self.calibrationlog:\n self.calibrationlogflag = True\n self.calibrationlogtime = DEFAULT_CALIBRATIONLOG_TIME","def last_value(self):\n return self._waveforms[-1].last_value","def get_last(t_, w_):\n return t_ - tf.constant(1)","def __findBestLogProbability(self):\n best_model = None\n highest_log_probability = -sys.maxsize# (np.finfo(float).eps)\n\n # Find the highest model\n for item in self.data_array:\n if item[1] > highest_log_probability:\n best_model = item\n highest_log_probability = item[1]\n\n return best_model","def last_value(self):\n return 0","def get_last_lr(self) -> Tensor:\n\n return self.lr_scheduler.get_last_lr()","def getLastFunction(self) -> ghidra.program.model.listing.Function:\n ...","def checkBest(data):\n global filename, hyp\n if data.newBest is True:\n bestReps = hyp['bestReps']\n rep = np.tile(data.best[-1], bestReps)\n fitVector = batchMpiEval(rep, gen=None, sp_count=None, sameSeedForEachIndividual=False)\n trueFit = np.mean(fitVector)\n if trueFit > data.best[-2].fitness: # Actually better!\n data.best[-1].fitness = trueFit\n data.fit_top[-1] = trueFit\n data.bestFitVec = fitVector\n else: # Just lucky!\n prev = hyp['save_mod']\n data.best[-prev:] = data.best[-prev]\n data.fit_top[-prev:] = data.fit_top[-prev]\n data.newBest = False\n return data","def getLatestSpectrumMeasurements(self): \n return self.spectrum[len(self.spectrum)-1]","def result(self):\n best_accuracy = get_average_valid_accuracy(self.log_dir)\n\n if best_accuracy is not None:\n # Nevergrad performs minimization, but we want to maximize\n # the accuracy\n return 1.0 - best_accuracy\n\n return None","def getReward(self):\n# def evaluateFitness(self):\n fitness = 0.0\n distance = self.env.getDistance()\n speed = self.env.getSpeed()\n theta = self.env.getOrientation()\n\n ## implementation 101\n timeBonus = (self.maxTime - self.t)/self.maxTime\n alpha = 1.0/((1+distance)*(1+fabs(theta))*(speed+1));\n if distance < 0.5*self.env.init_distance :\n if(distance < self.env.vicinity_distance and\n abs(theta) < self.env.vicinity_orientation and\n speed < self.env.vicinity_speed ):\n fitness = 1 + timeBonus; \n else:\n fitness = alpha;\n else: fitness = 0\n self.lastFitness = fitness\n if fitness > self.bestFitness : \n self.bestFitness = fitness \n\n return fitness","def fit():\n pass","def get_last_sample(self) -> InternalSample:","def last_provided(self):\n last = self.current()\n if last == 0:\n return None\n return self._cnt2bc(last - 1)","def step(self):\n fit_default_config = {\"verbose\": self.verbose}\n fit_default_config.update(self.config.get(\"fit_config\", {}))\n\n history = self.model.fit(self.train_dataset, **fit_default_config)\n if history is None:\n stats = {}\n else:\n stats = {\"train_\" + k: v[-1] for k, v in history.history.items()}\n\n self.epoch += 1\n return stats","def get_optimal_beta(self):\n if self.annealing:\n # find the epoch/index that had the highest NDCG@k value\n index_max_ndcg = np.argmax(self.val_ndcg)\n\n # using this index find the value that beta had at this epoch\n return self.ls_beta[index_max_ndcg]\n else:\n return self.beta","def has_been_fit(self, value):\n self.predictor.has_been_fit = value","def best_value(self):\r\n return self._best_value","def save_fit(self):\n if self.fit is None:\n self.fit_status.setText('Fit not available for saving')\n return\n self.read_parameters()\n group = NXprocess()\n group['model'] = self.composite_model\n group['data'] = self.data\n for m in self.models:\n group[m['name']] = self.get_model(m['model'])\n parameters = NXparameters(attrs={'model': m['class']})\n for name in m['parameters']:\n p = self.fit.params[name]\n name = name.replace(m['model'].prefix, '')\n parameters[name] = NXfield(p.value, error=p.stderr,\n initial_value=p.init_value,\n min=str(p.min), max=str(p.max),\n vary=p.vary, expr=p.expr)\n group[m['name']].insert(parameters)\n group['program'] = 'lmfit'\n group['program'].attrs['version'] = lmfit_version\n group['title'] = 'Fit Results'\n group['fit'] = self.get_model(fit=True)\n fit = NXparameters()\n fit.nfev = self.fit.result.nfev\n fit.chisq = self.fit.result.chisqr\n fit.redchi = self.fit.result.redchi\n fit.message = self.fit.result.message\n group['statistics'] = fit\n group.note = NXnote(\n self.fit.result.message,\n f'Chi^2 = {self.fit.result.chisqr}\\n'\n f'Reduced Chi^2 = {self.fit.result.redchi}\\n'\n f'No. of Function Evaluations = {self.fit.result.nfev}\\n'\n f'No. of Variables = {self.fit.result.nvarys}\\n'\n f'No. of Data Points = {self.fit.result.ndata}\\n'\n f'No. of Degrees of Freedom = {self.fit.result.nfree}\\n'\n f'{self.fit.fit_report()}')\n self.write_group(group)","def get_fit_intercept(self):\n return self.fit_intercept","def last_generation(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"last_generation\")","def get_maximum_fitness(self) -> float:\n anticipated_change_cls = [cl for cl in self\n if cl.does_anticipate_change()]\n\n if len(anticipated_change_cls) > 0:\n best_cl = max(anticipated_change_cls, key=lambda cl: cl.fitness)\n return best_cl.fitness\n\n return 0.0","def getLatestMeasurement(self): \n return self.measurement[len(self.measurement)-1]","def get_latest(self):\n if len(self.points) == 0:\n return None\n return self.points[-1]","def best_bat(self):\n\n i = 0\n j = 0\n for i in range(self.NP):\n if self.Fitness[i] < self.Fitness[j]:\n j = i\n for i in range(self.D):\n self.best[i] = self.Sol[j][i]\n self.f_min = self.Fitness[j]","def _get_max_sampled_bandit(self)->Bandit:\n estimates = []\n for bandit in self.bandits:\n Qth = np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id])\n f_hat = self.mu[bandit.id]#computing moving_average here \n estimates.append(max(Qth, f_hat))\n return self.bandits[np.argmax(estimates)]","def _get_max_single_prediction_time(self):\n self._validate_max_single_prediction_time()\n if self.max_single_prediction_time is None:\n if self._get_mode() == \"Perform\":\n return 0.5 # prediction time should be under 0.5 second\n return None\n else:\n return deepcopy(self.max_single_prediction_time)","def get_last_result(self):\n return self.last_result","def get_last_lr(self):\n if not hasattr(self, '_last_lr'):\n raise RuntimeError(\"Run scheduler.step() first!\")\n return self._last_lr","def get_last_fea_condition_value(self, var_name):\n pos = len(self.fea_conditions[var_name]) - 1\n return self.get_fea_condition_value(var_name, pos)","def getLast(self):\r\n return self._data[-1]","def early_stopping(self, epoch):\n if len(self.test_res['score']) == 0:\n return -1, False\n if self.test_res['score'][-1] > self.best_score: # improvement\n self.best_score = self.test_res['score'][-1]\n self.cur_patience = 0\n else:\n self.cur_patience += 1\n\n if self.max_patience == self.cur_patience: # early stop must happen\n best_epoch = epoch - self.max_patience\n return best_epoch, True\n else:\n return epoch, False","def end(self, finish=None):\n return self.bounds(finish=finish)[1]","def find_last(self):\n # Get directory names. Each directory corresponds to a model\n dir_names = next(os.walk(self.model_dir))[1]\n key = self.config.NAME.lower()\n dir_names = filter(lambda f: f.startswith(key), dir_names)\n dir_names = sorted(dir_names)\n if not dir_names:\n return None, None\n # Pick last directory\n dir_name = os.path.join(self.model_dir, dir_names[-1])\n # Find the last checkpoint\n checkpoints = next(os.walk(dir_name))[2]\n checkpoints = filter(lambda f: f.startswith(\"FCN_DenseNet\"), checkpoints)\n checkpoints = sorted(checkpoints)\n if not checkpoints:\n return dir_name, None\n checkpoint = os.path.join(dir_name, checkpoints[-1])\n return dir_name, checkpoint","def adjust_data(self,fis,start,size,last_res=0.0):\n cond = fis.dimension() == self.training_data.shape[1]\n for i in range(start,start+size):\n if math.isnan(last_res):\n last_res = 0.0\n self.training_data[i,-1] = last_res\n if cond:\n last_res = fis.evaluate(self.training_data[i])\n else:\n last_res = fis.evaluate(self.training_data[i,:-1])\n return last_res","def extract_optimal_policy(self):\n self.Policy = np.argmax(self.Q, axis=1)\n if self.mode == 'debug':\n print(\"Optimal Policy:\",self.Policy)","def get_fittess_tour(self) -> Tour:\n # max_index = 0\n # for i in range(1, self.population_size):\n # if self.population[i].fitness > self.population[max_index]:\n # max_index = i\n # return self.population[max_index]\n return self.population[0]","def get_most_valuable(self):\n return self.most_valuable","def get_solution(self):\n return self.P_plot[-1]","def best_params(self):\n return self.X[np.argmax(self.y.numpy())]","def recovery(self):\n\n def exponential(time, tau):\n\n time = list(map(lambda x: float(x), time))\n exponent = np.exp(-np.divide(time, tau))\n return (1 - exponent)\n \n \n initial_guess = [55]\n \n tau = []\n for i in range(self.n_cols):\n current = self.screened_data.iloc[:,i]\n popt = curve_fit(exponential, self.xaxis, current, p0 = initial_guess)\n tau.append(popt[0][0])\n\n print('Median: ', np.median(tau))\n print('Min: ', np.min(tau))\n print('Max: ', np.max(tau))\n return 0\n\n plt.plot(self.xaxis, self.averaged_data, label = 'Average of all models')\n plt.plot(exponential(self.xaxis, *initial_guess), label = 'Initial Guess')\n for i in range(len(popt)):\n plt.plot(self.xaxis, exponential(self.xaxis, *popt[i]), label = 'Best Fit: time = ' + str(*popt[i]) + ' (ms)')\n plt.xlabel('Time (ms)')\n plt.ylabel('Normalized Current')\n plt.title('Recovery from Inactivation')\n plt.legend()\n plt.savefig('recovery_exponential_fit.png')\n return popt","def maxfit(self, *args, **kwargs):\n return _image.image_maxfit(self, *args, **kwargs)","def youngest(self):\n # Your implementation here","def getLastCall(self):\n return [x for x in self.xeps if x.lastcall]","def last(self, trace):\n return trace[-1]","def get_last(self, count):","def get_lip_max(self) -> float:\n if self._fitted:\n return self._model.get_lip_max()\n else:\n raise ValueError(\"call ``fit`` before calling ``get_lip_max``\")","def _last_matching(self, arg):\n try:\n if arg:\n return self.history.get(arg)[-1]\n else:\n return self.history[-1]\n except IndexError:\n return None","def get_fitness(self):\n if self.fitness == 0:\n self.fitness = 1 / self.get_cost()\n return self.fitness","def getLast(self):\n return self.dataBuffer[len(self.dataBuffer) - 1]","def get_last_lr(self):\n return self._lr_scheduler.get_last_lr()","def registre_actual(self, fitxa):\n\t\treturn self.reg_actual[fitxa]","def get_current_state(self):\n return self.nextYs[-1]","def get_fitness(self):\n score = self.score - (abs(self.distance_to_pipe()[0])) * 0.3\n score = self.score + 1.5 * 1e-3 * self.birth_time - (abs(self.distance_to_pipe()[0])) * 0.001\n score = self.birth_time * 3 - \\\n (abs(Bird.lower_pipes[self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 2 - self.pos_y)) * 0.5\n pipe_width = IMAGES['pipe'][0].get_width()\n\n constants.debug_circle = Bird.lower_pipes[self.get_next_pipe_index()]['x'] + pipe_width // 1.2, \\\n Bird.lower_pipes[\n self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 10\n constants.debug_circle = tuple(map(int, constants.debug_circle))\n # score *= 1e-1\n # score = self.score\n # if self.score > 1:\n # print(score)\n\n score = self.birth_time * 3 - abs(constants.debug_circle[1] - self.pos_y) + 5 * self.score\n return score","def get_mean_fit(flag='L'):\n if flag == 'L':\n return np.mean(np.vstack(l_coeff_queue), axis =0) if len(l_coeff_queue)>1 else l_coeff_queue[-1]\n else:\n return np.mean(np.vstack(r_coeff_queue), axis =0) if len(r_coeff_queue)>1 else r_coeff_queue[-1]","def _best_individual(self):\n return max(self._population, key=attrgetter(\"fitness\"))","def finish_checkpoint(self):\n return self.this_evaluation.checkpoint","def get_y_max(self):\n if len(self._statDict) == 0:\n return -1E10\n\n line_id_list = self._statDict.keys()\n max_y = self._statDict[line_id_list[0]][3]\n for i_plot in range(1, len(line_id_list)):\n if self._statDict[line_id_list[i_plot]][3] > max_y:\n max_y = self._statDict[line_id_list[i_plot]][3]\n\n return max_y","def find_last(self):\n # Get directory names. Each directory corresponds to a model\n dir_names = next(os.walk(self.model_dir))[1]\n key = self.config.NAME.lower()\n dir_names = filter(lambda f: f.startswith(key), dir_names)\n dir_names = sorted(dir_names)\n if not dir_names:\n import errno\n raise FileNotFoundError(\n errno.ENOENT,\n f\"Could not find model directory under {self.model_dir}\")\n # Pick last directory\n dir_name = os.path.join(self.model_dir, dir_names[-1])\n # Find the last checkpoint\n checkpoints = next(os.walk(dir_name))[2]\n checkpoints = filter(lambda f: f.startswith(\"OOD\"), checkpoints)\n checkpoints = sorted(checkpoints)\n if not checkpoints:\n import errno\n raise FileNotFoundError(\n errno.ENOENT, f\"Could not find weight files in {dir_name}\")\n checkpoint = os.path.join(dir_name, checkpoints[-1])\n return checkpoint","def max_y_arg(self):\n return max((self(0).y,0), (self(1).y,1))[1]","def latestValue(self):\n if len(self.values) > 0:\n return self.values[-1]\n else:\n return 0","def best(self):\n\n last = self.timer.times[-1]\n return last != 'DNF' and all(last <= t for t in self.timer.times if t != 'DNF')","def GetPts(self):\n return self.best","def pick_largest(self, cut_off):\r\n for i in range(self.dimension):\r\n m = self.masked[int(self.rank_yx(self.rank[i])[0]) # locating the corresponding mark array\r\n ,int(self.rank_yx(self.rank[i])[1])]\r\n if m * self.image_data[i] == self.image_data[i]:\r\n if self.image_data[i] <= cut_off:\r\n print(\"Surveying completed\")\r\n return -1,-1 # returns -1,-1 if scan is completed\r\n else:\r\n return self.image_data[i], np.array(self.rank[i])","def get_last_step(self):\n return self.get_step_by_index(-1)","def result(self):\n # most pythonic way to get last in last is -1\n return self.history[-1]","def getCurrentFS(self):\n\t\tif self.currentFS[2] != self.step:\n\t\t\tuFS = self.update_feasible_set(self.currentFS[0])\n\t\t\tself.currentFS = np.array([uFS, self.fs_probability(uFS), self.step])\n\t\treturn self.currentFS"],"string":"[\n \"def getFit(self):\\n if self.fits.has_key('default'):\\n return self.fits['default']\\n else:\\n return None\",\n \"def last_fmeasure(self):\\n return self.get_fvalue(self.last_position())\",\n \"def get_last_saved_estimation(self):\\n return None\",\n \"def get_fit(self, space=False):\\n\\n if space:\\n model_type = 'space'\\n else:\\n model_type = 'risk'\\n\\n fit_type = 'likelihood'\\n\\n fitter = self.fits[model_type].linear_fits[fit_type]\\n\\n return fitter\",\n \"def get_last_save(self) -> Optional[float]:\\n return None if self._save_marker is None else self._save_marker + self._offset\",\n \"def get_last_measurement(self, param):\\n return self.__buffer[param][-1]\",\n \"def restore_last(self, points_x = None, points_y = None):\\n\\n # when calling with no parameter, we just keep the last state activated\\n # and keep signaling a detected line to absorb small flaws of a few\\n # frames - otherwise calculate with new input data\\n\\n # on new input points, reset and update lane\\n if (points_x is not None) and (points_y is not None):\\n #self.reset(self.roi_warped_points)\\n self.update(points_x, points_y)\\n\\n return self.detected\\n\\n elif len(self.recent_fit) >= 2:\\n # ensure detected\\n self.detected = True\\n\\n # remove current broken fit from recent fits\\n self.recent_fit = self.recent_fit[:-1]\\n\\n # make last valid recent fit to current fit\\n self.current_fit = self.recent_fit[-1]\\n\\n # calculate new best fit\\n sum = [np.array([False])]\\n \\\"\\\"\\\"\\n current_weight = self.max_n + 1\\n divisor = 0\\n\\n for r in self.recent_fit:\\n current_weight = current_weight - 1\\n sum = sum + current_weight * r\\n divisor = divisor + current_weight\\n\\n self.best_fit = (sum / divisor)[0]\\n \\\"\\\"\\\"\\n\\n for r in self.recent_fit:\\n sum = sum + r\\n\\n self.best_fit = (sum / len(self.recent_fit))[0]\\n\\n # re calculate diffs\\n self.riffs = self.current_fit - self.best_fit\\n\\n # we need to re-calculate the metrics\\n self.calculate_metrics()\\n\\n return True\\n else:\\n # if not, there's currently no way out\\n return False\",\n \"def getBestOption(self):\\n if len(self.Data) < 1:\\n return None\\n else:\\n bestR = max(self.Data.items(), key=lambda x: x[1]['SPat'].I)\\n return bestR[1]\",\n \"def get_lip_best(self) -> float:\\n if self._fitted:\\n if self._ready_lip_best:\\n return self._lip_best\\n else:\\n lip_best = self._get_lip_best()\\n self._set(\\\"_lip_best\\\", lip_best)\\n self._set(\\\"_ready_lip_best\\\", True)\\n return lip_best\\n else:\\n raise ValueError(\\\"call ``fit`` before calling ``get_lip_best``\\\")\",\n \"def last_value(self):\\n return self.samples[-1]\",\n \"def best_step(self):\\r\\n return self._best_value_step\",\n \"def is_fitted(self):\\n\\n return self.isFitted\",\n \"def scatter_back_fit(self):\\n return self._scatter_back_fit\",\n \"def max_log_likelihood_fit(self) -> FitInterferometer:\\r\\n return self.analysis.fit_interferometer_via_instance_from(\\r\\n instance=self.instance\\r\\n )\",\n \"def get_fit(self) -> np.poly1d:\\n if self.log_fits is not None:\\n return next(self.log_fits)\\n x = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: [line.point1.y for line in m.marker_lines])\\n .to_list()\\n )\\n y = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: [line.point1.x for line in m.marker_lines])\\n .to_list()\\n )\\n if self.orientation == Orientation.UP_DOWN:\\n fit = np.polyfit(x, y, 1)\\n else:\\n fit = np.polyfit(y, x, 1)\\n return np.poly1d(fit)\",\n \"def stop_fit(self):\\n self._stop_fit = True\",\n \"def get_last_solution(self):\\n return self.last_result\",\n \"def _get_max_estimated_bandit(self)->Bandit:\\n # print(\\\"mus - \\\", self.mu)\\n # print(\\\"actions - \\\", np.argmax(self.mu))\\n unique, counts = np.unique(self.mu, return_counts=True)\\n lens = counts[np.argmax(unique)] \\n if lens>1: # if two actions have same argmax\\n # then return arbitrarily from those max ones\\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\\n return np.random.choice(maxs)\\n # otherwise return the max one\\n return self.bandits[np.argmax(self.mu)]\",\n \"def max_log_likelihood_fit(self) -> ag.FitQuantity:\\r\\n\\r\\n return self.analysis.fit_quantity_for_instance(instance=self.instance)\",\n \"def last_percept(self):\\n return self.percept\",\n \"def _get_lip_best(self) -> float:\\n pass\",\n \"def best_value(self):\\n return np.max(self.y.numpy())\",\n \"def has_been_fit(self):\\n return self.predictor.has_been_fit\",\n \"def get_bestparameter(self):\\n if self._df_test is None:\\n raise RuntimeError('get_bestparameter: please the '\\n 'train model first')\\n mean = self._df_test.mean(axis=1)\\n if len(mean) == 1:\\n result = mean.idxmax()\\n elif len(mean) == 2:\\n result = mean.loc[mean.index > 1].idxmax()\\n else:\\n result = mean.loc[mean.index > 2].idxmax()\\n return result\",\n \"def get_bestparameter(self):\\n if self._df_test is None:\\n raise RuntimeError('get_bestparameter: please the '\\n 'train model first')\\n mean = self._df_test.mean(axis=1)\\n if len(mean) == 1:\\n result = mean.idxmax()\\n elif len(mean) == 2:\\n result = mean.loc[mean.index > 1].idxmax()\\n else:\\n result = mean.loc[mean.index > 2].idxmax()\\n return result\",\n \"def get_last_save(self) -> Optional[int]:\\n return self._bin_iter.get_last_save()\",\n \"def last_value(self):\\n return self._stop\",\n \"def get_score(self):\\n return np.max(self._scores) if self._scores is not None else self._score_history[-1]\",\n \"def last_hit(self):\\n return self._last_hit\",\n \"def is_fitted(self):\\n return self.__fdata is not None\",\n \"def getFitness(self):\\n\\n if self.extraAsFitness!=None:\\n return self.extra[self.extraAsFitness]\\n \\n fit = self.getMeanFitness('F')\\n if (np.isnan(fit)):\\n return 0 \\n return float(int(fit*1000.0))/1000.0\",\n \"def get_last_save(self) -> Optional[int]:\\n return self._save_marker\",\n \"def _find_last_checkpoint(self):\\n highest_num, last_checkpoint = -np.inf, None\\n for filename in os.listdir(self.logdir):\\n # checkpoints look like logdir/model.ckpt-N\\n # self._save_path is \\\"logdir/model.ckpt\\\"\\n if os.path.basename(self._save_path) in filename:\\n try:\\n N = int(filename.split(\\\"-\\\")[1].split(\\\".\\\")[0])\\n if N > highest_num:\\n highest_num = N\\n last_checkpoint = \\\"model.ckpt-\\\" + str(N)\\n except ValueError:\\n pass\\n return os.path.join(self.logdir, last_checkpoint)\",\n \"def y_flag(self):\\n if self.calibrationlog:\\n self.calibrationlogflag = True\\n self.calibrationlogtime = DEFAULT_CALIBRATIONLOG_TIME\",\n \"def last_value(self):\\n return self._waveforms[-1].last_value\",\n \"def get_last(t_, w_):\\n return t_ - tf.constant(1)\",\n \"def __findBestLogProbability(self):\\n best_model = None\\n highest_log_probability = -sys.maxsize# (np.finfo(float).eps)\\n\\n # Find the highest model\\n for item in self.data_array:\\n if item[1] > highest_log_probability:\\n best_model = item\\n highest_log_probability = item[1]\\n\\n return best_model\",\n \"def last_value(self):\\n return 0\",\n \"def get_last_lr(self) -> Tensor:\\n\\n return self.lr_scheduler.get_last_lr()\",\n \"def getLastFunction(self) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def checkBest(data):\\n global filename, hyp\\n if data.newBest is True:\\n bestReps = hyp['bestReps']\\n rep = np.tile(data.best[-1], bestReps)\\n fitVector = batchMpiEval(rep, gen=None, sp_count=None, sameSeedForEachIndividual=False)\\n trueFit = np.mean(fitVector)\\n if trueFit > data.best[-2].fitness: # Actually better!\\n data.best[-1].fitness = trueFit\\n data.fit_top[-1] = trueFit\\n data.bestFitVec = fitVector\\n else: # Just lucky!\\n prev = hyp['save_mod']\\n data.best[-prev:] = data.best[-prev]\\n data.fit_top[-prev:] = data.fit_top[-prev]\\n data.newBest = False\\n return data\",\n \"def getLatestSpectrumMeasurements(self): \\n return self.spectrum[len(self.spectrum)-1]\",\n \"def result(self):\\n best_accuracy = get_average_valid_accuracy(self.log_dir)\\n\\n if best_accuracy is not None:\\n # Nevergrad performs minimization, but we want to maximize\\n # the accuracy\\n return 1.0 - best_accuracy\\n\\n return None\",\n \"def getReward(self):\\n# def evaluateFitness(self):\\n fitness = 0.0\\n distance = self.env.getDistance()\\n speed = self.env.getSpeed()\\n theta = self.env.getOrientation()\\n\\n ## implementation 101\\n timeBonus = (self.maxTime - self.t)/self.maxTime\\n alpha = 1.0/((1+distance)*(1+fabs(theta))*(speed+1));\\n if distance < 0.5*self.env.init_distance :\\n if(distance < self.env.vicinity_distance and\\n abs(theta) < self.env.vicinity_orientation and\\n speed < self.env.vicinity_speed ):\\n fitness = 1 + timeBonus; \\n else:\\n fitness = alpha;\\n else: fitness = 0\\n self.lastFitness = fitness\\n if fitness > self.bestFitness : \\n self.bestFitness = fitness \\n\\n return fitness\",\n \"def fit():\\n pass\",\n \"def get_last_sample(self) -> InternalSample:\",\n \"def last_provided(self):\\n last = self.current()\\n if last == 0:\\n return None\\n return self._cnt2bc(last - 1)\",\n \"def step(self):\\n fit_default_config = {\\\"verbose\\\": self.verbose}\\n fit_default_config.update(self.config.get(\\\"fit_config\\\", {}))\\n\\n history = self.model.fit(self.train_dataset, **fit_default_config)\\n if history is None:\\n stats = {}\\n else:\\n stats = {\\\"train_\\\" + k: v[-1] for k, v in history.history.items()}\\n\\n self.epoch += 1\\n return stats\",\n \"def get_optimal_beta(self):\\n if self.annealing:\\n # find the epoch/index that had the highest NDCG@k value\\n index_max_ndcg = np.argmax(self.val_ndcg)\\n\\n # using this index find the value that beta had at this epoch\\n return self.ls_beta[index_max_ndcg]\\n else:\\n return self.beta\",\n \"def has_been_fit(self, value):\\n self.predictor.has_been_fit = value\",\n \"def best_value(self):\\r\\n return self._best_value\",\n \"def save_fit(self):\\n if self.fit is None:\\n self.fit_status.setText('Fit not available for saving')\\n return\\n self.read_parameters()\\n group = NXprocess()\\n group['model'] = self.composite_model\\n group['data'] = self.data\\n for m in self.models:\\n group[m['name']] = self.get_model(m['model'])\\n parameters = NXparameters(attrs={'model': m['class']})\\n for name in m['parameters']:\\n p = self.fit.params[name]\\n name = name.replace(m['model'].prefix, '')\\n parameters[name] = NXfield(p.value, error=p.stderr,\\n initial_value=p.init_value,\\n min=str(p.min), max=str(p.max),\\n vary=p.vary, expr=p.expr)\\n group[m['name']].insert(parameters)\\n group['program'] = 'lmfit'\\n group['program'].attrs['version'] = lmfit_version\\n group['title'] = 'Fit Results'\\n group['fit'] = self.get_model(fit=True)\\n fit = NXparameters()\\n fit.nfev = self.fit.result.nfev\\n fit.chisq = self.fit.result.chisqr\\n fit.redchi = self.fit.result.redchi\\n fit.message = self.fit.result.message\\n group['statistics'] = fit\\n group.note = NXnote(\\n self.fit.result.message,\\n f'Chi^2 = {self.fit.result.chisqr}\\\\n'\\n f'Reduced Chi^2 = {self.fit.result.redchi}\\\\n'\\n f'No. of Function Evaluations = {self.fit.result.nfev}\\\\n'\\n f'No. of Variables = {self.fit.result.nvarys}\\\\n'\\n f'No. of Data Points = {self.fit.result.ndata}\\\\n'\\n f'No. of Degrees of Freedom = {self.fit.result.nfree}\\\\n'\\n f'{self.fit.fit_report()}')\\n self.write_group(group)\",\n \"def get_fit_intercept(self):\\n return self.fit_intercept\",\n \"def last_generation(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"last_generation\\\")\",\n \"def get_maximum_fitness(self) -> float:\\n anticipated_change_cls = [cl for cl in self\\n if cl.does_anticipate_change()]\\n\\n if len(anticipated_change_cls) > 0:\\n best_cl = max(anticipated_change_cls, key=lambda cl: cl.fitness)\\n return best_cl.fitness\\n\\n return 0.0\",\n \"def getLatestMeasurement(self): \\n return self.measurement[len(self.measurement)-1]\",\n \"def get_latest(self):\\n if len(self.points) == 0:\\n return None\\n return self.points[-1]\",\n \"def best_bat(self):\\n\\n i = 0\\n j = 0\\n for i in range(self.NP):\\n if self.Fitness[i] < self.Fitness[j]:\\n j = i\\n for i in range(self.D):\\n self.best[i] = self.Sol[j][i]\\n self.f_min = self.Fitness[j]\",\n \"def _get_max_sampled_bandit(self)->Bandit:\\n estimates = []\\n for bandit in self.bandits:\\n Qth = np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id])\\n f_hat = self.mu[bandit.id]#computing moving_average here \\n estimates.append(max(Qth, f_hat))\\n return self.bandits[np.argmax(estimates)]\",\n \"def _get_max_single_prediction_time(self):\\n self._validate_max_single_prediction_time()\\n if self.max_single_prediction_time is None:\\n if self._get_mode() == \\\"Perform\\\":\\n return 0.5 # prediction time should be under 0.5 second\\n return None\\n else:\\n return deepcopy(self.max_single_prediction_time)\",\n \"def get_last_result(self):\\n return self.last_result\",\n \"def get_last_lr(self):\\n if not hasattr(self, '_last_lr'):\\n raise RuntimeError(\\\"Run scheduler.step() first!\\\")\\n return self._last_lr\",\n \"def get_last_fea_condition_value(self, var_name):\\n pos = len(self.fea_conditions[var_name]) - 1\\n return self.get_fea_condition_value(var_name, pos)\",\n \"def getLast(self):\\r\\n return self._data[-1]\",\n \"def early_stopping(self, epoch):\\n if len(self.test_res['score']) == 0:\\n return -1, False\\n if self.test_res['score'][-1] > self.best_score: # improvement\\n self.best_score = self.test_res['score'][-1]\\n self.cur_patience = 0\\n else:\\n self.cur_patience += 1\\n\\n if self.max_patience == self.cur_patience: # early stop must happen\\n best_epoch = epoch - self.max_patience\\n return best_epoch, True\\n else:\\n return epoch, False\",\n \"def end(self, finish=None):\\n return self.bounds(finish=finish)[1]\",\n \"def find_last(self):\\n # Get directory names. Each directory corresponds to a model\\n dir_names = next(os.walk(self.model_dir))[1]\\n key = self.config.NAME.lower()\\n dir_names = filter(lambda f: f.startswith(key), dir_names)\\n dir_names = sorted(dir_names)\\n if not dir_names:\\n return None, None\\n # Pick last directory\\n dir_name = os.path.join(self.model_dir, dir_names[-1])\\n # Find the last checkpoint\\n checkpoints = next(os.walk(dir_name))[2]\\n checkpoints = filter(lambda f: f.startswith(\\\"FCN_DenseNet\\\"), checkpoints)\\n checkpoints = sorted(checkpoints)\\n if not checkpoints:\\n return dir_name, None\\n checkpoint = os.path.join(dir_name, checkpoints[-1])\\n return dir_name, checkpoint\",\n \"def adjust_data(self,fis,start,size,last_res=0.0):\\n cond = fis.dimension() == self.training_data.shape[1]\\n for i in range(start,start+size):\\n if math.isnan(last_res):\\n last_res = 0.0\\n self.training_data[i,-1] = last_res\\n if cond:\\n last_res = fis.evaluate(self.training_data[i])\\n else:\\n last_res = fis.evaluate(self.training_data[i,:-1])\\n return last_res\",\n \"def extract_optimal_policy(self):\\n self.Policy = np.argmax(self.Q, axis=1)\\n if self.mode == 'debug':\\n print(\\\"Optimal Policy:\\\",self.Policy)\",\n \"def get_fittess_tour(self) -> Tour:\\n # max_index = 0\\n # for i in range(1, self.population_size):\\n # if self.population[i].fitness > self.population[max_index]:\\n # max_index = i\\n # return self.population[max_index]\\n return self.population[0]\",\n \"def get_most_valuable(self):\\n return self.most_valuable\",\n \"def get_solution(self):\\n return self.P_plot[-1]\",\n \"def best_params(self):\\n return self.X[np.argmax(self.y.numpy())]\",\n \"def recovery(self):\\n\\n def exponential(time, tau):\\n\\n time = list(map(lambda x: float(x), time))\\n exponent = np.exp(-np.divide(time, tau))\\n return (1 - exponent)\\n \\n \\n initial_guess = [55]\\n \\n tau = []\\n for i in range(self.n_cols):\\n current = self.screened_data.iloc[:,i]\\n popt = curve_fit(exponential, self.xaxis, current, p0 = initial_guess)\\n tau.append(popt[0][0])\\n\\n print('Median: ', np.median(tau))\\n print('Min: ', np.min(tau))\\n print('Max: ', np.max(tau))\\n return 0\\n\\n plt.plot(self.xaxis, self.averaged_data, label = 'Average of all models')\\n plt.plot(exponential(self.xaxis, *initial_guess), label = 'Initial Guess')\\n for i in range(len(popt)):\\n plt.plot(self.xaxis, exponential(self.xaxis, *popt[i]), label = 'Best Fit: time = ' + str(*popt[i]) + ' (ms)')\\n plt.xlabel('Time (ms)')\\n plt.ylabel('Normalized Current')\\n plt.title('Recovery from Inactivation')\\n plt.legend()\\n plt.savefig('recovery_exponential_fit.png')\\n return popt\",\n \"def maxfit(self, *args, **kwargs):\\n return _image.image_maxfit(self, *args, **kwargs)\",\n \"def youngest(self):\\n # Your implementation here\",\n \"def getLastCall(self):\\n return [x for x in self.xeps if x.lastcall]\",\n \"def last(self, trace):\\n return trace[-1]\",\n \"def get_last(self, count):\",\n \"def get_lip_max(self) -> float:\\n if self._fitted:\\n return self._model.get_lip_max()\\n else:\\n raise ValueError(\\\"call ``fit`` before calling ``get_lip_max``\\\")\",\n \"def _last_matching(self, arg):\\n try:\\n if arg:\\n return self.history.get(arg)[-1]\\n else:\\n return self.history[-1]\\n except IndexError:\\n return None\",\n \"def get_fitness(self):\\n if self.fitness == 0:\\n self.fitness = 1 / self.get_cost()\\n return self.fitness\",\n \"def getLast(self):\\n return self.dataBuffer[len(self.dataBuffer) - 1]\",\n \"def get_last_lr(self):\\n return self._lr_scheduler.get_last_lr()\",\n \"def registre_actual(self, fitxa):\\n\\t\\treturn self.reg_actual[fitxa]\",\n \"def get_current_state(self):\\n return self.nextYs[-1]\",\n \"def get_fitness(self):\\n score = self.score - (abs(self.distance_to_pipe()[0])) * 0.3\\n score = self.score + 1.5 * 1e-3 * self.birth_time - (abs(self.distance_to_pipe()[0])) * 0.001\\n score = self.birth_time * 3 - \\\\\\n (abs(Bird.lower_pipes[self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 2 - self.pos_y)) * 0.5\\n pipe_width = IMAGES['pipe'][0].get_width()\\n\\n constants.debug_circle = Bird.lower_pipes[self.get_next_pipe_index()]['x'] + pipe_width // 1.2, \\\\\\n Bird.lower_pipes[\\n self.get_next_pipe_index()]['y'] - PIPE_GAP_SIZE // 10\\n constants.debug_circle = tuple(map(int, constants.debug_circle))\\n # score *= 1e-1\\n # score = self.score\\n # if self.score > 1:\\n # print(score)\\n\\n score = self.birth_time * 3 - abs(constants.debug_circle[1] - self.pos_y) + 5 * self.score\\n return score\",\n \"def get_mean_fit(flag='L'):\\n if flag == 'L':\\n return np.mean(np.vstack(l_coeff_queue), axis =0) if len(l_coeff_queue)>1 else l_coeff_queue[-1]\\n else:\\n return np.mean(np.vstack(r_coeff_queue), axis =0) if len(r_coeff_queue)>1 else r_coeff_queue[-1]\",\n \"def _best_individual(self):\\n return max(self._population, key=attrgetter(\\\"fitness\\\"))\",\n \"def finish_checkpoint(self):\\n return self.this_evaluation.checkpoint\",\n \"def get_y_max(self):\\n if len(self._statDict) == 0:\\n return -1E10\\n\\n line_id_list = self._statDict.keys()\\n max_y = self._statDict[line_id_list[0]][3]\\n for i_plot in range(1, len(line_id_list)):\\n if self._statDict[line_id_list[i_plot]][3] > max_y:\\n max_y = self._statDict[line_id_list[i_plot]][3]\\n\\n return max_y\",\n \"def find_last(self):\\n # Get directory names. Each directory corresponds to a model\\n dir_names = next(os.walk(self.model_dir))[1]\\n key = self.config.NAME.lower()\\n dir_names = filter(lambda f: f.startswith(key), dir_names)\\n dir_names = sorted(dir_names)\\n if not dir_names:\\n import errno\\n raise FileNotFoundError(\\n errno.ENOENT,\\n f\\\"Could not find model directory under {self.model_dir}\\\")\\n # Pick last directory\\n dir_name = os.path.join(self.model_dir, dir_names[-1])\\n # Find the last checkpoint\\n checkpoints = next(os.walk(dir_name))[2]\\n checkpoints = filter(lambda f: f.startswith(\\\"OOD\\\"), checkpoints)\\n checkpoints = sorted(checkpoints)\\n if not checkpoints:\\n import errno\\n raise FileNotFoundError(\\n errno.ENOENT, f\\\"Could not find weight files in {dir_name}\\\")\\n checkpoint = os.path.join(dir_name, checkpoints[-1])\\n return checkpoint\",\n \"def max_y_arg(self):\\n return max((self(0).y,0), (self(1).y,1))[1]\",\n \"def latestValue(self):\\n if len(self.values) > 0:\\n return self.values[-1]\\n else:\\n return 0\",\n \"def best(self):\\n\\n last = self.timer.times[-1]\\n return last != 'DNF' and all(last <= t for t in self.timer.times if t != 'DNF')\",\n \"def GetPts(self):\\n return self.best\",\n \"def pick_largest(self, cut_off):\\r\\n for i in range(self.dimension):\\r\\n m = self.masked[int(self.rank_yx(self.rank[i])[0]) # locating the corresponding mark array\\r\\n ,int(self.rank_yx(self.rank[i])[1])]\\r\\n if m * self.image_data[i] == self.image_data[i]:\\r\\n if self.image_data[i] <= cut_off:\\r\\n print(\\\"Surveying completed\\\")\\r\\n return -1,-1 # returns -1,-1 if scan is completed\\r\\n else:\\r\\n return self.image_data[i], np.array(self.rank[i])\",\n \"def get_last_step(self):\\n return self.get_step_by_index(-1)\",\n \"def result(self):\\n # most pythonic way to get last in last is -1\\n return self.history[-1]\",\n \"def getCurrentFS(self):\\n\\t\\tif self.currentFS[2] != self.step:\\n\\t\\t\\tuFS = self.update_feasible_set(self.currentFS[0])\\n\\t\\t\\tself.currentFS = np.array([uFS, self.fs_probability(uFS), self.step])\\n\\t\\treturn self.currentFS\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6239705","0.6228102","0.6141779","0.6008824","0.59334695","0.5871821","0.5755246","0.5743263","0.5716989","0.57042426","0.5698672","0.56794965","0.56396884","0.56118524","0.55922616","0.55794775","0.55546254","0.55316406","0.55230576","0.5493914","0.54734224","0.5470537","0.5467277","0.5463756","0.5463756","0.54407865","0.54403305","0.5427564","0.5399268","0.5394421","0.5388534","0.53839546","0.5378728","0.53413075","0.5322262","0.5298815","0.5291285","0.5281541","0.52804136","0.5277138","0.5274262","0.52741987","0.527289","0.5263323","0.5259525","0.52570707","0.5241124","0.5227992","0.52240574","0.5223994","0.5223494","0.5218274","0.5208505","0.5208322","0.5208169","0.52062094","0.5202218","0.52018553","0.5195343","0.5193176","0.5183217","0.51829326","0.5173605","0.5173029","0.517132","0.51674783","0.5161488","0.51600397","0.5154234","0.5154144","0.51532555","0.5146984","0.5140146","0.5137223","0.5136961","0.5135339","0.5131359","0.5122635","0.51225656","0.5118868","0.5116891","0.5114408","0.5113295","0.51122326","0.5110303","0.51029485","0.50995046","0.50992376","0.5097886","0.5090866","0.50888604","0.50838196","0.5083123","0.50804895","0.50740147","0.5070229","0.50679976","0.5065348","0.5052871","0.50371355"],"string":"[\n \"0.6239705\",\n \"0.6228102\",\n \"0.6141779\",\n \"0.6008824\",\n \"0.59334695\",\n \"0.5871821\",\n \"0.5755246\",\n \"0.5743263\",\n \"0.5716989\",\n \"0.57042426\",\n \"0.5698672\",\n \"0.56794965\",\n \"0.56396884\",\n \"0.56118524\",\n \"0.55922616\",\n \"0.55794775\",\n \"0.55546254\",\n \"0.55316406\",\n \"0.55230576\",\n \"0.5493914\",\n \"0.54734224\",\n \"0.5470537\",\n \"0.5467277\",\n \"0.5463756\",\n \"0.5463756\",\n \"0.54407865\",\n \"0.54403305\",\n \"0.5427564\",\n \"0.5399268\",\n \"0.5394421\",\n \"0.5388534\",\n \"0.53839546\",\n \"0.5378728\",\n \"0.53413075\",\n \"0.5322262\",\n \"0.5298815\",\n \"0.5291285\",\n \"0.5281541\",\n \"0.52804136\",\n \"0.5277138\",\n \"0.5274262\",\n \"0.52741987\",\n \"0.527289\",\n \"0.5263323\",\n \"0.5259525\",\n \"0.52570707\",\n \"0.5241124\",\n \"0.5227992\",\n \"0.52240574\",\n \"0.5223994\",\n \"0.5223494\",\n \"0.5218274\",\n \"0.5208505\",\n \"0.5208322\",\n \"0.5208169\",\n \"0.52062094\",\n \"0.5202218\",\n \"0.52018553\",\n \"0.5195343\",\n \"0.5193176\",\n \"0.5183217\",\n \"0.51829326\",\n \"0.5173605\",\n \"0.5173029\",\n \"0.517132\",\n \"0.51674783\",\n \"0.5161488\",\n \"0.51600397\",\n \"0.5154234\",\n \"0.5154144\",\n \"0.51532555\",\n \"0.5146984\",\n \"0.5140146\",\n \"0.5137223\",\n \"0.5136961\",\n \"0.5135339\",\n \"0.5131359\",\n \"0.5122635\",\n \"0.51225656\",\n \"0.5118868\",\n \"0.5116891\",\n \"0.5114408\",\n \"0.5113295\",\n \"0.51122326\",\n \"0.5110303\",\n \"0.51029485\",\n \"0.50995046\",\n \"0.50992376\",\n \"0.5097886\",\n \"0.5090866\",\n \"0.50888604\",\n \"0.50838196\",\n \"0.5083123\",\n \"0.50804895\",\n \"0.50740147\",\n \"0.5070229\",\n \"0.50679976\",\n \"0.5065348\",\n \"0.5052871\",\n \"0.50371355\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8070429"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14794,"cells":{"query":{"kind":"string","value":"Verify if number of pixels are satisfactory for a confident fit and then fit"},"document":{"kind":"string","value":"def check_and_fit(x, y, flag='L', threshold=1000):\n \n confidence_index = len(x)\n if IsLaneFound is False:\n threshold =500\n if confidence_index < threshold:\n fit = None\n foundFlag = False\n else:\n fit, cov = curve_fit(lambda x, a, b, c:a*x*x+b*x + c , x, y)\n foundFlag = True\n return fit, foundFlag, confidence_index"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _check_is_fitted(self):\n check_is_fitted(self, ['w', 'b'])","def will_data_fit(bit_num, image, bits_per_pix):\r\n max_bits = reduce(lambda x, y: x * y, image.size) * bits_per_pix\r\n return bit_num <= max_bits","def _check_is_fitted(self):\n # Do not check `b` as some classifiers do not set it\n check_is_fitted(self, 'w')\n super(CClassifierLinear, self)._check_is_fitted()","def is_fit(self):\n if not hasattr(self, '_icc_imgs'):\n return False\n else:\n return self._icc_imgs is not None","def test_fit(self):\n X = np.zeros((2, 3), dtype=np.float64)\n snv = SNV(q=50)\n try:\n _ = snv.fit(X)\n except:\n self.assertTrue(False)","def _check_if_fitted(self):\n if not self.fitted:\n raise AssertionError('Model is not fitted! Fit the model to a '\n 'dataset before attempting to plot results.')","def test_fit_score(self):\n oz = ClassificationScoreVisualizer(GaussianNB())\n assert_not_fitted(oz, X_test=self.binary.X.test)\n assert oz.fit(self.binary.X.train, self.binary.y.train) is oz\n assert 0.0 <= oz.score(self.binary.X.test, self.binary.y.test) <= 1.0\n assert_fitted(oz, X_test=self.binary.X.test)","def number_of_images_valid():\r\n if number_of_images_a_valid() and number_of_images_b_valid():\r\n return True\r\n else:\r\n return False","def _check_fitted(self):\n assert self.subspace_basis is not None, \\\n 'You must fit %s before you can project' % self.__class__.__name__","def _check_fitted(self):\n assert self.subspace_basis is not None, \\\n 'You must fit %s before you can project' % self.__class__.__name__","def has_fit(client: NumPyClient) -> bool:\n return type(client).fit != NumPyClient.fit","def is_fitted(self):\n return self.__fdata is not None","def is_perfect_square():","def is_full(self):\r\n return self.num_checkers == self.width * self.height","def _fit_test(self, img_ext) -> int:\n sum_squared_difference = np.sum(np.square(self._orig_img.img - img_ext.img))\n\n return sum_squared_difference","def fit():\n pass","def checks(self, poly_fit, poly_fitx, poly_fity):\n if self.best_fit is not None:\n if not (np.abs(self.best_fit-poly_fit) <\n np.array([0.001, 1, 500])).all():\n return False\n if self.bestx is not None:\n if np.mean(np.abs(self.bestx-poly_fitx)) > 200:\n return False\n\n return True","def sanity_check(self):\n score = 0\n curvatures = self._curvature()\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\n # difference in curvature is more than 15%\n score -= 1\n\n diff_std = np.std(self.right_fitx - self.left_fitx)\n if diff_std > 30:\n # std of the difference between the right lane and left lane is more than 30 pixel\n score -= 1\n\n # roughly parallel\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\n # difference in slope is more than 15%\n score -= 1\n\n return score","def fit_test(self):","def determine_if_fit_converged(dic_rms, catalog, observation, wcsprm, NAXIS1, NAXIS2, silent=False):\n converged = False\n\n N_obs = observation.shape[0]\n\n catalog_on_sensor = wcsprm.s2p(catalog[[\"ra\", \"dec\"]], 1)['pixcrd']\n cat_x = np.array( [catalog_on_sensor[:,0] ])\n cat_y = np.array( [catalog_on_sensor[:,1] ])\n mask = (cat_x >= 0) & (cat_x <= NAXIS1) & (cat_y >= 0) & (cat_y <= NAXIS2)\n N_cat = mask.sum()\n\n N = min([N_obs, N_cat])\n if(not silent):\n print(\"Conditions for converegence of fit: at least 5 matches within {}px and at least 0.2 * minimum ( observed sources, catalog sources in fov) matches with the same radius\".format(dic_rms[\"radius_px\"]))\n if (dic_rms[\"matches\"] > 5 and dic_rms[\"matches\"] > 0.1 * N ):\n converged = True\n\n return converged","def fits(x, y):\n return y.memory <= x.memory and y.cores <= x.cores and y.disk <= x.disk","def is_fitted(self):\n\n return self.isFitted","def healthy_test(obj: np.ndarray) -> bool:\n nb_rows, nb_cols = obj.shape\n return nb_rows == nb_cols > 1 and np.array_equal(obj, colony(nb_rows))","def issquare(self):\r\n if self.width == self.height:\r\n return True\r\n else:\r\n return False","def check_none_zero_values(self):\n hits = -1\n if (len(self.data.shape) == 3):\n hits = 0\n frames = self.data.shape[0]\n pixels = self.data.shape[1]\n bins = self.data.shape[2]\n for i in range(frames):\n for j in range(pixels):\n for k in range(bins):\n value = self.data[i][j][k]\n if value > 0:\n hits += 1\n print(\"self.data[{}][{}][{}]; Sum so far = {}\".format(i, j, k, hits))\n return hits","def test_fit(self):\n X,Y,Z = self.generate_data()\n\n p={'k':-1,'r':0}\n key = (p['r'],p['k'])\n\n task = mmSCHPOLY()\n fit_result = task.fit(X,Y,Z)\n\n self.assertEqual(fit_result.best_poly_df[key].shape[0]==4,True)\n\n task2 = mmSCH2W()\n fit_result = task2.fit(X,Y,Z)\n\n self.assertEqual(fit_result.best_inter_df[key].shape[0]==6,True)","def validate(self):\n if self.isEmpty(): return False\n\n sum = 0\n for item in self.mask:\n sum += item.prob\n return sum == 1","def test_size_check(self):\n [x1, y1, s1, g1] = self.data.diffusion_data.shape\n [x2, y2, s2, g2] = module_05.run_module(self.data).diffusion_data.shape\n self.assertEqual(x1, x2)\n self.assertEqual(y1, y2)\n self.assertEqual(s1, s2)\n self.assertEqual(g1, g2)","def is_valid(box, img):\n valid_width = box['top_left_x'] > 0 and box['bottom_right_x'] < img.shape[1]\n valid_height = box['top_left_y'] > 0 and box['bottom_right_y'] < img.shape[0]\n return valid_width and valid_height","def check(self):\r\n self.check_probabilities()\r\n self.check_sum()","def check_size(self,x,y):\n assert(x <= 10**3), 'Width larger than 1000' \n assert(y <= 10**3), 'Height larger than 1000' \n assert(x*y <= 3*(10**5)), 'Resolution larger than 300000'","def test_fit(self, fit: str, baseline_images):\n fig = plt.figure()\n ax = fig.add_subplot(projection=\"ternary\")\n tn0, tn1, tn2 = get_spiral()\n ax.plot(tn0, tn1, tn2, \"C0\")\n ax.plot(tn0, tn1, tn2, \"k\", transform=ax.transTernaryAxes)\n ax.set_facecolor(\"0.9\")\n ax.grid(True)\n ax.set_ternary_lim(0.1, 0.7, 0.1, 0.6, 0.1, 0.5, fit)","def test_test_fit_equal_values(self):\n instance = GammaUnivariate()\n instance.fit(np.array([5, 5, 5, 5, 5, 5]))\n assert instance.constant_value == 5","def _check_size(self, img):\n absdiff = num.abs(num.subtract(img.shape, self.expected_size))\n pctdiff = num.true_divide(absdiff, self.expected_size)\n if not num.all(pctdiff <= self.size_tolerance):\n raise StandardError('image size outside form tolerance {} != {}'\n .format(img.shape, self.expected_size))","def do_grid_check(self,):\n self.ydim, self.xdim = self.data_fcst.shape \n if self.data_obs.shape != (self.ydim,self.xdim):\n raise FormatError(\"Obs and forecast data not same size.\")\n return","def check_image(image, psf_criteria=6):\n \n print('checking image: {}'.format(image))\n tab = pd.DataFrame(np.array(Table.read(image, format='fits')))\n # check the mean of FWHM < psf_criteria for good image\n if tab['FWHM_IMAGE'].mean() < psf_criteria:\n return 1\n else:\n return 0","def _verify_fit(self) -> None:\n if not hasattr(self, 'X_train') or not hasattr(self, 'Y_train'):\n raise ValueError('Training data not set. Call `fit` and pass training data first.')","def test_train_nn_overfits_the_data_for_small_input_size(self):\n self.nn.train_nn(self.X_train[:10], self.y_train[:10], 200, 1, 0.06)\n count = 0\n for i in range(10):\n out = self.nn.forward_prop(self.X_train[i])[0][-1]\n if np.argmax(out) == np.where(self.y_train[i])[0][0]:\n count += 1\n else:\n print(\"Incorrect\", np.argmax(out),\n np.where(self.y_train[i])[0][0])\n self.assertGreaterEqual(count, 5)","def _check_if_fitted(self):\n if self.covar_module is None:\n raise RuntimeError(\n \"Model has not been fitted. You need to call \"\n \"`fit_fully_bayesian_model_nuts` to fit the model.\"\n )","def test_fit(self):\n\n # Generate data with known parameters\n a, loc, scale = 1.0, 3.0, 5.0\n data = gamma.rvs(a, loc, scale, size=100000)\n\n # Fit the model and check parameters\n copula = GammaUnivariate()\n copula.fit(data)\n self.assertAlmostEqual(copula.a, a, places=1)\n self.assertAlmostEqual(copula.loc, loc, places=1)\n self.assertAlmostEqual(copula.scale, scale, places=1)","def quality_fis(self,fis):\n if fis.dimension() == self.training_data.shape[1]:\n last_res = 0.0\n count = 0\n for i in range(self.check_data.shape[0]):\n last_res = fis.evaluate(np.hstack((self.check_data[i],last_res)))\n if abs(last_res - self.id) < 0.5:\n count = count + 1\n return (count,self.check_data.shape[0])\n else:\n rvec = fis.evaluates(self.check_data) - self.id\n rvec = ma.masked_inside(rvec,-0.5,0.5)\n return (ma.count_masked(rvec),self.check_data.shape[0])\n \n if fis.dimension() == self.training_data.shape[1]:\n dat = np.hstack((self.check_data,self.id*np.ones((self.check_data.shape[0],1))))\n else:\n dat = self.check_data\n #if self.check_data.shape[1] == self.training_data.shape[1]:\n # dat = self.check_data\n #else:\n # dat = np.hstack((self.check_data,np.zeros((self.check_data.shape[0],1))))\n rvec = fis.evaluates(dat) - self.id\n rvec = ma.masked_inside(rvec,-0.5,0.5)\n return (ma.count_masked(rvec),self.check_data.shape[0])","def check_gaus_fit(hist):\n s = ROOT.TSpectrum(1)\n s.Search(hist, 1, \"new\")\n peaks_buff = s.GetPositionX()\n x_peak = peaks_buff[0]\n\n return (abs(hist.GetFunction('gaus').GetParameter(1) - x_peak) / abs(x_peak)) < 0.1","def test_fitting_accuracy(self):\r\n # Instantiate spectrum object, calibrate peak shape and fit all peaks\r\n spec = emg.spectrum(df=self.data,show_plot=False)\r\n spec.detect_peaks(thres=0.0053, plot_smoothed_spec=False,\r\n plot_2nd_deriv=False, plot_detection_result=False)\r\n msg0 = \"Incorrect number of peaks detected.\"\r\n assert len(spec.peaks) == len(self.true_mus), msg0\r\n spec.assign_species([\"Ni58:-1e\",\"Co58:-1e\",\"Mn58?:-1e\",\"Sn116:-2e\"])\r\n spec.assign_species(\"Mn58m?:-1e\", peak_index=2, Ex=71.77, Ex_error=0.05)\r\n spec.determine_peak_shape(species_shape_calib=\"Mn58m?:-1e\",\r\n show_plots=False)\r\n spec.fit_peaks(species_mass_calib=\"Ni58:-1e\",show_plots=False)\r\n\r\n # Perform accuracy checks\r\n for p in spec.peaks:\r\n if p.species == \"Ni58:-1e\":\r\n continue # skip calibrant\r\n msg1 = \"ME deviates from literature by more than 1 sigma.\"\r\n assert p.m_dev_keV <= p.mass_error_keV, msg1\r\n\r\n # Check calculation of (atomic) ME for doubly charged species\r\n if p.species == \"Sn116:-2e\":\r\n ME_dev_keV = p.atomic_ME_keV - self.ME_Sn116_keV\r\n msg2 = str(\"Respective deviation of ionic mass and atomic mass \"\r\n \"excess from literature differ by > 1 sigma for \"\r\n \"Sn116:-2e.\")\r\n assert abs(ME_dev_keV - p.m_dev_keV) < p.mass_error_keV, msg2","def testKnown(self):\n numAmps = (2, 2)\n bbox = afwGeom.Box2I(afwGeom.Point2I(0, 0), afwGeom.Extent2I(4, 4))\n # make a 4x4 image with 4 identical 2x2 subregions that flatten to -1, 0, 1, 2\n im = afwImage.ImageF(bbox)\n imArr = im.getArray()\n imArr[:, :] = np.array(((-1, 0, -1, 0),\n (1, 2, 1, 2),\n (-1, 0, -1, 0),\n (1, 2, 1, 2)), dtype=imArr.dtype)\n\n sqCoeffs = np.array(((0, 0.11), (-0.15, -12)))\n detector = self.makeDetector(bbox=bbox, numAmps=numAmps, sqCoeffs=sqCoeffs)\n ampInfoCat = detector.getAmpInfoCatalog()\n\n linSq = LinearizeSquared()\n linSq(im, detector=detector)\n\n # amp 0 has 0 squared coefficient and so makes no correction\n imArr0 = im.Factory(im, ampInfoCat[0].getBBox()).getArray()\n linCoeff0 = ampInfoCat[0].getLinearityCoeffs()[0]\n self.assertEqual(0, linCoeff0)\n self.assertFloatsAlmostEqual(imArr0.flatten(), (-1, 0, 1, 2))\n\n # test all amps\n for ampInfo in ampInfoCat:\n imArr = im.Factory(im, ampInfo.getBBox()).getArray()\n linCoeff = ampInfo.getLinearityCoeffs()[0]\n expect = np.array((-1 + linCoeff, 0, 1 + linCoeff, 2 + 4*linCoeff), dtype=imArr.dtype)\n self.assertFloatsAlmostEqual(imArr.flatten(), expect)","def has_been_fit(self):\n return self.predictor.has_been_fit","def check_cells_fit(cell_no, min_cell_distance, space_range=[[0,10],[0,10],None]):\n\n dim1, dim2, dim3 = space_range\n full_dim = 1.\n for dim in [dim1, dim2, dim3]:\n if dim != None:\n dim = dim[1]-dim[0]\n full_dim = full_dim*dim\n\n return full_dim / min_cell_distance >= cell_no","def test_constructed_is_small(self):\n self.assertTrue(all(elt<10 for elt in goodwinsheaf.checkradii()))#check all entries have small radii","def check_2x2_solved(self):\n return self._grid[0][0] == 0 and self._grid[0][1] == 1 \\\n and self._grid[1][0] == self._width*1 and self._grid[1][1] == (1 + self._width * 1)","def check_location_confidence(self):\n\t\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\n\t\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\n\t\tepsilon_meters = .08\n\t\tpixel_distances = []\n\t\tactual_distances = []\n\t\tnum_observed = 0\n\t\tfor ti in self.targs:\n\t\t\tif ti.props_are_set:\n\t\t\t\tfor tj in self.targs:\n\t\t\t\t\tif tj.props_are_set: \n\t\t\t\t\t\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\n\t\t\t\t\t\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\n\t\t\t\t\t\tif pixel_dist == 0:\n\t\t\t\t\t\t\tpixel_dist = 10000 #ignore two of the same points\n\t\t\t\t\t\t\tactual_dist = 10000\n\t\t\t\t\t\tpixel_distances.append(pixel_dist)\t\n\t\t\t\t\t\tactual_distances.append(actual_dist)\n\t\t\t\t\telse:\n\t\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\t\tactual_distances.append(10000)\n\t\t\telse:\n\t\t\t\tfor _ in self.targs:\n\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\tactual_distances.append(10000)\n\t\tmin_ind_pixel = np.argmin(pixel_distances)\n\t\tmin_ind_actual = np.argmin(actual_distances)\n\t\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\n\t\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\n\t\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\n\t\t\t#measurements are not trustworthy, return nothing\n\t\t\treturn None\n\n\t\treturn best_guys","def _is_skull_stripped(imgs):\n\n def _check_img(img):\n data = np.abs(nb.load(img).get_fdata(dtype=np.float32))\n sidevals = (\n data[0, :, :].sum()\n + data[-1, :, :].sum()\n + data[:, 0, :].sum()\n + data[:, -1, :].sum()\n + data[:, :, 0].sum()\n + data[:, :, -1].sum()\n )\n return sidevals < 10\n\n return all(_check_img(img) for img in imgs)","def inner_fit(self):\n pass","def inner_fit(self):\n pass","def mask_and_fit(mask, binary_warped, flag):\n img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)\n x, y = extract_pixels(img)\n fit, foundFlag, confidence_index = check_and_fit(x, y, flag)\n return fit, foundFlag, confidence_index","def _autocheck_dimensions(self):\n # W dimensions check list\n assert len(self.W.shape) == 2, f\"W shape should be (N, N) but is {self.W.shape}.\"\n assert self.W.shape[0] == self.W.shape[1], f\"W shape should be (N, N) but is {self.W.shape}.\"\n\n # Win dimensions check list\n assert len(self.Win.shape) == 2, f\"Win shape should be (N, input) but is {self.Win.shape}.\"\n err = f\"Win shape should be ({self.W.shape[1]}, input) but is {self.Win.shape}.\"\n assert self.Win.shape[0] == self.W.shape[0], err\n\n # Wout dimensions check list\n assert len(self.Wout.shape) == 2, f\"Wout shape should be (output, nb_states) but is {self.Wout.shape}.\"\n nb_states = self.Win.shape[1] + self.W.shape[0] + 1 if self.use_raw_inp else self.W.shape[0] + 1\n err = f\"Wout shape should be (output, {nb_states}) but is {self.Wout.shape}.\"\n assert self.Wout.shape[1] == nb_states, err\n\n # Wfb dimensions check list\n if self.Wfb is not None:\n assert len(self.Wfb.shape) == 2, f\"Wfb shape should be (input, output) but is {self.Wfb.shape}.\"\n err = f\"Wfb shape should be ({self.Win.shape[0]}, {self.Wout.shape[0]}) but is {self.Wfb.shape}.\"\n assert (self.Win.shape[0],self.Wout.shape[0]) == self.Wfb.shape, err","def assert_data_correct(self) -> bool:\n corr_char = self.assert_data_characters_correct()\n print(\"Character data correct?\", corr_char)\n corr_font = FontImages().assert_data_correct()\n print(\"Font data correct?\", corr_font)\n corr_frag = self.assert_data_fragments_correct()\n print(\"Fragment data correct?\", corr_frag)\n corr_train_aug = self.assert_train_augmented()\n print(\"Train data augmented?\", corr_train_aug)\n truth_agree = corr_char and corr_font and corr_frag\n return True if truth_agree else False","def check_shape(self):\r\n if np.array(self.img).shape != (1536, 2048, 3):\r\n raise BadShape","def test_fit(self, model):\r\n fit = model/np.linalg.norm(model, axis=1, keepdims=True)\r\n if self.white:\r\n sources = self.sources.dot(self.zca_matrix)\r\n sources /= np.linalg.norm(sources, axis=1, keepdims=True)\r\n else:\r\n sources = self.sources\r\n allthedots = sources.dot(fit.T)\r\n # how close is the closest model source to each true source?\r\n bestfits = np.max(np.abs(allthedots), axis=1)\r\n return np.median(bestfits)","def _check_shape(self, X):\n return all([X.shape[i] == self.train_shape[i] for i in range(2)])","def check_correctness(classifier_out, mode, image_type):\n labels = image_type.image_data[mode].labels\n num_correct = 0\n total = len(classifier_out)\n for index, label in classifier_out:\n if labels[index] == label:\n num_correct += 1\n print(f'Got {num_correct} out of {total} correct: {(num_correct / total) * 100}%')","def _evaluate_during_fit(self, test_loader, epoch):","def fit(self):\n raise NotImplementedError # pragma: no cover","def check_fit(data, data_fit, time_points):\n plt.figure()\n for jj,(ii,lab) in enumerate(zip([Sub.T, Sub.D, Sub.H, Sub.C],[\"Cases\", \"Deaths\", \"Hospitalized\", \"ICU\"])):\n if data[ii] is not None:\n plt.plot(time_points, data[ii], c=f\"C{jj}\", label=lab)\n plt.plot(time_points, data_fit[ii], '--', c=f\"C{jj}\", label=f\"{lab} fit\")\n plt.yscale(\"log\")\n plt.legend()\n # plt.savefig(\"Test_fitting\", format=\"png\")\n plt.show()","def test_with_fitted(self):\n X, y = make_blobs(\n n_samples=100, n_features=5, centers=3, shuffle=False, random_state=112\n )\n model = MiniBatchKMeans().fit(X)\n labels = model.predict(X)\n\n with mock.patch.object(model, \"fit\") as mockfit:\n oz = SilhouetteVisualizer(model)\n oz.fit(X)\n mockfit.assert_not_called()\n\n with mock.patch.object(model, \"fit\") as mockfit:\n oz = SilhouetteVisualizer(model, is_fitted=True)\n oz.fit(X)\n mockfit.assert_not_called()\n\n with mock.patch.object(model, \"fit_predict\", return_value=labels) as mockfit:\n oz = SilhouetteVisualizer(model, is_fitted=False)\n oz.fit(X)\n mockfit.assert_called_once_with(X, None)","def _image_is_large_enough(im):\n return (im.shape[0] >= MIN_DIM) and (im.shape[1] >= MIN_DIM)","def test_point_with_zero_value_is_good():\n point = np.array([0, 20])\n image_dimensions = np.array([100, 100])\n assert point_within_dimensions(point, image_dimensions)","def _check_partial_fit_first_call(clf, classes=None):\n if getattr(clf, \"classes_\", None) is None and classes is None:\n raise ValueError(\"classes must be passed on the first call to partial_fit.\")\n\n elif classes is not None:\n if getattr(clf, \"classes_\", None) is not None:\n if not np.array_equal(clf.classes_, unique_labels(classes)):\n raise ValueError(\n \"`classes=%r` is not the same as on last call \"\n \"to partial_fit, was: %r\" % (classes, clf.classes_)\n )\n\n else:\n # This is the first call to partial_fit\n clf.classes_ = unique_labels(classes)\n return True\n\n # classes is None and clf.classes_ has already previously been set:\n # nothing to do\n return False","def validate(net, val_data, ctx, eval_metric, size, args):\n clipper = gcv.nn.bbox.BBoxClipToImage()\n eval_metric.reset()\n # set nms threshold and topk constraint\n net.set_nms(nms_thresh=0.45, nms_topk=400)\n mx.nd.waitall()\n net.hybridize()\n\n with tqdm(total=size) as pbar:\n for ib, batch in enumerate(val_data):\n # if(ib >= 200):\n # break\n batch = split_and_load(batch, ctx_list=ctx)\n det_bboxes = []\n det_ids = []\n det_scores = []\n det_coefs = []\n det_infos = []\n\n for x, im_info in zip(*batch):\n # get prediction results\n t1 = time.time()\n ids, scores, bboxes, coefs = net(x)\n t2 = time.time()\n det_bboxes.append(clipper(bboxes, x))\n det_ids.append(ids)\n det_scores.append(scores)\n det_coefs.append(coefs)\n det_infos.append(im_info)\n\n # update metric\n for det_bbox, det_id, det_score, def_coef, det_info in zip(det_bboxes, det_ids, det_scores, det_coefs, det_infos):\n for i in range(det_info.shape[0]):\n # numpy everything\n det_bbox = det_bbox[i].asnumpy()\n det_id = det_id[i].asnumpy()\n det_score = det_score[i].asnumpy()\n def_coef = def_coef[i].asnumpy()\n det_info = det_info[i].asnumpy()\n # filter by conf threshold\n im_height, im_width = det_info\n valid = np.where(((det_id >= 0) & (det_score >= 0.001)))[0]\n det_id = det_id[valid]\n det_score = det_score[valid]\n # To bbox of original img size\n det_bbox = det_bbox[valid]\n det_bbox[:, 0] *= (im_width / 416.0)\n det_bbox[:, 2] *= (im_width / 416.0)\n det_bbox[:, 1] *= (im_height / 416.0)\n det_bbox[:, 3] *= (im_height / 416.0)\n\n def_coef = def_coef[valid]\n eval_metric.update(det_bbox, det_id, det_score, def_coef, int(im_height), int(im_width))\n\n pbar.update(len(ctx))\n\n return eval_metric.get()","def checkNumNeighbors():","def testTicket1123(self):\n\n ctrl = afwMath.StatisticsControl()\n ctrl.setAndMask(~0x0)\n \n mimg = afwImage.MaskedImageF(afwGeom.Extent2I(10, 10))\n mimg.set([self.val, 0x1, self.val])\n\n # test the case with no valid pixels ... both mean and stdev should be nan\n stat = afwMath.makeStatistics(mimg, afwMath.MEAN | afwMath.STDEV, ctrl)\n mean = stat.getValue(afwMath.MEAN)\n stdev = stat.getValue(afwMath.STDEV)\n self.assertNotEqual(mean, mean) # NaN does not equal itself\n self.assertNotEqual(stdev, stdev) # NaN does not equal itself\n \n # test the case with one valid pixel ... mean is ok, but stdev should still be nan\n mimg.getMask().set(1, 1, 0x0)\n stat = afwMath.makeStatistics(mimg, afwMath.MEAN | afwMath.STDEV, ctrl)\n mean = stat.getValue(afwMath.MEAN)\n stdev = stat.getValue(afwMath.STDEV)\n self.assertEqual(mean, self.val)\n self.assertNotEqual(stdev, stdev) # NaN does not equal itself\n\n # test the case with two valid pixels ... both mean and stdev are ok\n mimg.getMask().set(1, 2, 0x0)\n stat = afwMath.makeStatistics(mimg, afwMath.MEAN | afwMath.STDEV, ctrl)\n mean = stat.getValue(afwMath.MEAN)\n stdev = stat.getValue(afwMath.STDEV)\n self.assertEqual(mean, self.val)\n self.assertEqual(stdev, 0.0)","def evaluate_fit_range(predicted, fit_range):\n test1 = (predicted[0] >= fit_range[0])\n test2 = (predicted[0] <= fit_range[1])\n test3 = (predicted[1] >= fit_range[2])\n test4 = (predicted[1] <= fit_range[3])\n return all([test1, test2, test3, test4])","def testCheckBlocksFitLength_Pass(self):\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\n 64, 4, 16, 'foo'))\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\n 60, 4, 16, 'foo'))\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\n 49, 4, 16, 'foo'))\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\n 48, 3, 16, 'foo'))","def fits(self, ctx: EvaluationContext) -> bool:\n return self.rules.is_satisfied(ctx) and self.targets.match(ctx)","def test_basic(self):\r\n self.validate((3, 2, 8, 8), (4, 2, 5, 5), 'valid', verify_grad=False)\r\n self.validate((3, 2, 7, 5), (5, 2, 2, 3), 'valid')\r\n self.validate((3, 2, 7, 5), (5, 2, 3, 2), 'valid', verify_grad=False)\r\n self.validate((3, 2, 8, 8), (4, 2, 5, 5), 'full', verify_grad=False)\r\n self.validate((3, 2, 7, 5), (5, 2, 2, 3), 'full')\r\n # test filter same size as input\r","def testSize (self):\r\n \r\n perpixel = bytes_per_pixel [self.bih_vals [bih_BitCount]]\r\n width = self.bih_vals [bih_Width]\r\n height = self.bih_vals [bih_Height]\r\n expected = self.bih_vals [bih_SizeImage]\r\n\r\n # Rows always have multiples of 4 bytes\r\n \r\n padding = 3 - ((perpixel * width + 3) % 4)\r\n size = (width * perpixel + padding) * height\r\n\r\n if not size == expected:\r\n print \"Calculated size = %d (<> %d)\" % (size, expected)\r\n print \"***** File size error *****\"","def is_isotropic(self):\n return self.fibres is None","def __check_bit_size(self, value, num_bits):\n is_fit = False\n if value <= 2 ** num_bits - 1:\n is_fit = True\n return is_fit","def check_correctness_statistics(classifier_out, mode, image_type):\n labels = image_type.image_data[mode].labels\n num_correct = 0\n total = len(classifier_out)\n for index, label in classifier_out:\n if labels[index] == label:\n num_correct += 1\n return (num_correct / total) * 100","def check_evaluation_points(x, y):\n assert x.ndim == y.ndim == 1\n assert x.shape == y.shape\n assert x.dtype == y.dtype == np.float64","def test_multifit_num_results(self, perform_fit):\n cost_func = make_cost_function('multifit_set/multifit.txt')\n problem = cost_func.problem\n cost_func.jacobian = Scipy(problem)\n cost_func.jacobian.method = '2-point'\n controller = DummyController(cost_func=cost_func)\n options = problem.options\n options.table_type = ['acc', 'runtime', 'compare', 'local_min']\n grabbed_output = output_grabber.OutputGrabber(options)\n controller.final_params = [[0.1, 0.1], [0.1, 0.1]]\n controller.parameter_set = 0\n perform_fit.return_value = ([0.1, 0.2],\n [0.1, 0.01],\n [10e-3, 10e-4])\n results = loop_over_hessians(controller=controller,\n options=options,\n grabbed_output=grabbed_output,\n checkpointer=self.cp)\n self.assertTrue(len(results) == 2)","def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\n\n # useful display and computational data\n y_fitted = poly_fit(x_data)\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\n x_fitted_display = np.linspace(min_x_display, max_x_display)\n y_fitted_display = poly_fit(x_fitted_display)\n\n # goodness of fit indicators\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\n R2 = 1.0 - SSE/SST # R squared\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\n\n fig = plt.figure()\n ax = fig.add_subplot(1, 2, 1)\n\n # plot of the fitted polynomial itself\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\n ax.scatter(x_data, y_data, color='C7')\n ax.set(title=\"Fitted polynomial (deg{}) for \\'{}\\'\".format(poly_fit.order, fit_name), xlabel=\"x\", ylabel=\"y\")\n\n # histogram of residuals\n ax2 = fig.add_subplot(1, 2, 2)\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\n ax2.set(title=\"Histogram of residuals\", xlabel=\"Residual value $y_k - \\\\widehat{y_k}$\", ylabel=\"Count\")\n\n # display of fit indicators\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\n\n fig.tight_layout()\n fig.subplots_adjust(bottom=0.2)\n\n figurefiles.save_in_perfs_fits_folder(fig, \"Polyfit_{}_order_{}.pdf\".format(fit_name, poly_fit.order))","def _c_fits_consistent(fit1, fit2, quantile=.125):\n # [.125, .25, .4, .5, .6, .75, .875]\n try:\n log.debug('Checking fits against each others {} quantiles' \\\n .format(quantile))\n\n qmin = list(fit1.quantiles).index( quantile)\n qmax = list(fit1.quantiles).index(1-quantile)\n log.debug('{} < {} < {} ?'.format(\n fit2.tauquantiles[qmin], fit1.tau, fit2.tauquantiles[qmax]))\n if fit1.tau > fit2.tauquantiles[qmax] \\\n or fit1.tau < fit2.tauquantiles[qmin]:\n return False\n\n qmin = list(fit2.quantiles).index( quantile)\n qmax = list(fit2.quantiles).index(1-quantile)\n log.debug('{} < {} < {} ?'.format(\n fit1.tauquantiles[qmin], fit2.tau, fit1.tauquantiles[qmax]))\n if fit2.tau > fit1.tauquantiles[qmax] \\\n or fit2.tau < fit1.tauquantiles[qmin]:\n return False\n\n return True\n except Exception as e:\n log.debug('Quantile not found in fit', exc_info=True)\n\n return False","def check(self, test_set):\n for id in test_set.keys():\n image = test_set[id]\n answers = {}\n for mood, perceptron in self._perceptrons.items():\n answers[perceptron.check(image)] = mood\n final_answer = answers[max(answers.keys())]\n print('Image{} {}'.format(id, final_answer.value))","def test(self, data_set):\r\n\r\n correct = 0.0\r\n total = 0.0\r\n\r\n for input, target in data_set:\r\n #actual output from neural net\r\n output = self.predict(input)\r\n total += 1.0 #number of total output vectors\r\n\r\n if allclose(output, target, self.converge) == True:\r\n correct += 1.0\r\n\r\n return correct/total","def testTicket1125(self):\n mimg = afwImage.MaskedImageF(afwGeom.Extent2I(10, 10))\n mimg.set([self.val, 0x1, self.val])\n\n ctrl = afwMath.StatisticsControl()\n ctrl.setAndMask(~0x0)\n \n # test the case with no valid pixels ... try MEANCLIP and STDEVCLIP\n stat = afwMath.makeStatistics(mimg, afwMath.MEANCLIP | afwMath.STDEVCLIP, ctrl)\n mean = stat.getValue(afwMath.MEANCLIP)\n stdev = stat.getValue(afwMath.STDEVCLIP)\n self.assertNotEqual(mean, mean) # NaN does not equal itself\n self.assertNotEqual(stdev, stdev) # NaN does not equal itself","def test_final_result():\n img = cv2.imread(os.path.join(TESTS_ASSETS_VISION_DIR, \"mussels_sample.PNG\"))\n _orig, _circles_removed, _blurred_and_smoothed, _convex_hull, _mussels_found, _mussels_count = count_mussels(img)\n final_result = _mussels_count\n assert final_result == 8","def check_for_fit(cls, method):\n\n @wraps(method)\n def _check_for_fit(self, X=None, y=None):\n klass = type(self).__name__\n if not self._is_fitted and self.needs_fitting:\n raise ComponentNotYetFittedError(\n f\"This {klass} is not fitted yet. You must fit {klass} before calling {method.__name__}.\"\n )\n else:\n return method(self, X, y)\n\n return _check_for_fit","def test_whitley(self):\n fun = get_problem('whitley', self.dimension)\n self.assertEqual(fun(self.array2), 0.0)","def _check_data_valid(self):\n\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\n if not is_valid:\n raise FITSException(f\"No data in {self.survey}\")","def get_percentage_false_class(arr_of_results):\n\n count_success = np.zeros_like(arr_of_results[:,0], dtype=float)\n count_correct_prediction = 0\n\n for i in range(len(arr_of_results[0])):\n use = True\n for result in arr_of_results[:,i]:\n if result[\"image_target\"] != result[\"prediction_image\"] or result[\"std_noise\"] == 0:\n use = False\n if use:\n count_correct_prediction += 1\n i2 = 0\n for result in arr_of_results[:,i]:\n if result[\"success\"]:\n count_success[i2] += 1\n i2 += 1\n\n\n errors = proportion_confint(count_success, count_correct_prediction)\n count_success = count_success/count_correct_prediction\n errors = np.array(errors)\n\n errors[0] = np.abs(count_success - errors[0])\n errors[1] = np.abs(count_success - errors[1])\n\n return count_success, errors","def fit(self):\n raise NotImplementedError","def test_point_within_dimensions_true():\n point = np.array([10, 20])\n image_dimensions = np.array([100, 100])\n assert point_within_dimensions(point, image_dimensions)","def test_intra_power_law_fit(self):\n\n\t\tprint(type(self.fc_layers[0:2]), self.fc_layers[0:2])\n\t\tdetails= self.watcher.analyze(layers=self.fc_layers[0:2], intra=True, randomize=False, vectors=False, pl_package=POWERLAW_PACKAGE, xmax=XMAX_FORCE)\n\t\tactual_alpha = details.alpha[0]\n\t\t#actual_best_fit = details.best_fit[0]\n\t\t#print(actual_alpha,actual_best_fit)\n\n\t\texpected_alpha = 2.654 # not very accurate because of the sparisify transform\n\t\t#expected_best_fit = LOG_NORMAL\n\t\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=1)\n\t\t#self.assertEqual(actual_best_fit, expected_best_fit)","def _check_dimensions(self, workspace_to_check):\n for i in range(self._raw_ws.getNumDims()):\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\n return False\n return True","def validate(self, epn, num_samples_to_test = 1000):\n batch_size = epn.batch_size\n dataloader = torch.utils.data.DataLoader(dataset = self, batch_size = batch_size, shuffle=True)\n num_samples_evaluated = 0\n num_correct = 0\n for batch_idx, (x_data, y_target) in enumerate(dataloader):\n epn.randomize_initial_state(batch_size = batch_size)\n epn.set_x_state(x_data)\n s = epn.evolve_to_equilbrium(y_target = None, beta = 0)\n compared = s[:,epn.iy].argmax(dim = 1) == y_target[:].argmax(dim = 1)\n num_samples_evaluated += batch_size\n num_correct += torch.sum(compared)\n if num_samples_evaluated > num_samples_to_test:\n break\n error = (1-num_correct.item()/num_samples_evaluated)\n return error","def test_number_of_paint_cans_calculated_correctly_1():\n\n info = paintCanInfo.PaintCanInfo(0)\n info.efficiency = 5\n\n assert paintCanCalculator.how_many_needed(5, 5, info) == 5, \\\n 'Result for 5x5 wall and 5m^2 paint can efficiency should should be 5!'","def plotGaussian3Dbatchfit(param_all, img_crop_all, ind_plot):\n\n fit_result = param_all[ind_plot, 6:]\n img_crop = img_crop_all[ind_plot, :, :, :]\n\n fit_img_fun = symmetricGaussian3D(*fit_result)\n fit_img = fit_img_fun(*np.indices(img_crop.shape))\n\n # Create figure and axes\n import matplotlib.pyplot as plt\n\n fig_detect, (ax1, ax2) = plt.subplots(1, 2)\n\n plt.subplot(231)\n plt.imshow(np.amax(img_crop, axis=0), cmap='magma')\n plt.plot(fit_result[4], fit_result[3], marker='o', linestyle='--', color='g', label='Square')\n plt.axis('off')\n plt.title('Raw image-XY')\n plt.colorbar()\n\n plt.subplot(232)\n plt.imshow(np.amax(img_crop, axis=1), cmap='magma')\n plt.plot(fit_result[4], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\n plt.axis('off')\n plt.title('Raw image-XZ')\n plt.colorbar()\n\n plt.subplot(233)\n plt.imshow(np.amax(img_crop, axis=2), cmap='magma')\n plt.plot(fit_result[3], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\n plt.axis('off')\n plt.title('Raw image-YZ')\n plt.colorbar()\n\n ax2 = plt.subplot(234)\n plt.imshow(np.amax(fit_img, axis=0), cmap='magma')\n plt.plot(fit_result[4], fit_result[3], marker='o', linestyle='--', color='g', label='Square')\n plt.axis('off')\n plt.title('Fit image-XY')\n plt.colorbar()\n\n ax2 = plt.subplot(235)\n plt.imshow(np.amax(fit_img, axis=1), cmap='magma')\n plt.plot(fit_result[4], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\n plt.axis('off')\n plt.title('Fit image-XZ')\n plt.colorbar()\n\n ax2 = plt.subplot(236)\n plt.imshow(np.amax(fit_img, axis=2), cmap='magma')\n plt.plot(fit_result[3], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\n plt.axis('off')\n plt.title('Fit image-YZ')\n plt.colorbar()","def victory_checker() -> bool:\r\n conflict_check()\r\n for x in range(shape):\r\n for y in range(shape):\r\n if conflict_space[x, y] != 0:\r\n return False\r\n if separation_crawler(False):\r\n return False\r\n return True","def _check_success(self):\n cube_height = self.sim.data.body_xpos[self.cube_body_id][2]\n table_height = self.table_full_size[2]\n\n # cube is higher than the table top above a margin\n return cube_height > table_height + 0.10","def analyse(self):\n self.__try_fitting()\n self.second.rotate()\n self.__try_fitting()","def test_is_filled(self):\n n = 10\n matrix = g.np.random.uniform(size=(n + 1,) * 3) > 0.5\n not_matrix = g.np.logical_not(matrix)\n pitch = 1. / n\n origin = g.np.random.uniform(size=(3,))\n vox = g.trimesh.voxel.VoxelGrid(matrix)\n vox = vox.apply_scale(pitch).apply_translation(origin)\n not_vox = g.trimesh.voxel.VoxelGrid(not_matrix)\n not_vox = not_vox.apply_scale(pitch).apply_translation(origin)\n for a, b in ((vox, not_vox), (not_vox, vox)):\n points = a.points\n # slight jitter - shouldn't change indices\n points += (\n g.np.random.uniform(size=points.shape) - 1) * 0.4 * pitch\n g.np.random.shuffle(points)\n\n # all points are filled, and no empty points are filled\n assert g.np.all(a.is_filled(points))\n assert not g.np.any(b.is_filled(points))\n\n # test different number of dimensions\n points = g.np.stack([points, points[-1::-1]], axis=1)\n assert g.np.all(a.is_filled(points))\n assert not g.np.any(b.is_filled(points))"],"string":"[\n \"def _check_is_fitted(self):\\n check_is_fitted(self, ['w', 'b'])\",\n \"def will_data_fit(bit_num, image, bits_per_pix):\\r\\n max_bits = reduce(lambda x, y: x * y, image.size) * bits_per_pix\\r\\n return bit_num <= max_bits\",\n \"def _check_is_fitted(self):\\n # Do not check `b` as some classifiers do not set it\\n check_is_fitted(self, 'w')\\n super(CClassifierLinear, self)._check_is_fitted()\",\n \"def is_fit(self):\\n if not hasattr(self, '_icc_imgs'):\\n return False\\n else:\\n return self._icc_imgs is not None\",\n \"def test_fit(self):\\n X = np.zeros((2, 3), dtype=np.float64)\\n snv = SNV(q=50)\\n try:\\n _ = snv.fit(X)\\n except:\\n self.assertTrue(False)\",\n \"def _check_if_fitted(self):\\n if not self.fitted:\\n raise AssertionError('Model is not fitted! Fit the model to a '\\n 'dataset before attempting to plot results.')\",\n \"def test_fit_score(self):\\n oz = ClassificationScoreVisualizer(GaussianNB())\\n assert_not_fitted(oz, X_test=self.binary.X.test)\\n assert oz.fit(self.binary.X.train, self.binary.y.train) is oz\\n assert 0.0 <= oz.score(self.binary.X.test, self.binary.y.test) <= 1.0\\n assert_fitted(oz, X_test=self.binary.X.test)\",\n \"def number_of_images_valid():\\r\\n if number_of_images_a_valid() and number_of_images_b_valid():\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def _check_fitted(self):\\n assert self.subspace_basis is not None, \\\\\\n 'You must fit %s before you can project' % self.__class__.__name__\",\n \"def _check_fitted(self):\\n assert self.subspace_basis is not None, \\\\\\n 'You must fit %s before you can project' % self.__class__.__name__\",\n \"def has_fit(client: NumPyClient) -> bool:\\n return type(client).fit != NumPyClient.fit\",\n \"def is_fitted(self):\\n return self.__fdata is not None\",\n \"def is_perfect_square():\",\n \"def is_full(self):\\r\\n return self.num_checkers == self.width * self.height\",\n \"def _fit_test(self, img_ext) -> int:\\n sum_squared_difference = np.sum(np.square(self._orig_img.img - img_ext.img))\\n\\n return sum_squared_difference\",\n \"def fit():\\n pass\",\n \"def checks(self, poly_fit, poly_fitx, poly_fity):\\n if self.best_fit is not None:\\n if not (np.abs(self.best_fit-poly_fit) <\\n np.array([0.001, 1, 500])).all():\\n return False\\n if self.bestx is not None:\\n if np.mean(np.abs(self.bestx-poly_fitx)) > 200:\\n return False\\n\\n return True\",\n \"def sanity_check(self):\\n score = 0\\n curvatures = self._curvature()\\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\\n # difference in curvature is more than 15%\\n score -= 1\\n\\n diff_std = np.std(self.right_fitx - self.left_fitx)\\n if diff_std > 30:\\n # std of the difference between the right lane and left lane is more than 30 pixel\\n score -= 1\\n\\n # roughly parallel\\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\\n # difference in slope is more than 15%\\n score -= 1\\n\\n return score\",\n \"def fit_test(self):\",\n \"def determine_if_fit_converged(dic_rms, catalog, observation, wcsprm, NAXIS1, NAXIS2, silent=False):\\n converged = False\\n\\n N_obs = observation.shape[0]\\n\\n catalog_on_sensor = wcsprm.s2p(catalog[[\\\"ra\\\", \\\"dec\\\"]], 1)['pixcrd']\\n cat_x = np.array( [catalog_on_sensor[:,0] ])\\n cat_y = np.array( [catalog_on_sensor[:,1] ])\\n mask = (cat_x >= 0) & (cat_x <= NAXIS1) & (cat_y >= 0) & (cat_y <= NAXIS2)\\n N_cat = mask.sum()\\n\\n N = min([N_obs, N_cat])\\n if(not silent):\\n print(\\\"Conditions for converegence of fit: at least 5 matches within {}px and at least 0.2 * minimum ( observed sources, catalog sources in fov) matches with the same radius\\\".format(dic_rms[\\\"radius_px\\\"]))\\n if (dic_rms[\\\"matches\\\"] > 5 and dic_rms[\\\"matches\\\"] > 0.1 * N ):\\n converged = True\\n\\n return converged\",\n \"def fits(x, y):\\n return y.memory <= x.memory and y.cores <= x.cores and y.disk <= x.disk\",\n \"def is_fitted(self):\\n\\n return self.isFitted\",\n \"def healthy_test(obj: np.ndarray) -> bool:\\n nb_rows, nb_cols = obj.shape\\n return nb_rows == nb_cols > 1 and np.array_equal(obj, colony(nb_rows))\",\n \"def issquare(self):\\r\\n if self.width == self.height:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def check_none_zero_values(self):\\n hits = -1\\n if (len(self.data.shape) == 3):\\n hits = 0\\n frames = self.data.shape[0]\\n pixels = self.data.shape[1]\\n bins = self.data.shape[2]\\n for i in range(frames):\\n for j in range(pixels):\\n for k in range(bins):\\n value = self.data[i][j][k]\\n if value > 0:\\n hits += 1\\n print(\\\"self.data[{}][{}][{}]; Sum so far = {}\\\".format(i, j, k, hits))\\n return hits\",\n \"def test_fit(self):\\n X,Y,Z = self.generate_data()\\n\\n p={'k':-1,'r':0}\\n key = (p['r'],p['k'])\\n\\n task = mmSCHPOLY()\\n fit_result = task.fit(X,Y,Z)\\n\\n self.assertEqual(fit_result.best_poly_df[key].shape[0]==4,True)\\n\\n task2 = mmSCH2W()\\n fit_result = task2.fit(X,Y,Z)\\n\\n self.assertEqual(fit_result.best_inter_df[key].shape[0]==6,True)\",\n \"def validate(self):\\n if self.isEmpty(): return False\\n\\n sum = 0\\n for item in self.mask:\\n sum += item.prob\\n return sum == 1\",\n \"def test_size_check(self):\\n [x1, y1, s1, g1] = self.data.diffusion_data.shape\\n [x2, y2, s2, g2] = module_05.run_module(self.data).diffusion_data.shape\\n self.assertEqual(x1, x2)\\n self.assertEqual(y1, y2)\\n self.assertEqual(s1, s2)\\n self.assertEqual(g1, g2)\",\n \"def is_valid(box, img):\\n valid_width = box['top_left_x'] > 0 and box['bottom_right_x'] < img.shape[1]\\n valid_height = box['top_left_y'] > 0 and box['bottom_right_y'] < img.shape[0]\\n return valid_width and valid_height\",\n \"def check(self):\\r\\n self.check_probabilities()\\r\\n self.check_sum()\",\n \"def check_size(self,x,y):\\n assert(x <= 10**3), 'Width larger than 1000' \\n assert(y <= 10**3), 'Height larger than 1000' \\n assert(x*y <= 3*(10**5)), 'Resolution larger than 300000'\",\n \"def test_fit(self, fit: str, baseline_images):\\n fig = plt.figure()\\n ax = fig.add_subplot(projection=\\\"ternary\\\")\\n tn0, tn1, tn2 = get_spiral()\\n ax.plot(tn0, tn1, tn2, \\\"C0\\\")\\n ax.plot(tn0, tn1, tn2, \\\"k\\\", transform=ax.transTernaryAxes)\\n ax.set_facecolor(\\\"0.9\\\")\\n ax.grid(True)\\n ax.set_ternary_lim(0.1, 0.7, 0.1, 0.6, 0.1, 0.5, fit)\",\n \"def test_test_fit_equal_values(self):\\n instance = GammaUnivariate()\\n instance.fit(np.array([5, 5, 5, 5, 5, 5]))\\n assert instance.constant_value == 5\",\n \"def _check_size(self, img):\\n absdiff = num.abs(num.subtract(img.shape, self.expected_size))\\n pctdiff = num.true_divide(absdiff, self.expected_size)\\n if not num.all(pctdiff <= self.size_tolerance):\\n raise StandardError('image size outside form tolerance {} != {}'\\n .format(img.shape, self.expected_size))\",\n \"def do_grid_check(self,):\\n self.ydim, self.xdim = self.data_fcst.shape \\n if self.data_obs.shape != (self.ydim,self.xdim):\\n raise FormatError(\\\"Obs and forecast data not same size.\\\")\\n return\",\n \"def check_image(image, psf_criteria=6):\\n \\n print('checking image: {}'.format(image))\\n tab = pd.DataFrame(np.array(Table.read(image, format='fits')))\\n # check the mean of FWHM < psf_criteria for good image\\n if tab['FWHM_IMAGE'].mean() < psf_criteria:\\n return 1\\n else:\\n return 0\",\n \"def _verify_fit(self) -> None:\\n if not hasattr(self, 'X_train') or not hasattr(self, 'Y_train'):\\n raise ValueError('Training data not set. Call `fit` and pass training data first.')\",\n \"def test_train_nn_overfits_the_data_for_small_input_size(self):\\n self.nn.train_nn(self.X_train[:10], self.y_train[:10], 200, 1, 0.06)\\n count = 0\\n for i in range(10):\\n out = self.nn.forward_prop(self.X_train[i])[0][-1]\\n if np.argmax(out) == np.where(self.y_train[i])[0][0]:\\n count += 1\\n else:\\n print(\\\"Incorrect\\\", np.argmax(out),\\n np.where(self.y_train[i])[0][0])\\n self.assertGreaterEqual(count, 5)\",\n \"def _check_if_fitted(self):\\n if self.covar_module is None:\\n raise RuntimeError(\\n \\\"Model has not been fitted. You need to call \\\"\\n \\\"`fit_fully_bayesian_model_nuts` to fit the model.\\\"\\n )\",\n \"def test_fit(self):\\n\\n # Generate data with known parameters\\n a, loc, scale = 1.0, 3.0, 5.0\\n data = gamma.rvs(a, loc, scale, size=100000)\\n\\n # Fit the model and check parameters\\n copula = GammaUnivariate()\\n copula.fit(data)\\n self.assertAlmostEqual(copula.a, a, places=1)\\n self.assertAlmostEqual(copula.loc, loc, places=1)\\n self.assertAlmostEqual(copula.scale, scale, places=1)\",\n \"def quality_fis(self,fis):\\n if fis.dimension() == self.training_data.shape[1]:\\n last_res = 0.0\\n count = 0\\n for i in range(self.check_data.shape[0]):\\n last_res = fis.evaluate(np.hstack((self.check_data[i],last_res)))\\n if abs(last_res - self.id) < 0.5:\\n count = count + 1\\n return (count,self.check_data.shape[0])\\n else:\\n rvec = fis.evaluates(self.check_data) - self.id\\n rvec = ma.masked_inside(rvec,-0.5,0.5)\\n return (ma.count_masked(rvec),self.check_data.shape[0])\\n \\n if fis.dimension() == self.training_data.shape[1]:\\n dat = np.hstack((self.check_data,self.id*np.ones((self.check_data.shape[0],1))))\\n else:\\n dat = self.check_data\\n #if self.check_data.shape[1] == self.training_data.shape[1]:\\n # dat = self.check_data\\n #else:\\n # dat = np.hstack((self.check_data,np.zeros((self.check_data.shape[0],1))))\\n rvec = fis.evaluates(dat) - self.id\\n rvec = ma.masked_inside(rvec,-0.5,0.5)\\n return (ma.count_masked(rvec),self.check_data.shape[0])\",\n \"def check_gaus_fit(hist):\\n s = ROOT.TSpectrum(1)\\n s.Search(hist, 1, \\\"new\\\")\\n peaks_buff = s.GetPositionX()\\n x_peak = peaks_buff[0]\\n\\n return (abs(hist.GetFunction('gaus').GetParameter(1) - x_peak) / abs(x_peak)) < 0.1\",\n \"def test_fitting_accuracy(self):\\r\\n # Instantiate spectrum object, calibrate peak shape and fit all peaks\\r\\n spec = emg.spectrum(df=self.data,show_plot=False)\\r\\n spec.detect_peaks(thres=0.0053, plot_smoothed_spec=False,\\r\\n plot_2nd_deriv=False, plot_detection_result=False)\\r\\n msg0 = \\\"Incorrect number of peaks detected.\\\"\\r\\n assert len(spec.peaks) == len(self.true_mus), msg0\\r\\n spec.assign_species([\\\"Ni58:-1e\\\",\\\"Co58:-1e\\\",\\\"Mn58?:-1e\\\",\\\"Sn116:-2e\\\"])\\r\\n spec.assign_species(\\\"Mn58m?:-1e\\\", peak_index=2, Ex=71.77, Ex_error=0.05)\\r\\n spec.determine_peak_shape(species_shape_calib=\\\"Mn58m?:-1e\\\",\\r\\n show_plots=False)\\r\\n spec.fit_peaks(species_mass_calib=\\\"Ni58:-1e\\\",show_plots=False)\\r\\n\\r\\n # Perform accuracy checks\\r\\n for p in spec.peaks:\\r\\n if p.species == \\\"Ni58:-1e\\\":\\r\\n continue # skip calibrant\\r\\n msg1 = \\\"ME deviates from literature by more than 1 sigma.\\\"\\r\\n assert p.m_dev_keV <= p.mass_error_keV, msg1\\r\\n\\r\\n # Check calculation of (atomic) ME for doubly charged species\\r\\n if p.species == \\\"Sn116:-2e\\\":\\r\\n ME_dev_keV = p.atomic_ME_keV - self.ME_Sn116_keV\\r\\n msg2 = str(\\\"Respective deviation of ionic mass and atomic mass \\\"\\r\\n \\\"excess from literature differ by > 1 sigma for \\\"\\r\\n \\\"Sn116:-2e.\\\")\\r\\n assert abs(ME_dev_keV - p.m_dev_keV) < p.mass_error_keV, msg2\",\n \"def testKnown(self):\\n numAmps = (2, 2)\\n bbox = afwGeom.Box2I(afwGeom.Point2I(0, 0), afwGeom.Extent2I(4, 4))\\n # make a 4x4 image with 4 identical 2x2 subregions that flatten to -1, 0, 1, 2\\n im = afwImage.ImageF(bbox)\\n imArr = im.getArray()\\n imArr[:, :] = np.array(((-1, 0, -1, 0),\\n (1, 2, 1, 2),\\n (-1, 0, -1, 0),\\n (1, 2, 1, 2)), dtype=imArr.dtype)\\n\\n sqCoeffs = np.array(((0, 0.11), (-0.15, -12)))\\n detector = self.makeDetector(bbox=bbox, numAmps=numAmps, sqCoeffs=sqCoeffs)\\n ampInfoCat = detector.getAmpInfoCatalog()\\n\\n linSq = LinearizeSquared()\\n linSq(im, detector=detector)\\n\\n # amp 0 has 0 squared coefficient and so makes no correction\\n imArr0 = im.Factory(im, ampInfoCat[0].getBBox()).getArray()\\n linCoeff0 = ampInfoCat[0].getLinearityCoeffs()[0]\\n self.assertEqual(0, linCoeff0)\\n self.assertFloatsAlmostEqual(imArr0.flatten(), (-1, 0, 1, 2))\\n\\n # test all amps\\n for ampInfo in ampInfoCat:\\n imArr = im.Factory(im, ampInfo.getBBox()).getArray()\\n linCoeff = ampInfo.getLinearityCoeffs()[0]\\n expect = np.array((-1 + linCoeff, 0, 1 + linCoeff, 2 + 4*linCoeff), dtype=imArr.dtype)\\n self.assertFloatsAlmostEqual(imArr.flatten(), expect)\",\n \"def has_been_fit(self):\\n return self.predictor.has_been_fit\",\n \"def check_cells_fit(cell_no, min_cell_distance, space_range=[[0,10],[0,10],None]):\\n\\n dim1, dim2, dim3 = space_range\\n full_dim = 1.\\n for dim in [dim1, dim2, dim3]:\\n if dim != None:\\n dim = dim[1]-dim[0]\\n full_dim = full_dim*dim\\n\\n return full_dim / min_cell_distance >= cell_no\",\n \"def test_constructed_is_small(self):\\n self.assertTrue(all(elt<10 for elt in goodwinsheaf.checkradii()))#check all entries have small radii\",\n \"def check_2x2_solved(self):\\n return self._grid[0][0] == 0 and self._grid[0][1] == 1 \\\\\\n and self._grid[1][0] == self._width*1 and self._grid[1][1] == (1 + self._width * 1)\",\n \"def check_location_confidence(self):\\n\\t\\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\\n\\t\\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\\n\\t\\tepsilon_meters = .08\\n\\t\\tpixel_distances = []\\n\\t\\tactual_distances = []\\n\\t\\tnum_observed = 0\\n\\t\\tfor ti in self.targs:\\n\\t\\t\\tif ti.props_are_set:\\n\\t\\t\\t\\tfor tj in self.targs:\\n\\t\\t\\t\\t\\tif tj.props_are_set: \\n\\t\\t\\t\\t\\t\\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\\n\\t\\t\\t\\t\\t\\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\\n\\t\\t\\t\\t\\t\\tif pixel_dist == 0:\\n\\t\\t\\t\\t\\t\\t\\tpixel_dist = 10000 #ignore two of the same points\\n\\t\\t\\t\\t\\t\\t\\tactual_dist = 10000\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(pixel_dist)\\t\\n\\t\\t\\t\\t\\t\\tactual_distances.append(actual_dist)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor _ in self.targs:\\n\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\tmin_ind_pixel = np.argmin(pixel_distances)\\n\\t\\tmin_ind_actual = np.argmin(actual_distances)\\n\\t\\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\\n\\t\\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\\n\\t\\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\\n\\t\\t\\t#measurements are not trustworthy, return nothing\\n\\t\\t\\treturn None\\n\\n\\t\\treturn best_guys\",\n \"def _is_skull_stripped(imgs):\\n\\n def _check_img(img):\\n data = np.abs(nb.load(img).get_fdata(dtype=np.float32))\\n sidevals = (\\n data[0, :, :].sum()\\n + data[-1, :, :].sum()\\n + data[:, 0, :].sum()\\n + data[:, -1, :].sum()\\n + data[:, :, 0].sum()\\n + data[:, :, -1].sum()\\n )\\n return sidevals < 10\\n\\n return all(_check_img(img) for img in imgs)\",\n \"def inner_fit(self):\\n pass\",\n \"def inner_fit(self):\\n pass\",\n \"def mask_and_fit(mask, binary_warped, flag):\\n img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)\\n x, y = extract_pixels(img)\\n fit, foundFlag, confidence_index = check_and_fit(x, y, flag)\\n return fit, foundFlag, confidence_index\",\n \"def _autocheck_dimensions(self):\\n # W dimensions check list\\n assert len(self.W.shape) == 2, f\\\"W shape should be (N, N) but is {self.W.shape}.\\\"\\n assert self.W.shape[0] == self.W.shape[1], f\\\"W shape should be (N, N) but is {self.W.shape}.\\\"\\n\\n # Win dimensions check list\\n assert len(self.Win.shape) == 2, f\\\"Win shape should be (N, input) but is {self.Win.shape}.\\\"\\n err = f\\\"Win shape should be ({self.W.shape[1]}, input) but is {self.Win.shape}.\\\"\\n assert self.Win.shape[0] == self.W.shape[0], err\\n\\n # Wout dimensions check list\\n assert len(self.Wout.shape) == 2, f\\\"Wout shape should be (output, nb_states) but is {self.Wout.shape}.\\\"\\n nb_states = self.Win.shape[1] + self.W.shape[0] + 1 if self.use_raw_inp else self.W.shape[0] + 1\\n err = f\\\"Wout shape should be (output, {nb_states}) but is {self.Wout.shape}.\\\"\\n assert self.Wout.shape[1] == nb_states, err\\n\\n # Wfb dimensions check list\\n if self.Wfb is not None:\\n assert len(self.Wfb.shape) == 2, f\\\"Wfb shape should be (input, output) but is {self.Wfb.shape}.\\\"\\n err = f\\\"Wfb shape should be ({self.Win.shape[0]}, {self.Wout.shape[0]}) but is {self.Wfb.shape}.\\\"\\n assert (self.Win.shape[0],self.Wout.shape[0]) == self.Wfb.shape, err\",\n \"def assert_data_correct(self) -> bool:\\n corr_char = self.assert_data_characters_correct()\\n print(\\\"Character data correct?\\\", corr_char)\\n corr_font = FontImages().assert_data_correct()\\n print(\\\"Font data correct?\\\", corr_font)\\n corr_frag = self.assert_data_fragments_correct()\\n print(\\\"Fragment data correct?\\\", corr_frag)\\n corr_train_aug = self.assert_train_augmented()\\n print(\\\"Train data augmented?\\\", corr_train_aug)\\n truth_agree = corr_char and corr_font and corr_frag\\n return True if truth_agree else False\",\n \"def check_shape(self):\\r\\n if np.array(self.img).shape != (1536, 2048, 3):\\r\\n raise BadShape\",\n \"def test_fit(self, model):\\r\\n fit = model/np.linalg.norm(model, axis=1, keepdims=True)\\r\\n if self.white:\\r\\n sources = self.sources.dot(self.zca_matrix)\\r\\n sources /= np.linalg.norm(sources, axis=1, keepdims=True)\\r\\n else:\\r\\n sources = self.sources\\r\\n allthedots = sources.dot(fit.T)\\r\\n # how close is the closest model source to each true source?\\r\\n bestfits = np.max(np.abs(allthedots), axis=1)\\r\\n return np.median(bestfits)\",\n \"def _check_shape(self, X):\\n return all([X.shape[i] == self.train_shape[i] for i in range(2)])\",\n \"def check_correctness(classifier_out, mode, image_type):\\n labels = image_type.image_data[mode].labels\\n num_correct = 0\\n total = len(classifier_out)\\n for index, label in classifier_out:\\n if labels[index] == label:\\n num_correct += 1\\n print(f'Got {num_correct} out of {total} correct: {(num_correct / total) * 100}%')\",\n \"def _evaluate_during_fit(self, test_loader, epoch):\",\n \"def fit(self):\\n raise NotImplementedError # pragma: no cover\",\n \"def check_fit(data, data_fit, time_points):\\n plt.figure()\\n for jj,(ii,lab) in enumerate(zip([Sub.T, Sub.D, Sub.H, Sub.C],[\\\"Cases\\\", \\\"Deaths\\\", \\\"Hospitalized\\\", \\\"ICU\\\"])):\\n if data[ii] is not None:\\n plt.plot(time_points, data[ii], c=f\\\"C{jj}\\\", label=lab)\\n plt.plot(time_points, data_fit[ii], '--', c=f\\\"C{jj}\\\", label=f\\\"{lab} fit\\\")\\n plt.yscale(\\\"log\\\")\\n plt.legend()\\n # plt.savefig(\\\"Test_fitting\\\", format=\\\"png\\\")\\n plt.show()\",\n \"def test_with_fitted(self):\\n X, y = make_blobs(\\n n_samples=100, n_features=5, centers=3, shuffle=False, random_state=112\\n )\\n model = MiniBatchKMeans().fit(X)\\n labels = model.predict(X)\\n\\n with mock.patch.object(model, \\\"fit\\\") as mockfit:\\n oz = SilhouetteVisualizer(model)\\n oz.fit(X)\\n mockfit.assert_not_called()\\n\\n with mock.patch.object(model, \\\"fit\\\") as mockfit:\\n oz = SilhouetteVisualizer(model, is_fitted=True)\\n oz.fit(X)\\n mockfit.assert_not_called()\\n\\n with mock.patch.object(model, \\\"fit_predict\\\", return_value=labels) as mockfit:\\n oz = SilhouetteVisualizer(model, is_fitted=False)\\n oz.fit(X)\\n mockfit.assert_called_once_with(X, None)\",\n \"def _image_is_large_enough(im):\\n return (im.shape[0] >= MIN_DIM) and (im.shape[1] >= MIN_DIM)\",\n \"def test_point_with_zero_value_is_good():\\n point = np.array([0, 20])\\n image_dimensions = np.array([100, 100])\\n assert point_within_dimensions(point, image_dimensions)\",\n \"def _check_partial_fit_first_call(clf, classes=None):\\n if getattr(clf, \\\"classes_\\\", None) is None and classes is None:\\n raise ValueError(\\\"classes must be passed on the first call to partial_fit.\\\")\\n\\n elif classes is not None:\\n if getattr(clf, \\\"classes_\\\", None) is not None:\\n if not np.array_equal(clf.classes_, unique_labels(classes)):\\n raise ValueError(\\n \\\"`classes=%r` is not the same as on last call \\\"\\n \\\"to partial_fit, was: %r\\\" % (classes, clf.classes_)\\n )\\n\\n else:\\n # This is the first call to partial_fit\\n clf.classes_ = unique_labels(classes)\\n return True\\n\\n # classes is None and clf.classes_ has already previously been set:\\n # nothing to do\\n return False\",\n \"def validate(net, val_data, ctx, eval_metric, size, args):\\n clipper = gcv.nn.bbox.BBoxClipToImage()\\n eval_metric.reset()\\n # set nms threshold and topk constraint\\n net.set_nms(nms_thresh=0.45, nms_topk=400)\\n mx.nd.waitall()\\n net.hybridize()\\n\\n with tqdm(total=size) as pbar:\\n for ib, batch in enumerate(val_data):\\n # if(ib >= 200):\\n # break\\n batch = split_and_load(batch, ctx_list=ctx)\\n det_bboxes = []\\n det_ids = []\\n det_scores = []\\n det_coefs = []\\n det_infos = []\\n\\n for x, im_info in zip(*batch):\\n # get prediction results\\n t1 = time.time()\\n ids, scores, bboxes, coefs = net(x)\\n t2 = time.time()\\n det_bboxes.append(clipper(bboxes, x))\\n det_ids.append(ids)\\n det_scores.append(scores)\\n det_coefs.append(coefs)\\n det_infos.append(im_info)\\n\\n # update metric\\n for det_bbox, det_id, det_score, def_coef, det_info in zip(det_bboxes, det_ids, det_scores, det_coefs, det_infos):\\n for i in range(det_info.shape[0]):\\n # numpy everything\\n det_bbox = det_bbox[i].asnumpy()\\n det_id = det_id[i].asnumpy()\\n det_score = det_score[i].asnumpy()\\n def_coef = def_coef[i].asnumpy()\\n det_info = det_info[i].asnumpy()\\n # filter by conf threshold\\n im_height, im_width = det_info\\n valid = np.where(((det_id >= 0) & (det_score >= 0.001)))[0]\\n det_id = det_id[valid]\\n det_score = det_score[valid]\\n # To bbox of original img size\\n det_bbox = det_bbox[valid]\\n det_bbox[:, 0] *= (im_width / 416.0)\\n det_bbox[:, 2] *= (im_width / 416.0)\\n det_bbox[:, 1] *= (im_height / 416.0)\\n det_bbox[:, 3] *= (im_height / 416.0)\\n\\n def_coef = def_coef[valid]\\n eval_metric.update(det_bbox, det_id, det_score, def_coef, int(im_height), int(im_width))\\n\\n pbar.update(len(ctx))\\n\\n return eval_metric.get()\",\n \"def checkNumNeighbors():\",\n \"def testTicket1123(self):\\n\\n ctrl = afwMath.StatisticsControl()\\n ctrl.setAndMask(~0x0)\\n \\n mimg = afwImage.MaskedImageF(afwGeom.Extent2I(10, 10))\\n mimg.set([self.val, 0x1, self.val])\\n\\n # test the case with no valid pixels ... both mean and stdev should be nan\\n stat = afwMath.makeStatistics(mimg, afwMath.MEAN | afwMath.STDEV, ctrl)\\n mean = stat.getValue(afwMath.MEAN)\\n stdev = stat.getValue(afwMath.STDEV)\\n self.assertNotEqual(mean, mean) # NaN does not equal itself\\n self.assertNotEqual(stdev, stdev) # NaN does not equal itself\\n \\n # test the case with one valid pixel ... mean is ok, but stdev should still be nan\\n mimg.getMask().set(1, 1, 0x0)\\n stat = afwMath.makeStatistics(mimg, afwMath.MEAN | afwMath.STDEV, ctrl)\\n mean = stat.getValue(afwMath.MEAN)\\n stdev = stat.getValue(afwMath.STDEV)\\n self.assertEqual(mean, self.val)\\n self.assertNotEqual(stdev, stdev) # NaN does not equal itself\\n\\n # test the case with two valid pixels ... both mean and stdev are ok\\n mimg.getMask().set(1, 2, 0x0)\\n stat = afwMath.makeStatistics(mimg, afwMath.MEAN | afwMath.STDEV, ctrl)\\n mean = stat.getValue(afwMath.MEAN)\\n stdev = stat.getValue(afwMath.STDEV)\\n self.assertEqual(mean, self.val)\\n self.assertEqual(stdev, 0.0)\",\n \"def evaluate_fit_range(predicted, fit_range):\\n test1 = (predicted[0] >= fit_range[0])\\n test2 = (predicted[0] <= fit_range[1])\\n test3 = (predicted[1] >= fit_range[2])\\n test4 = (predicted[1] <= fit_range[3])\\n return all([test1, test2, test3, test4])\",\n \"def testCheckBlocksFitLength_Pass(self):\\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\\n 64, 4, 16, 'foo'))\\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\\n 60, 4, 16, 'foo'))\\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\\n 49, 4, 16, 'foo'))\\n self.assertIsNone(checker.PayloadChecker._CheckBlocksFitLength(\\n 48, 3, 16, 'foo'))\",\n \"def fits(self, ctx: EvaluationContext) -> bool:\\n return self.rules.is_satisfied(ctx) and self.targets.match(ctx)\",\n \"def test_basic(self):\\r\\n self.validate((3, 2, 8, 8), (4, 2, 5, 5), 'valid', verify_grad=False)\\r\\n self.validate((3, 2, 7, 5), (5, 2, 2, 3), 'valid')\\r\\n self.validate((3, 2, 7, 5), (5, 2, 3, 2), 'valid', verify_grad=False)\\r\\n self.validate((3, 2, 8, 8), (4, 2, 5, 5), 'full', verify_grad=False)\\r\\n self.validate((3, 2, 7, 5), (5, 2, 2, 3), 'full')\\r\\n # test filter same size as input\\r\",\n \"def testSize (self):\\r\\n \\r\\n perpixel = bytes_per_pixel [self.bih_vals [bih_BitCount]]\\r\\n width = self.bih_vals [bih_Width]\\r\\n height = self.bih_vals [bih_Height]\\r\\n expected = self.bih_vals [bih_SizeImage]\\r\\n\\r\\n # Rows always have multiples of 4 bytes\\r\\n \\r\\n padding = 3 - ((perpixel * width + 3) % 4)\\r\\n size = (width * perpixel + padding) * height\\r\\n\\r\\n if not size == expected:\\r\\n print \\\"Calculated size = %d (<> %d)\\\" % (size, expected)\\r\\n print \\\"***** File size error *****\\\"\",\n \"def is_isotropic(self):\\n return self.fibres is None\",\n \"def __check_bit_size(self, value, num_bits):\\n is_fit = False\\n if value <= 2 ** num_bits - 1:\\n is_fit = True\\n return is_fit\",\n \"def check_correctness_statistics(classifier_out, mode, image_type):\\n labels = image_type.image_data[mode].labels\\n num_correct = 0\\n total = len(classifier_out)\\n for index, label in classifier_out:\\n if labels[index] == label:\\n num_correct += 1\\n return (num_correct / total) * 100\",\n \"def check_evaluation_points(x, y):\\n assert x.ndim == y.ndim == 1\\n assert x.shape == y.shape\\n assert x.dtype == y.dtype == np.float64\",\n \"def test_multifit_num_results(self, perform_fit):\\n cost_func = make_cost_function('multifit_set/multifit.txt')\\n problem = cost_func.problem\\n cost_func.jacobian = Scipy(problem)\\n cost_func.jacobian.method = '2-point'\\n controller = DummyController(cost_func=cost_func)\\n options = problem.options\\n options.table_type = ['acc', 'runtime', 'compare', 'local_min']\\n grabbed_output = output_grabber.OutputGrabber(options)\\n controller.final_params = [[0.1, 0.1], [0.1, 0.1]]\\n controller.parameter_set = 0\\n perform_fit.return_value = ([0.1, 0.2],\\n [0.1, 0.01],\\n [10e-3, 10e-4])\\n results = loop_over_hessians(controller=controller,\\n options=options,\\n grabbed_output=grabbed_output,\\n checkpointer=self.cp)\\n self.assertTrue(len(results) == 2)\",\n \"def analyse_goodness_of_fit(x_data, y_data, poly_fit, fit_name):\\n\\n # useful display and computational data\\n y_fitted = poly_fit(x_data)\\n min_x_display = min(x_data) - abs(max(x_data) - min(x_data)) * 0.1\\n max_x_display = max(x_data) + abs(max(x_data) - min(x_data)) * 0.1\\n x_fitted_display = np.linspace(min_x_display, max_x_display)\\n y_fitted_display = poly_fit(x_fitted_display)\\n\\n # goodness of fit indicators\\n dof = len(y_data) - (poly_fit.order+1) # degrees of freedom\\n SSE = np.sum((y_data - y_fitted) ** 2) # Sum of Squared Errors\\n SST = np.sum((y_data - np.mean(y_data)) ** 2) # Total Sum of Squares (about the mean)\\n R2 = 1.0 - SSE/SST # R squared\\n RMSE = math.sqrt( SSE / dof ) # Root Mean Squared Error\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 2, 1)\\n\\n # plot of the fitted polynomial itself\\n ax.plot(x_fitted_display, y_fitted_display, color='C6')\\n ax.scatter(x_data, y_data, color='C7')\\n ax.set(title=\\\"Fitted polynomial (deg{}) for \\\\'{}\\\\'\\\".format(poly_fit.order, fit_name), xlabel=\\\"x\\\", ylabel=\\\"y\\\")\\n\\n # histogram of residuals\\n ax2 = fig.add_subplot(1, 2, 2)\\n sns.distplot(y_data - y_fitted, kde=True, ax=ax2)\\n ax2.set(title=\\\"Histogram of residuals\\\", xlabel=\\\"Residual value $y_k - \\\\\\\\widehat{y_k}$\\\", ylabel=\\\"Count\\\")\\n\\n # display of fit indicators\\n fig.text(0.02, 0.02, '$SSE = {0:.6f}$'.format(SSE), fontsize='10')\\n fig.text(0.27, 0.02, '$R^2 = {0:.6f}$'.format(R2), fontsize='10')\\n fig.text(0.52, 0.02, '$RMSE = {0:.6f}$'.format(RMSE), fontsize='10')\\n\\n fig.tight_layout()\\n fig.subplots_adjust(bottom=0.2)\\n\\n figurefiles.save_in_perfs_fits_folder(fig, \\\"Polyfit_{}_order_{}.pdf\\\".format(fit_name, poly_fit.order))\",\n \"def _c_fits_consistent(fit1, fit2, quantile=.125):\\n # [.125, .25, .4, .5, .6, .75, .875]\\n try:\\n log.debug('Checking fits against each others {} quantiles' \\\\\\n .format(quantile))\\n\\n qmin = list(fit1.quantiles).index( quantile)\\n qmax = list(fit1.quantiles).index(1-quantile)\\n log.debug('{} < {} < {} ?'.format(\\n fit2.tauquantiles[qmin], fit1.tau, fit2.tauquantiles[qmax]))\\n if fit1.tau > fit2.tauquantiles[qmax] \\\\\\n or fit1.tau < fit2.tauquantiles[qmin]:\\n return False\\n\\n qmin = list(fit2.quantiles).index( quantile)\\n qmax = list(fit2.quantiles).index(1-quantile)\\n log.debug('{} < {} < {} ?'.format(\\n fit1.tauquantiles[qmin], fit2.tau, fit1.tauquantiles[qmax]))\\n if fit2.tau > fit1.tauquantiles[qmax] \\\\\\n or fit2.tau < fit1.tauquantiles[qmin]:\\n return False\\n\\n return True\\n except Exception as e:\\n log.debug('Quantile not found in fit', exc_info=True)\\n\\n return False\",\n \"def check(self, test_set):\\n for id in test_set.keys():\\n image = test_set[id]\\n answers = {}\\n for mood, perceptron in self._perceptrons.items():\\n answers[perceptron.check(image)] = mood\\n final_answer = answers[max(answers.keys())]\\n print('Image{} {}'.format(id, final_answer.value))\",\n \"def test(self, data_set):\\r\\n\\r\\n correct = 0.0\\r\\n total = 0.0\\r\\n\\r\\n for input, target in data_set:\\r\\n #actual output from neural net\\r\\n output = self.predict(input)\\r\\n total += 1.0 #number of total output vectors\\r\\n\\r\\n if allclose(output, target, self.converge) == True:\\r\\n correct += 1.0\\r\\n\\r\\n return correct/total\",\n \"def testTicket1125(self):\\n mimg = afwImage.MaskedImageF(afwGeom.Extent2I(10, 10))\\n mimg.set([self.val, 0x1, self.val])\\n\\n ctrl = afwMath.StatisticsControl()\\n ctrl.setAndMask(~0x0)\\n \\n # test the case with no valid pixels ... try MEANCLIP and STDEVCLIP\\n stat = afwMath.makeStatistics(mimg, afwMath.MEANCLIP | afwMath.STDEVCLIP, ctrl)\\n mean = stat.getValue(afwMath.MEANCLIP)\\n stdev = stat.getValue(afwMath.STDEVCLIP)\\n self.assertNotEqual(mean, mean) # NaN does not equal itself\\n self.assertNotEqual(stdev, stdev) # NaN does not equal itself\",\n \"def test_final_result():\\n img = cv2.imread(os.path.join(TESTS_ASSETS_VISION_DIR, \\\"mussels_sample.PNG\\\"))\\n _orig, _circles_removed, _blurred_and_smoothed, _convex_hull, _mussels_found, _mussels_count = count_mussels(img)\\n final_result = _mussels_count\\n assert final_result == 8\",\n \"def check_for_fit(cls, method):\\n\\n @wraps(method)\\n def _check_for_fit(self, X=None, y=None):\\n klass = type(self).__name__\\n if not self._is_fitted and self.needs_fitting:\\n raise ComponentNotYetFittedError(\\n f\\\"This {klass} is not fitted yet. You must fit {klass} before calling {method.__name__}.\\\"\\n )\\n else:\\n return method(self, X, y)\\n\\n return _check_for_fit\",\n \"def test_whitley(self):\\n fun = get_problem('whitley', self.dimension)\\n self.assertEqual(fun(self.array2), 0.0)\",\n \"def _check_data_valid(self):\\n\\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\\n if not is_valid:\\n raise FITSException(f\\\"No data in {self.survey}\\\")\",\n \"def get_percentage_false_class(arr_of_results):\\n\\n count_success = np.zeros_like(arr_of_results[:,0], dtype=float)\\n count_correct_prediction = 0\\n\\n for i in range(len(arr_of_results[0])):\\n use = True\\n for result in arr_of_results[:,i]:\\n if result[\\\"image_target\\\"] != result[\\\"prediction_image\\\"] or result[\\\"std_noise\\\"] == 0:\\n use = False\\n if use:\\n count_correct_prediction += 1\\n i2 = 0\\n for result in arr_of_results[:,i]:\\n if result[\\\"success\\\"]:\\n count_success[i2] += 1\\n i2 += 1\\n\\n\\n errors = proportion_confint(count_success, count_correct_prediction)\\n count_success = count_success/count_correct_prediction\\n errors = np.array(errors)\\n\\n errors[0] = np.abs(count_success - errors[0])\\n errors[1] = np.abs(count_success - errors[1])\\n\\n return count_success, errors\",\n \"def fit(self):\\n raise NotImplementedError\",\n \"def test_point_within_dimensions_true():\\n point = np.array([10, 20])\\n image_dimensions = np.array([100, 100])\\n assert point_within_dimensions(point, image_dimensions)\",\n \"def test_intra_power_law_fit(self):\\n\\n\\t\\tprint(type(self.fc_layers[0:2]), self.fc_layers[0:2])\\n\\t\\tdetails= self.watcher.analyze(layers=self.fc_layers[0:2], intra=True, randomize=False, vectors=False, pl_package=POWERLAW_PACKAGE, xmax=XMAX_FORCE)\\n\\t\\tactual_alpha = details.alpha[0]\\n\\t\\t#actual_best_fit = details.best_fit[0]\\n\\t\\t#print(actual_alpha,actual_best_fit)\\n\\n\\t\\texpected_alpha = 2.654 # not very accurate because of the sparisify transform\\n\\t\\t#expected_best_fit = LOG_NORMAL\\n\\t\\tself.assertAlmostEqual(actual_alpha,expected_alpha, places=1)\\n\\t\\t#self.assertEqual(actual_best_fit, expected_best_fit)\",\n \"def _check_dimensions(self, workspace_to_check):\\n for i in range(self._raw_ws.getNumDims()):\\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\\n return False\\n return True\",\n \"def validate(self, epn, num_samples_to_test = 1000):\\n batch_size = epn.batch_size\\n dataloader = torch.utils.data.DataLoader(dataset = self, batch_size = batch_size, shuffle=True)\\n num_samples_evaluated = 0\\n num_correct = 0\\n for batch_idx, (x_data, y_target) in enumerate(dataloader):\\n epn.randomize_initial_state(batch_size = batch_size)\\n epn.set_x_state(x_data)\\n s = epn.evolve_to_equilbrium(y_target = None, beta = 0)\\n compared = s[:,epn.iy].argmax(dim = 1) == y_target[:].argmax(dim = 1)\\n num_samples_evaluated += batch_size\\n num_correct += torch.sum(compared)\\n if num_samples_evaluated > num_samples_to_test:\\n break\\n error = (1-num_correct.item()/num_samples_evaluated)\\n return error\",\n \"def test_number_of_paint_cans_calculated_correctly_1():\\n\\n info = paintCanInfo.PaintCanInfo(0)\\n info.efficiency = 5\\n\\n assert paintCanCalculator.how_many_needed(5, 5, info) == 5, \\\\\\n 'Result for 5x5 wall and 5m^2 paint can efficiency should should be 5!'\",\n \"def plotGaussian3Dbatchfit(param_all, img_crop_all, ind_plot):\\n\\n fit_result = param_all[ind_plot, 6:]\\n img_crop = img_crop_all[ind_plot, :, :, :]\\n\\n fit_img_fun = symmetricGaussian3D(*fit_result)\\n fit_img = fit_img_fun(*np.indices(img_crop.shape))\\n\\n # Create figure and axes\\n import matplotlib.pyplot as plt\\n\\n fig_detect, (ax1, ax2) = plt.subplots(1, 2)\\n\\n plt.subplot(231)\\n plt.imshow(np.amax(img_crop, axis=0), cmap='magma')\\n plt.plot(fit_result[4], fit_result[3], marker='o', linestyle='--', color='g', label='Square')\\n plt.axis('off')\\n plt.title('Raw image-XY')\\n plt.colorbar()\\n\\n plt.subplot(232)\\n plt.imshow(np.amax(img_crop, axis=1), cmap='magma')\\n plt.plot(fit_result[4], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\\n plt.axis('off')\\n plt.title('Raw image-XZ')\\n plt.colorbar()\\n\\n plt.subplot(233)\\n plt.imshow(np.amax(img_crop, axis=2), cmap='magma')\\n plt.plot(fit_result[3], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\\n plt.axis('off')\\n plt.title('Raw image-YZ')\\n plt.colorbar()\\n\\n ax2 = plt.subplot(234)\\n plt.imshow(np.amax(fit_img, axis=0), cmap='magma')\\n plt.plot(fit_result[4], fit_result[3], marker='o', linestyle='--', color='g', label='Square')\\n plt.axis('off')\\n plt.title('Fit image-XY')\\n plt.colorbar()\\n\\n ax2 = plt.subplot(235)\\n plt.imshow(np.amax(fit_img, axis=1), cmap='magma')\\n plt.plot(fit_result[4], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\\n plt.axis('off')\\n plt.title('Fit image-XZ')\\n plt.colorbar()\\n\\n ax2 = plt.subplot(236)\\n plt.imshow(np.amax(fit_img, axis=2), cmap='magma')\\n plt.plot(fit_result[3], fit_result[2], marker='o', linestyle='--', color='g', label='Square')\\n plt.axis('off')\\n plt.title('Fit image-YZ')\\n plt.colorbar()\",\n \"def victory_checker() -> bool:\\r\\n conflict_check()\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n if conflict_space[x, y] != 0:\\r\\n return False\\r\\n if separation_crawler(False):\\r\\n return False\\r\\n return True\",\n \"def _check_success(self):\\n cube_height = self.sim.data.body_xpos[self.cube_body_id][2]\\n table_height = self.table_full_size[2]\\n\\n # cube is higher than the table top above a margin\\n return cube_height > table_height + 0.10\",\n \"def analyse(self):\\n self.__try_fitting()\\n self.second.rotate()\\n self.__try_fitting()\",\n \"def test_is_filled(self):\\n n = 10\\n matrix = g.np.random.uniform(size=(n + 1,) * 3) > 0.5\\n not_matrix = g.np.logical_not(matrix)\\n pitch = 1. / n\\n origin = g.np.random.uniform(size=(3,))\\n vox = g.trimesh.voxel.VoxelGrid(matrix)\\n vox = vox.apply_scale(pitch).apply_translation(origin)\\n not_vox = g.trimesh.voxel.VoxelGrid(not_matrix)\\n not_vox = not_vox.apply_scale(pitch).apply_translation(origin)\\n for a, b in ((vox, not_vox), (not_vox, vox)):\\n points = a.points\\n # slight jitter - shouldn't change indices\\n points += (\\n g.np.random.uniform(size=points.shape) - 1) * 0.4 * pitch\\n g.np.random.shuffle(points)\\n\\n # all points are filled, and no empty points are filled\\n assert g.np.all(a.is_filled(points))\\n assert not g.np.any(b.is_filled(points))\\n\\n # test different number of dimensions\\n points = g.np.stack([points, points[-1::-1]], axis=1)\\n assert g.np.all(a.is_filled(points))\\n assert not g.np.any(b.is_filled(points))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72636896","0.6932754","0.66202956","0.66143525","0.65346766","0.63944054","0.6253365","0.6242172","0.62324864","0.62324864","0.6188465","0.6146149","0.6145773","0.61280084","0.6103189","0.6067273","0.60213757","0.6007816","0.5982442","0.59745777","0.59690756","0.59484226","0.59258944","0.5919239","0.5888658","0.58831644","0.58735824","0.5853248","0.5841843","0.5821388","0.58172166","0.5789411","0.5777684","0.5763237","0.57616645","0.57558286","0.5749045","0.57419753","0.5725584","0.57131565","0.57019407","0.5691456","0.5686693","0.56754565","0.5669854","0.5668999","0.5665738","0.5653504","0.5652207","0.5637154","0.56334746","0.56334746","0.5626449","0.5615163","0.56045973","0.56002784","0.55954","0.5592526","0.5587731","0.55862087","0.55808514","0.55800086","0.55745053","0.55688834","0.55618614","0.5554303","0.55540806","0.55250204","0.551133","0.5509129","0.54983634","0.548324","0.5480429","0.54793876","0.5470892","0.54672664","0.5462249","0.54557323","0.5445417","0.5444739","0.5433781","0.54314506","0.5417105","0.54110616","0.54014874","0.5400629","0.53920364","0.53905386","0.5381406","0.5378611","0.5374087","0.53715795","0.5366178","0.53642714","0.5364005","0.53635836","0.53600484","0.5358001","0.5355367","0.53419745"],"string":"[\n \"0.72636896\",\n \"0.6932754\",\n \"0.66202956\",\n \"0.66143525\",\n \"0.65346766\",\n \"0.63944054\",\n \"0.6253365\",\n \"0.6242172\",\n \"0.62324864\",\n \"0.62324864\",\n \"0.6188465\",\n \"0.6146149\",\n \"0.6145773\",\n \"0.61280084\",\n \"0.6103189\",\n \"0.6067273\",\n \"0.60213757\",\n \"0.6007816\",\n \"0.5982442\",\n \"0.59745777\",\n \"0.59690756\",\n \"0.59484226\",\n \"0.59258944\",\n \"0.5919239\",\n \"0.5888658\",\n \"0.58831644\",\n \"0.58735824\",\n \"0.5853248\",\n \"0.5841843\",\n \"0.5821388\",\n \"0.58172166\",\n \"0.5789411\",\n \"0.5777684\",\n \"0.5763237\",\n \"0.57616645\",\n \"0.57558286\",\n \"0.5749045\",\n \"0.57419753\",\n \"0.5725584\",\n \"0.57131565\",\n \"0.57019407\",\n \"0.5691456\",\n \"0.5686693\",\n \"0.56754565\",\n \"0.5669854\",\n \"0.5668999\",\n \"0.5665738\",\n \"0.5653504\",\n \"0.5652207\",\n \"0.5637154\",\n \"0.56334746\",\n \"0.56334746\",\n \"0.5626449\",\n \"0.5615163\",\n \"0.56045973\",\n \"0.56002784\",\n \"0.55954\",\n \"0.5592526\",\n \"0.5587731\",\n \"0.55862087\",\n \"0.55808514\",\n \"0.55800086\",\n \"0.55745053\",\n \"0.55688834\",\n \"0.55618614\",\n \"0.5554303\",\n \"0.55540806\",\n \"0.55250204\",\n \"0.551133\",\n \"0.5509129\",\n \"0.54983634\",\n \"0.548324\",\n \"0.5480429\",\n \"0.54793876\",\n \"0.5470892\",\n \"0.54672664\",\n \"0.5462249\",\n \"0.54557323\",\n \"0.5445417\",\n \"0.5444739\",\n \"0.5433781\",\n \"0.54314506\",\n \"0.5417105\",\n \"0.54110616\",\n \"0.54014874\",\n \"0.5400629\",\n \"0.53920364\",\n \"0.53905386\",\n \"0.5381406\",\n \"0.5378611\",\n \"0.5374087\",\n \"0.53715795\",\n \"0.5366178\",\n \"0.53642714\",\n \"0.5364005\",\n \"0.53635836\",\n \"0.53600484\",\n \"0.5358001\",\n \"0.5355367\",\n \"0.53419745\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5679916"},"document_rank":{"kind":"string","value":"43"}}},{"rowIdx":14795,"cells":{"query":{"kind":"string","value":"Mask the Images and then return the equation of the lane lines"},"document":{"kind":"string","value":"def mask_and_fit(mask, binary_warped, flag):\n img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)\n x, y = extract_pixels(img)\n fit, foundFlag, confidence_index = check_and_fit(x, y, flag)\n return fit, foundFlag, confidence_index"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def calcmask(self, *args, **kwargs):\n return _image.image_calcmask(self, *args, **kwargs)","def set_lanes(left_lines, right_lines, image):\n \n Y_LANE_EXTRAP = 35 # percent up from bottom of image to extrapolate lane lines\n \n image_wk = np.copy(image) # working copy\n image_lines = np.copy(image_wk)*0 # create a blank to draw lines on\n im_y = image_wk.shape[0]\n \n y1_lane = im_y\n y2_lane = np.int32(im_y - (Y_LANE_EXTRAP/100*im_y))\n \n # Process left lane\n if left_lines:\n z_left = my_linear_polyfit(left_lines)\n x1_lane = np.int32( (y1_lane - z_left[1]) / z_left[0] ) # x = (y-b)/m\n x2_lane = np.int32( (y2_lane - z_left[1]) / z_left[0] )\n \n # Draw left lane on blank image\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\n \n # Process right lane\n if right_lines:\n z_right = my_linear_polyfit(right_lines)\n x1_lane = np.int32( (y1_lane - z_right[1]) / z_right[0] ) # x = (y-b)/m\n x2_lane = np.int32( (y2_lane - z_right[1]) / z_right[0] )\n \n # Draw right lane on blank image\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\n \n # Overlay detected left/right lanes on road image\n image_wk = weighted_img(image_lines, image_wk)\n \n # Output road image with overlaid left/right lanes\n return image_wk","def mask(self):","def get_mask(self, img):\n raise NotImplementedError()","def lane(self, mask, win_color = None):\n\n # the nonzero point\n solid = np.nonzero(mask)\n sx, sy = solid[1], solid[0]\n\n # make a image to draw on\n out_img = np.dstack([np.zeros_like(mask)]*3)*255\n if self.fit is None:\n # get the intial poly line for window sliding\n\n # get the midpoint for both line, expecting it shows up in the lower half\n self.h, self.w = mask.shape\n self.midpoint = self.w//2\n self.win_height = self.h//self.nb_win\n\n curv_head = self.h//self.frac\n histogram = np.sum(mask[:curv_head, :], axis = 0)\n mid_l = np.argmax(histogram[:self.midpoint])\n mid_r = np.argmax(histogram[self.midpoint:]) + self.midpoint\n\n # the indice for solid pixel in left and right\n l_lane_idc = []\n r_lane_idc = []\n\n # slide the windows down up\n btm = self.h\n for n in range(self.nb_win):\n # right window\n ul_l = (mid_l - self.half, btm - self.win_height)\n lr_l = (mid_l + self.half, btm)\n\n # left window\n ul_r = (mid_r - self.half, btm - self.win_height)\n lr_r = (mid_r + self.half, btm)\n\n\n # draw the retangle on the image\n if win_color:\n cv2.rectangle(out_img, lr_l, ul_l, win_color, 2)\n cv2.rectangle(out_img, lr_r, ul_r, win_color, 2)\n\n\n # the indice within window\n within_l = ((sx>=ul_l[0]) & \\\n (sx<=lr_l[0]) & \\\n (sy>=ul_l[1]) & \\\n (sy<=lr_l[1])).nonzero()[0]\n\n within_r = ((sx>=ul_r[0]) & \\\n (sx<=lr_r[0]) & \\\n (sy>=ul_r[1]) & \\\n (sy<=lr_r[1])).nonzero()[0]\n\n # append to the lane\n l_lane_idc.append(within_l)\n r_lane_idc.append(within_r)\n\n if len(within_r) > self.minpix:\n mid_r = np.int(np.mean(sx[within_r]))\n if len(within_l) > self.minpix:\n mid_l = np.int(np.mean(sx[within_l]))\n btm -= self.win_height\n\n # concatenate the windows\n l_lane_idc = np.concatenate(l_lane_idc)\n r_lane_idc = np.concatenate(r_lane_idc)\n try:\n self.fit = [np.polyfit(sy[l_lane_idc], sx[l_lane_idc], 2),\n np.polyfit(sy[r_lane_idc], sx[r_lane_idc], 2)]\n except:\n return out_img\n\n\n else:\n # if we've fitted the lane, use that as guide\n l_fit, r_fit = self.fit\n l_lane_idc = ((sx >= np.polyval(l_fit, sy) - self.half) &\n (sx <= np.polyval(l_fit, sy) + self.half)).nonzero()[0]\n r_lane_idc = ((sx >= np.polyval(r_fit, sy) - self.half) &\n (sx <= np.polyval(r_fit, sy) + self.half)).nonzero()[0]\n\n\n curv_head = self.h//self.frac\n l_curv_count = np.sum((sy >= curv_head) & (sx <= self.midpoint))\n r_curv_count = np.sum((sy >= curv_head) & (sx >= self.midpoint))\n\n if l_curv_count >= self.curv_count:\n try: self.fit[0] = np.polyfit(sy[l_lane_idc], sx[l_lane_idc], 2)\n except: pass\n if r_curv_count >= self.curv_count:\n try: self.fit[1] = np.polyfit(sy[r_lane_idc], sx[r_lane_idc], 2)\n except: pass\n\n # draw the lane area\n l_fit, r_fit = self.fit\n y_cord = np.linspace(0, self.h - 1, self.h)\n lane_l = np.polyval(l_fit, y_cord)\n lane_r = np.polyval(r_fit, y_cord)\n\n\n if not win_color:\n pts_l = np.array([np.vstack([lane_l, y_cord]).T])\n pts_r = np.array([np.flipud(np.vstack([lane_r, y_cord]).T)])\n\n pts = np.hstack((pts_l, pts_r))\n cv2.fillPoly(out_img, np.int_(pts), [0, 100, 0])\n\n # draw red on left\n out_img[sy[l_lane_idc], sx[l_lane_idc]] = RED\n # draw blue on right\n out_img[sy[r_lane_idc], sx[r_lane_idc]] = BLUE\n\n\n # put text showing meters away center and radius\n l_btm = np.polyval(l_fit, self.h)\n r_btm = np.polyval(r_fit, self.h)\n mpp = self.lane_width/(r_btm - l_btm) # meters per pixel\n\n mid_lane = int((r_btm + l_btm)/2)\n dev = (self.midpoint - mid_lane)\n radius = np.mean(self.curvature(mpp))\n\n side = ''\n side = 'L' if dev < 0 else 'R'\n dev_text = (\"%.2fm %s\"%(np.abs(mpp*dev), side))\n radius_text = (\"RADIUS %.2fm\"%(radius)) if radius < 2000 else 'STRAIGHT'\n\n (dev_w, dev_h), _ = cv2.getTextSize(dev_text,\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\n fontScale = 1, thickness = 2)\n\n (radius_w, radius_h), _ = cv2.getTextSize(radius_text,\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\n fontScale = 1, thickness = 3)\n\n\n dev_org = (int(mid_lane + 2*dev - dev_w//2), self.h - 30)\n radius_org = (int(mid_lane - radius_w//2), self.h - 80)\n\n\n\n cv2.line(out_img, (mid_lane, self.h - 20),\n (mid_lane, self.h - 40 - dev_h),\n color = [255,255,255], thickness = 3)\n\n cv2.putText(out_img, radius_text,\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\n fontScale = 1, thickness = 3,\n org = radius_org, color = [0, 0, 0])\n\n cv2.putText(out_img, dev_text,\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\n fontScale = 1, thickness = 2,\n org = dev_org, color = [0, 0, 0])\n\n return out_img","def mask(self):\n mask = np.zeros((self.height, self.width))\n pts = [\n np.array(anno).reshape(-1, 2).round().astype(int)\n for anno in self.segmentation\n ]\n mask = cv2.fillPoly(mask, pts, 1)\n return mask","def mask_image(image):\n pass","def _generate_mask(self):\r\n mask = np.zeros((self.width, self.height), np.uint8)\r\n size = int((self.width + self.height) * 0.01)\r\n if self.width < 32 or self.height < 32:\r\n raise Exception(\"Width and Height of mask must be at least 64!\")\r\n for _ in range(randint(1,int(0.5*self.width))):\r\n x1 = randint(0, self.width-1)\r\n thickness = 1\r\n cv2.line(mask, (0, x1),(self.height-1, x1), 1, thickness)\r\n return 1 - mask","def createMasks(inputFolderName=\"Masks_From_VolumeTracing\", outputFolderName=\"Masks_From_VolumeTracing_Lines_From_VolumeTracing\"):\n\n root, df = loader.dataModules()\n\n PATH_TO_RAW_FRAMES_PARENT_DIR = os.path.join(root, inputFolderName) # frames path\n PATH_TO_OUTPUT_DIR = os.path.join(root, outputFolderName) # frames path\n \n os.makedirs(PATH_TO_OUTPUT_DIR, exist_ok=True) # creates ground truth mask parent directory\n\n print(\"Drawing lines on each mask from VolumeTracings\")\n for i in tqdm(range(len(df))): # iterates through each row of data frame\n videoName = df.iloc[i, 0] # name of video\n frameNumber = df.iloc[i, 1] # timing for clip\n\n frameName = videoName + \".avi_\" + str(frameNumber) + \".png\" # concatenate video name with frame number as file name\n PATH_TO_RAW_FRAME = os.path.join(PATH_TO_RAW_FRAMES_PARENT_DIR, frameName)\n PATH_TO_OUTPUT_RAW_FRAME = os.path.join(PATH_TO_OUTPUT_DIR, frameName)\n\n image = cv2.imread(\"/Users/ishan/Downloads/Untraced.png\") # read in the image from the specified frame path\n if os.path.exists(PATH_TO_RAW_FRAME) and videoName == \"0X16A6CEDE7F61E211\" and int(frameNumber) == 131: # checks if frame exists\n x1 = list(literal_eval(df.iloc[i, 2])) # x1 coords\n y1 = list(literal_eval(df.iloc[i, 3])) # y1 coords\n x2 = list(literal_eval(df.iloc[i, 4])) # x2 coords\n y2 = list(literal_eval(df.iloc[i, 5])) # y2 coords\n\n for coord in range(len(x1)): # iterate through each coordinate\n if coord is 0: # gets the perpendicular/long line\n longLine1stCoords = (int(x1[coord]), int(y1[coord]))\n longLine2ndCoords = (int(x2[coord]), int(y2[coord]))\n else: # draws the parallel lines\n cv2.line(image, (int(x1[coord]), int(y1[coord])), (int(x2[coord]), int(y2[coord])), (255, 255, 255), 1)\n \n cv2.line(image, longLine1stCoords, longLine2ndCoords, (255, 255, 255), 1) # Drawing the perpendicular/long line in different color\n\n cv2.imwrite(\"/Users/ishan/Downloads/Traced.png\", image)","def my_lane_detection_pipeline(image, debug_images=False):\n\n # Step 1 - Filter and enhance image by lane color\n image_s1 = filter_lane_color(image)\n \n # Step 2 - Canny edge detection with Gaussian blur and region mask\n image_s2 = detect_lane_edges(image_s1)\n \n # Step 3 - Raw line detection by Hough transform and classify left/right by angle\n (image_s3, left_lines, right_lines) = detect_lane_lines(image_s2, image)\n \n # Step 4 - Set left/right lanes by weighted linear polyfit of raw lines\n image_s4 = set_lanes(left_lines, right_lines, image_s3)\n \n # Save images of each step for debugging and documentation\n if debug_images:\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s0.jpg'), image)\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s1.jpg'), image_s1, cmap = 'gray')\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s2.jpg'), image_s2)\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s3.jpg'), image_s3)\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s4.jpg'), image_s4)\n \n # Output image with overlaid raw lane lines and detected left/right lanes\n return image_s4","def apply_lane_mask(fastalines, lane_mask, verbose=False):\r\n return apply_lane_mask_and_gap_filter(fastalines, lane_mask,\r\n allowed_gap_frac=1, verbose=False)","def pipeline(self,img,debug=0):\n\t\timg = self.cam.undist(img)\n\t\t#get warped binary image\n\t\tbinary_warped = self.cam.warp(Image(img).binary_th())\n\t\tbw_shape = binary_warped.shape\n\t\t\n\t\tif (self.leftLine.detected == True and self.rightLine.detected == True):\n\t\t\tself.quick_search(binary_warped,debug)\n\t\telse:\n\t\t\tself.blind_search(binary_warped,debug)\n\t\n\t\tif (self.leftLine.fit!=None and self.rightLine.fit!=None):\n\t\t\tpolygon = self.fill_lane(bw_shape)\n\t\t\tunwarped_polygon = self.cam.unwarp(polygon)\n\t\t\t# calculate position of lane's center \n\t\t\ttemp = np.nonzero(unwarped_polygon[-1,:,1])[0]\n\t\t\tleft, right = temp[0], temp[-1]\n\t\t\tself.center = (int(bw_shape[1]/2) - (int((right-left)/2)+int(left)))*7.4/1280\n\t\t\timg_lines = weighted_img(unwarped_polygon,img, α=1, β=0.5, λ=0.)\n\t\t\t# write text on image\n\t\t\tfont = cv2.FONT_HERSHEY_SIMPLEX\n\t\t\ttext1 = 'Radius of Curvature: {:.0f}m'.format(np.mean((self.leftLine.radius, self.rightLine.radius)))\n\t\t\ttext2 = 'Distance is {:.2f}m {} of center'.format(abs(self.center), 'left' if self.center<0 else 'right')\n\n\t\t\tcv2.putText(img_lines, text1, (100,100), font, 1,(255,255,255),2)\n\t\t\tcv2.putText(img_lines, text2 ,(100,140), font, 1,(255,255,255),2)\n\t\t\t\n\t\t\tif (debug==1):\n\t\t\t\tshow_2gr(polygon, unwarped_polygon)\n\t\t\t\tshow_2gr(binary_warped, unwarped_polygon)\n\n\t\t\treturn img_lines\n\n\t\telse:\n\t\t\t# no lines detected and not fit available: return original image\n\t\t\t# without lines\n\t\t\treturn img","def apply_lane_mask(fastalines, lane_mask, verbose=False):\n return apply_lane_mask_and_gap_filter(fastalines, lane_mask,\\\n allowed_gap_frac=1, verbose=False)","def fix_generate_mask(self):\r\n mask = np.zeros((self.width, self.height), np.uint8)\r\n size = int((self.width + self.height) * 0.01)\r\n if self.width < 32 or self.height < 32:\r\n raise Exception(\"Width and Height of mask must be at least 64!\")\r\n i = 0\r\n for _ in range(1, int(0.3 * self.width)):\r\n index_xline = random.sample(range(0, self.width), int(0.5 * self.width))\r\n x1 = index_xline[i]\r\n i += 1\r\n thickness = 1\r\n cv2.line(mask, (0, x1), (self.height - 1, x1), 1, thickness)\r\n\r\n return 1 - mask","def mark_lane_lines(undist, warped, ploty, left_fitx, right_fitx, Minv):\n # Create an image to draw the lines on\n warp_zero = np.zeros_like(warped).astype(np.uint8)\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\n\n # Recast the x and y points into usable format for cv2.fillPoly()\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\n pts = np.hstack((pts_left, pts_right))\n\n # Draw the lane onto the warped blank image\n cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))\n\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\n newwarp = cv2.warpPerspective(color_warp, Minv, (warped.shape[1], warped.shape[0])) \n # Combine the result with the original image\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\n return result","def Mask(self) -> int:","def draw_lines(img, lines, color=[0, 0, 255], thickness=10):\n \n yFinal = 540 # tweak these values as per the frame size\n yIni = 350\n xPlus = []\n yPlus = []\n xMinus = []\n yMinus= []\n slope_range = 0.2\n\n if lines is not None:\n for line in lines:\n if line is not None:\n for x1,y1,x2,y2 in line:\n # check slope \n slope = (y2-y1)/(x2-x1)\n\t\t \n \t\t # Collect all points with + ve slope (right lane)\n if (slope > slope_range):\n xPlus.append(x1)\n xPlus.append(x2)\n yPlus.append(y1)\n yPlus.append(y2)\n\n # Collect all points with - ve slope (left lane)\n elif ((slope) < (-slope_range)):\n xMinus.append(x1)\n xMinus.append(x2)\n yMinus.append(y1)\n yMinus.append(y2)\n # If out of range, lists defined in beginning of this function will be empty \n else:\n continue\n \n # draw right lane\n x1,y1,x2,y2 = fit_line(xPlus, yPlus, yIni, yFinal)\n cv2.line(img,(x1,y1),(x2,y2),color, thickness) \n\n # draw left lane\n x1,y1,x2,y2 = fit_line(xMinus, yMinus, yIni, yFinal)\n cv2.line(img,(x1,y1),(x2,y2),color,thickness)","def detect_lane_lines(image_edges, image_orig):\n \n HOUGH_RHO = 1 # distance resolution in pixels of the Hough grid\n HOUGH_THETA = np.pi/180 # angular resolution in radians of the Hough grid\n HOUGH_THRESH = 15 # minimum number of votes (intersections in Hough grid cell) <15,20>\n HOUGH_MIN_LEN = 40 # minimum number of pixels making up a line <40,100>\n HOUGH_MAX_GAP = 100 # maximum gap in pixels between connectable line segments <100,250>\n \n LINE_MIN_ANGLE = 20 # degrees\n \n image_wk = np.copy(image_orig) # working copy\n \n # Run Hough transform on edge-detected image\n raw_lines = cv2.HoughLinesP(image_edges, HOUGH_RHO, HOUGH_THETA, HOUGH_THRESH, np.array([]),\n HOUGH_MIN_LEN, HOUGH_MAX_GAP)\n \n # Group lines by left/right angle and side of center line\n left_lines = []\n right_lines = []\n x_center = np.int32((image_wk.shape[1]/2))\n for line in raw_lines:\n for x1, y1, x2, y2 in line:\n theta = np.arctan((y2-y1)/(x2-x1)) /np.pi*180\n \n if (theta < -LINE_MIN_ANGLE) and (x1 < x_center) and (x2 < x_center):\n left_lines.append(line)\n \n elif (theta > LINE_MIN_ANGLE) and (x1 > x_center) and (x2 > x_center):\n right_lines.append(line)\n \n # Draw raw left/right lines on road image\n draw_lines(image_wk, left_lines, (255,0,255), 2)\n draw_lines(image_wk, right_lines, (0,255,0), 2)\n \n # Output road image with drawn raw lines and lists of left/right line coordinates\n return (image_wk, left_lines, right_lines)","def slope_lines(self,image):\r\n img_copy = image.copy()\r\n \r\n left_lines,right_lines=self.makeLeftRightline()\r\n left_line = np.mean(left_lines, axis=0)\r\n right_line = np.mean(right_lines, axis=0)\r\n\r\n poly_vertices = []\r\n order = [0,1,3,2]\r\n\r\n for slope, intercept in [left_line, right_line]:\r\n #getting height of image in y1\r\n rows, cols = image.shape[:2]\r\n y1= int(rows) \r\n #taking y2 upto 68% of y1\r\n y2= int(rows*0.68) \r\n #y=mx +c can be written as x=(y-c)/m\r\n x1=int((y1-intercept)/slope)\r\n x2=int((y2-intercept)/slope)\r\n poly_vertices.append((x1, y1))\r\n poly_vertices.append((x2, y2))\r\n\r\n # DRAWING LINES AND PATH ON THE IMAGE\r\n thickness_of_line=9\r\n color_of_line=[20, 255, 20]\r\n lines=np.array([[[x1,y1,x2,y2]]])\r\n for i in lines:\r\n for x1,y1,x2,y2 in i:\r\n cv2.line(img_copy, (x1, y1), (x2, y2), color_of_line, thickness_of_line)\r\n poly_vertices = [poly_vertices[i] for i in order]\r\n #filling polygon color\r\n cv2.fillPoly(img_copy, pts = np.array([poly_vertices],'int32'), color = (200,20,20))\r\n final_out=cv2.addWeighted(image,0.7,img_copy,0.4,0.)\r\n return final_out","def filterBankPatch(img, width=5):\n half = width / 2 # e.g. for 5, it's 2\n imgE = Views.extendBorder(img)\n ops = [offset(imgE, [x, y]) for x in xrange(-half, half + 1) for y in xrange(-half, half + 1)]\n return ops","def apply(self, image):\n\n bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\n\n # Convert to float image\n float_im = bgr.copy().astype('float32') / 255\n blurred = cv2.GaussianBlur(float_im, ksize=(9, 9), sigmaX=1, sigmaY=9)\n cplanes = colors.bgr2cpaces(blurred)\n lanes, py, pw = finder.find_lane_pixels(cplanes, self.pfilter, gamma=0.4)\n\n binary = lanes\n\n # Find lanes and fit curves\n if not self.curve:\n self.sw.find(binary)\n self.curve= CurveSearch(self.sw.left_fit, self.sw.right_fit,\n image_size=self.warped_image_size, margin=20)\n lane = self.sw.visualize_lane()\n curve_rad = self.measure_curvature(self.sw.left_fit, self.sw.right_fit)\n offset = self.measure_offset(self.sw.left_fit, self.sw.right_fit)\n else:\n self.curve.find(binary)\n lane = self.curve.visualize_lane()\n curve_rad = self.measure_curvature(self.curve.left_fit, self.curve.right_fit)\n offset = self.measure_offset(self.curve.left_fit, self.curve.right_fit)\n\n non_warped_lane = self.warp_inverse(lane)\n\n result = cv2.addWeighted(image, 1, non_warped_lane, 0.3, 0)\n cv2.putText(result, \"Curve Radius: {:.0f}m\".format(curve_rad), (50,50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255))\n cv2.putText(result, \"Off Center: {:.2f}m\".format(offset), (50, 100),\n cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255))\n\n return result","def get_regions_mask(self, input):","def get_masked_scene(orig, mask, local_context_size = 80, dilation=False):\n orig_scene = orig.copy()\n mask_scene = mask.copy()\n orig_scene_no_mask = orig.copy()\n \n mask_info = np.where(mask_scene == 0) \n min_x = max(min(mask_info[0]) - local_context_size, 0)\n max_x = max(mask_info[0]) + local_context_size\n min_y = max(min(mask_info[1]) - local_context_size, 0)\n max_y = max(mask_info[1]) + local_context_size\n \n orig_scene = orig_scene[min_x:max_x,min_y:max_y]\n orig_scene_no_mask = orig_scene_no_mask[min_x:max_x,min_y:max_y]\n mask_scene = mask_scene[min_x:max_x,min_y:max_y]\n \n dialation_mask = np.zeros(mask_scene.shape) + 255\n \n if dilation:\n dialation_mask = cv2.dilate(255-mask_scene, np.ones((local_context_size,local_context_size)))\n \n #implot(dialation_mask)\n #plt.imshow(dialation_mask, 'gray')\n \n for x in range(mask_scene.shape[0]):\n for y in range(mask_scene.shape[1]):\n if mask_scene[x, y] == 0:\n orig_scene[x, y, :] = 0\n orig_scene_no_mask[x,y,:] = 0\n if dilation:\n if dialation_mask[x,y] == 0:\n orig_scene[x, y, :] = 0\n \n return orig_scene, mask_scene, orig_scene_no_mask, dialation_mask","def _generateTotalMask(self):\r\n\r\n mask = np.zeros(self.altPosMap.shape)\r\n\r\n for patch in self.finalPatches.itervalues():\r\n mask = mask + patch.array.astype(np.float)\r\n\r\n mask = ni.binary_closing(mask,\r\n structure=np.array([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]),\r\n iterations=self.params['borderWidth'])\r\n\r\n return mask.astype(np.int8)","def plot_lanes(self, img, ax):\n left_fit, right_fit, left_fit_curve, right_fit_curve, left_lane_inds, right_lane_inds, out_img, nonzerox, nonzeroy = self.detect_lanes(img)\n # Visualization\n ploty = np.linspace(0, img.shape[0]-1, img.shape[0] )\n left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]\n right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\n\n out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]\n out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255]\n ax.imshow(out_img)\n ax.plot(left_fitx, ploty, color='yellow')\n ax.plot(right_fitx, ploty, color='yellow')\n return left_fit, right_fit, left_fit_curve, right_fit_curve","def fill_lane(self,img_shape):\n\n\t\tbinary_l = np.zeros(img_shape, dtype=np.uint8)\n\n\t\tploty = np.linspace(0, img_shape[0]-1, img_shape[0])\n\t\tplotx_l = self.leftLine.fit[0]*ploty**2 + self.leftLine.fit[1]*ploty + self.leftLine.fit[2]\n\t\tplotx_r = self.rightLine.fit[0]*ploty**2 + self.rightLine.fit[1]*ploty + self.rightLine.fit[2]\n\n\t\tline_points_l = np.column_stack((plotx_l,ploty))\n\t\tline_points_r = np.column_stack((plotx_r,ploty))\n\t\tline_points = np.concatenate((line_points_l,line_points_r[::-1],line_points_l[:1]))\n\n\t\tcv2.fillPoly(binary_l, np.int32([line_points]),color=255)\n\n\t\tpolygon = np.dstack((np.zeros(img_shape),binary_l,np.zeros(img_shape))).astype('uint8')\n\t\t\n\t\treturn polygon\n\t\tunwarped_polygon = self.cam.unwarp(polygon)\n\t\treturn unwarped_polygon","def test(shape=(1000,2000)):\n mask = Mask()\n mask.addCircle(400,300,250)\n mask.subtractCircle(400,300,150)\n mask.addRectangle(350,250,1500,700)\n plt.imshow( mask.getMask(shape) )\n return mask","def linesolve(mask, meta):\n for func in RULE_FUNCS:\n func(mask, meta)","def __mask_region(self, img, vertices):\n\n mask = np.zeros_like(img) \n if len(img.shape) > 2:\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\n ignore_mask_color = (255,) * channel_count\n else:\n ignore_mask_color = 255\n cv2.fillConvexPoly(mask, vertices, ignore_mask_color)\n masked_image = cv2.bitwise_and(img, mask)\n return masked_image","def __generate_mask(self):\n mask = np.concatenate([np.ones(len(self.fixed[0])),\n np.zeros(self.num_points),\n np.ones(len(self.fixed[1]))])\n return mask","def filter_lane_color(image):\n \n YELLOW_HSV_LOWER = np.array([20, 100, 100])\n YELLOW_HSV_UPPER = np.array([40, 255, 255])\n \n WHITE_HSV_LOWER = np.array([0, 0, 220])\n WHITE_HSV_UPPER = np.array([255, 255, 255])\n \n image_wk = np.copy(image) # working copy\n image_hsv = cv2.cvtColor(image_wk, cv2.COLOR_RGB2HSV) # RGB -> HSV\n \n yellow_mask = cv2.inRange(image_hsv, YELLOW_HSV_LOWER, YELLOW_HSV_UPPER)\n white_mask = cv2.inRange(image_hsv, WHITE_HSV_LOWER, WHITE_HSV_UPPER)\n both_mask = yellow_mask + white_mask\n \n image_wk = grayscale(image_wk) # RGB -> GRAY\n image_wk = cv2.bitwise_or(image_wk, both_mask) # GRAY + yellow/white mask\n \n # Output grayscale road image with enhanced yellow/white areas\n return image_wk","def ice_unmasked(res='4x5', debug=False):\n # Create a np.ma mask\n m = np.logical_not((land_unmasked(res)*ocean_unmasked(res)))\n if debug:\n print((mask, mask.shape))\n return m","def poly2mask(self):\n self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)\n self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)\n img = Image.new(\"L\", (self.x_gridnum, self.y_gridnum), 0)\n\n self.perimeter = 0.0\n for ii in self.polygons:\n pp = np.array(ii) * self.CD # polygon\n polygonlen = len(pp)\n self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))\n pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize\n pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize\n vetex_list = list(pp)\n polygon = [tuple(y) for y in vetex_list]\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\n\n self.data = np.array(img)\n self.data = np.float64(self.data)\n\n self.spat_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.freq_part = pyfftw.empty_aligned(\n (self.y_gridnum, self.x_gridnum), dtype=\"complex128\"\n )\n self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))","def draw_final_image(self, image, warped, undist, ploty, left_fitx, right_fitx, Minv, left_rad, right_rad):\n gray = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)\n # Create an image to draw the lines on\n warp_zero = np.zeros_like(gray).astype(np.uint8)\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\n\n # Recast the x and y points into usable format for cv2.fillPoly()\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\n pts = np.hstack((pts_left, pts_right))\n\n # Draw the lane onto the warped blank image\n cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))\n\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\n newwarp = cv2.warpPerspective(color_warp, Minv, (image.shape[1], image.shape[0]))\n # Combine the result with the original image\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\n\n font = cv2.FONT_HERSHEY_SIMPLEX\n off_center = calculate_center(left_fitx, right_fitx, image.shape)\n direction_str = 'left' if off_center < 0 else 'right'\n center_str = '{:.2f} m of center {}'.format(abs(off_center), direction_str)\n cv2.putText(result, center_str, (430, 630), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\n if left_rad and right_rad:\n curvature = 0.5 * (round(right_rad / 1000, 1) + round(left_rad / 1000, 1))\n else:\n curvature = 0\n str2 = 'Radius of curvature: {} km'.format(curvature)\n cv2.putText(result, str2, (430, 670), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\n\n if self.args.is_test:\n plt.imshow(result)\n plt.show()\n\n return result","def process_image(image):\n \n # (step 1) get gray image\n gray = grayscale(image)\n \n # (step 2) do gaussian blur with kernel size is 3\n blur_gray = gaussian_blur(gray, 3)\n \n # (step 3) do canny edge detction with low 50 and hight 150\n canny_edges = canny(blur_gray, 50, 150)\n \n # (step 4) region of interset\n imshape = image.shape\n left_bottom = (50,imshape[0])\n right_bottom = (imshape[1]-50,imshape[0])\n left_top = (420, 330)\n right_top = (imshape[1]-420, 330)\n # used later to discard lines which are out of the ROI\n polygon = Polygon([(50,imshape[0]+1),(imshape[1]-50,imshape[0]+1), (imshape[1]-420, 329), (420, 329)])\n vertices = np.array([[left_bottom,left_top, right_top, right_bottom]], dtype=np.int32)\n masked_edge = region_of_interest(canny_edges, vertices)\n \n # (step 5) get lane lines from hough transform\n rho = 2\n theta = np.pi/18 \n threshold = 15\n min_line_length = 10\n max_line_gap = 20\n lines = hough_lines(masked_edge, rho, theta, threshold, min_line_length, max_line_gap)\n \n # (step 6) seperate left and right lines\n left_lines = []\n right_lines = []\n for line in lines:\n for x1,y1,x2,y2 in line:\n if y1 > y2:\n temp_line = [x1,y1,x2,y2]\n if x2 != x1:\n m = (float(y2) - float(y1)) / (float(x2) - float(x1))\n else:\n m = 1000 # it will be dicarded, any high value will work\n temp_line.append(m)\n if x1 < x2:\n left_lines.append(temp_line)\n else:\n right_lines.append(temp_line)\n else:\n temp_line = [x2,y2,x1,y1]\n if x2 != x1:\n m = (float(y1) - float(y2)) / (float(x1) - float(x2))\n else:\n m = 1000\n temp_line.append(m)\n if x1 > x2:\n left_lines.append(temp_line)\n else:\n right_lines.append(temp_line)\n \n # (step 7) get left and right lines slopes, can be done with step 6 although\n left_slop = []\n for left_line in left_lines:\n x1 = left_line[0]; y1 = left_line[1]; x2 = left_line[2]; y2 = left_line[3]; \n if x1 != x2:\n left_slop.append( (float(y2) - float(y1)) / (float(x2) - float(x1)) )\n average_left_slop = sum(left_slop)/len(left_slop) # not used yet\n \n right_slop = []\n for right_line in right_lines:\n x1 = right_line[0]; y1 = right_line[1]; x2 = right_line[2]; y2 = right_line[3]; \n if x1 != x2:\n right_slop.append( (float(y2) - float(y1)) / (float(x2) - float(x1)) )\n average_right_slope = sum(right_slop)/len(right_slop) # not used yet\n \n \n # (step 8) delete left lines which deviate from thersold_s slope\n thersold_s = 0.4\n delet_left_index = []\n i = 0\n for left_line in left_lines:\n x1 = left_line[0]; y1 = left_line[1]; x2 = left_line[2]; y2 = left_line[3]; m = left_line[4]; \n if abs(m) < thersold_s:\n delet_left_index.append(i)\n i=i+1\n for i in range((len(delet_left_index)-1), -1, -1):\n del left_lines[delet_left_index[i]]\n \n # (step 9) delete right lines which deviate from average slope\n delet_index_right = []\n i = 0\n for right_line in right_lines:\n x1 = right_line[0]; y1 = right_line[1]; x2 = right_line[2]; y2 = right_line[3]; m = right_line[4]; \n if abs(m) < thersold_s:\n delet_index_right.append(i)\n i=i+1\n for i in range((len(delet_index_right)-1), -1, -1):\n del right_lines[delet_index_right[i]]\n \n # (step 10) extrapolate left and right lines\n left_line_draw = True\n x_lefts = []\n y_lefts = []\n for line in left_lines:\n x1, y1, x2, y2, m = line\n x_lefts.append(x1)\n x_lefts.append(x2) \n y_lefts.append(y1)\n y_lefts.append(y2)\n \n if len(x_lefts) > 0:\n slope_left, c_left = np.polyfit(x_lefts, y_lefts, 1)\n else:\n slope_left, c_left = 1, 1\n left_line_draw = False\n \n right_line_draw = True\n x_rights = []\n y_rights = []\n for line in right_lines:\n x1, y1, x2, y2, m = line\n x_rights.append(x1)\n x_rights.append(x2)\n y_rights.append(y1)\n y_rights.append(y2)\n if len(x_rights) > 0:\n slope_right, c_right = np.polyfit(x_rights, y_rights, 1)\n else:\n slope_right, c_right = 1, 1\n right_line_draw = False\n \n y1_left = 530 # again hardcoded values, from ROI\n y2_left = 330 # again hardcoded values, from ROI\n x1_left = int((y1_left - c_left) / slope_left)\n x2_left = int((y2_left - c_left) / slope_left)\n \n y1_right = 530 # again hardcoded values, from ROI\n y2_right = 330 # again hardcoded values, from ROI \n x1_right = int((y1_right - c_right) / slope_right)\n x2_right = int((y2_right - c_right) / slope_right)\n \n # (step 11) check if left/right line is out of ROI\n left_point1 = Point(x1_left, y1_left)\n left_point2 = Point(x2_left, y2_left)\n \n right_point1 = Point(x1_right, y1_right)\n right_point2 = Point(x2_right, y2_right)\n \n if polygon.contains(left_point1) and polygon.contains(left_point2):\n left_line_draw = True\n else:\n #print (\"left line out\", left_point1, left_point2)\n left_line_draw = False\n \n if polygon.contains(right_point1) and polygon.contains(right_point2):\n right_line_draw = True\n else:\n #print (\"right line out\", right_point1, right_point2)\n right_line_draw = False\n \n \n # (step 12) draw lines\n line_image = np.copy(image)\n # Draw the right and left lines on image\n if left_line_draw:\n cv2.line(line_image, (x1_left, y1_left), (x2_left, y2_left), (255,0,0),5)\n if right_line_draw:\n cv2.line(line_image, (x1_right, y1_right), (x2_right, y2_right), (255,0,0),5)\n \n # Create a \"color\" binary image to combine with line image\n color_edges = np.dstack((masked_edge, masked_edge, masked_edge)) \n \n # Draw the lines on the edge image\n lines_edges = cv2.addWeighted(color_edges, 0.4, line_image, 1, 0) \n #plt.imshow(lines_edges)\n #plt.show()\n return lines_edges","def draw_lane_on_img(undist, warped, left_fitx, right_fitx, ploty, Minv, curvature, distance):\n # Create an image to draw the lines on\n warp_zero = np.zeros_like(warped).astype(np.uint8)\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\n\n # Recast the x and y points into usable format for cv2.fillPoly()\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\n pts = np.hstack((pts_left, pts_right))\n\n # Draw the lane onto the warped blank image\n cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))\n\n # Draw lane boundary\n left_lane = np.int32(pts_left)\n right_lane = np.int32(pts_right)\n color_warp = cv2.polylines(color_warp, [left_lane], False, (255,0,0), 16)\n color_warp = cv2.polylines(color_warp, [right_lane], False, (0, 0, 255), 16)\n\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\n newwarp = cv2.warpPerspective(color_warp, Minv, (undist.shape[1], undist.shape[0])) \n # Combine the result with the original image\n result = cv2.addWeighted(undist, 1, newwarp, 0.4, 0)\n\n # Write out the curvature and relative position\n curv_info = \"Radius of Curvature ={0:.2f}(m).\".format(curvature)\n if distance > 0:\n pos_info = \" Car is {0:.2f}m right of center.\".format(distance)\n else:\n pos_info = \" Car is {0:.2f}m left of center.\".format(-distance)\n info = curv_info + pos_info\n cv2.putText(result, info, (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2, bottomLeftOrigin=False)\n\n return result","def draw_lines(args, img, lines, color=[255, 0, 0], thickness=8):\n slopes = [ (line[0][3]-line[0][1])/(line[0][2]-line[0][0]) for line in lines]\n rights = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope > 0.0 ] # and slope < 0.5 and not np.isnan(slope) ]\n lefts = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope < 0.0 ] # and slope > -0.5 and not np.isnan(slope) ]\n #lefts[0] = [ [[x1,y1,x2,y2]] , slope , y_intercept ]\n\n y_mins = [ min(line[0][1],line[0][3]) for line in lines]\n y_min = min(y_mins)\n y_max = img.shape[0]\n\n log_new = [slopes, rights, lefts, y_mins, y_min, y_max]\n\n for lanes in [rights,lefts]:\n slope_mean = np.mean( [ lane[1] for lane in lanes ] )\n slope_std = np.std ( [ lane[1] for lane in lanes ] )\n if slope_std == 0:\n slope = slope_mean\n else:\n slope = np.mean( [ lane[1] for lane in lanes if lane[1] - slope_mean < 2*slope_std ] ) \n print()\n print('slope : {}'.format(slope))\n\n intercept_mean = np.mean( [ lane[2] for lane in lanes ] )\n intercept_std = np.std ( [ lane[2] for lane in lanes ] )\n if intercept_std == 0:\n intercept = intercept_mean\n else:\n intercept = np.mean( [ lane[2] for lane in lanes if lane[2] - intercept_mean < 2*intercept_std ] )\n print('intercept : {}'.format(intercept))\n \n x_min = int( ( y_min - intercept ) / slope ) \n x_max = int( ( y_max - intercept ) / slope )\n\n log_new.append(slope)\n log_new.append(intercept)\n log_new.append(x_min)\n log_new.append(x_max)\n\n cv2.line(img, (x_min, y_min), (x_max, y_max), color, thickness)\n\n try: \n log_line = pd.read_csv(args.path+args.csv_file, skiprows=[0], names=args.header)\n except:\n log_line = pd.DataFrame([ ], columns=args.header)\n finally:\n df = pd.DataFrame([ log_new ], columns=args.header)\n # update log: add new entry into the log\n result = pd.concat([log_line, df], ignore_index=True)\n result.to_csv(args.path+args.csv_file) #, index=False)","def get_lane_lines(self, lines, image):\n # get image shape\n img_height, img_width, _ = image.shape\n\n # get left and right lanes\n slope_lower_bnd, slope_upper_bnd = self.slope_params[\"bounds\"]\n left_lane, right_lane = get_lanes_segments(\n lines, slope_lower_bnd, slope_upper_bnd\n )\n\n # use get_line_end_pts to convert left_lane and right_lane to their corresponding end points\n left_lane = get_line_end_pts(\n left_lane, y1=img_height, y2=self.LANE_LINE_IMG_RATIO * img_height\n )\n right_lane = get_line_end_pts(\n right_lane, y1=img_height, y2=self.LANE_LINE_IMG_RATIO * img_height\n )\n\n # update cache and apply probablistic smoothing\n left_lane, self.left_lane_cache = self.probablistic_smoothing(\n left_lane, self.left_lane_cache\n )\n\n right_lane, self.right_lane_cache = self.probablistic_smoothing(\n right_lane, self.right_lane_cache\n )\n\n return left_lane, right_lane","def pipeline(image, plot = False):\n # undistort image\n undistorted_image = undistort_image(image)\n \n # R&S|sobel-x thresholding\n _, _, _, _, threshold_image = thresholding(undistorted_image)\n \n # yellow mask\n _, mask_yellow = filter_color(undistorted_image, np.array([20,100,100]), np.array([50,255,255]))\n \n # white mask\n _, mask_white = filter_color(undistorted_image, np.array([0,0,220]), np.array([255,35,255]))\n \n # combine yellow and white mask\n mask = cv2.bitwise_or(mask_yellow, mask_white)\n comb_image = np.zeros_like(threshold_image)\n \n # combine mask and thresholded image\n comb_image[(mask > 0)&(threshold_image == 1)] = 1\n \n # warp the binary image\n warped_image, Minv = warp(comb_image, src, dst)\n if plot:\n plt.figure(2)\n plt.imshow(warped_image, cmap = \"gray\")\n plt.title(\"Binary warped image\")\n \n # calculate polynomial fit\n left_fitx, right_fitx, ploty, left_curverad, right_curverad, offset = fit_polynomial(warped_image, plot)\n \n # superimpose lines on top of the polynomial\n superimposed_image = mark_lane_lines(undistorted_image, warped_image, ploty, left_fitx, right_fitx, Minv)\n cv2.putText(superimposed_image, \"Left curvature = \" + str(np.round(left_curverad, 2)) + \" m\",(40,40), \\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\n cv2.putText(superimposed_image,\"Right curvature = \" + str(np.round(right_curverad, 2)) + \" m\",(40,80), \\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\n cv2.putText(superimposed_image,\"Offset = \" + str(np.round(offset*100, 2)) + \" cm\",(40,120), \\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\n \n return superimposed_image","def get_mask(self):\n\t\treturn pygame.mask.from_surface(self.img)","def lane_find(self, binary_warped):\n\t\t# Identify the x and y positions of all nonzero pixels in the image\n\t\tnonzero = binary_warped.nonzero()\n\t\tnonzeroy = np.array(nonzero[0])\n\t\tnonzerox = np.array(nonzero[1])\n\t\t# Set th ewidth of the windows +/- margin\n\t\tmargin = 100\n\t\tleft_lane_inds = ((nonzerox > (self.left_fit[0] * (nonzeroy ** 2) + self.left_fit[1] * nonzeroy + self.left_fit[2] - margin)) & \n\t\t\t(nonzerox < (self.left_fit[0] * (nonzeroy ** 2) + self.left_fit[1] * nonzeroy + self.left_fit[2] + margin)))\n\t\tright_lane_inds = ((nonzerox > (self.right_fit[0] * (nonzeroy ** 2) + self.right_fit[1] * nonzeroy + self.right_fit[2] - margin)) & \n\t\t\t(nonzerox < (self.right_fit[0] * (nonzeroy ** 2) + self.right_fit[1] * nonzeroy + self.right_fit[2] + margin)))\n\t\t# Again, extract left and right line pixel positions\n\t\tleftx = nonzerox[left_lane_inds]\n\t\tlefty = nonzeroy[left_lane_inds]\n\t\trightx = nonzerox[right_lane_inds]\n\t\trighty = nonzeroy[right_lane_inds]\n\t\t# Fit a second order polynomial to each\n\t\tself.left_fit = np.polyfit(lefty, leftx, 2)\n\t\tself.right_fit = np.polyfit(righty, rightx, 2)\n\t\t# Generate x and y values for plotting\n\t\tploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0])\n\t\tleft_fitx = self.left_fit[0] * ploty ** 2 + self.left_fit[1] * ploty + self.left_fit[2]\n\t\tright_fitx = self.right_fit[0] * ploty ** 2 + self.right_fit[1] * ploty + self.right_fit[2]\n\t\treturn left_fitx, right_fitx","def mask_the_images(working_path,set_name):\n\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41cf2fb1198e.npy')\n out_images = [] #final set of images for all patients\n for fname in file_list:\n out_images_per_patient = []\n print (\"working on file \", fname)\n imgs_to_process = np.load(fname.replace(\"lungmask\",\"images\")) # images of one patient\n masks = np.load(fname)\n for i in range(len(imgs_to_process)):\n mask = masks[i]\n img = imgs_to_process[i]\n new_size = [512,512] # we're scaling back up to the original size of the image\n img= mask*img # apply lung mask\n #\n # renormalizing the masked image (in the mask region)\n #\n new_mean = np.mean(img[mask>0])\n new_std = np.std(img[mask>0])\n #\n # Pulling the background color up to the lower end\n # of the pixel range for the lungs\n #\n old_min = np.min(img) # background color\n img[img==old_min] = new_mean-1.2*new_std # resetting backgound color\n img = img-new_mean\n img = img/new_std\n #make image bounding box (min row, min col, max row, max col)\n labels = measure.label(mask)\n regions = measure.regionprops(labels)\n #\n # Finding the global min and max row over all regions\n #\n min_row = 512\n max_row = 0\n min_col = 512\n max_col = 0\n for prop in regions:\n B = prop.bbox\n if min_row > B[0]:\n min_row = B[0]\n if min_col > B[1]:\n min_col = B[1]\n if max_row < B[2]:\n max_row = B[2]\n if max_col < B[3]:\n max_col = B[3]\n width = max_col-min_col\n height = max_row - min_row\n if width > height:\n max_row=min_row+width\n else:\n max_col = min_col+height\n #\n # cropping the image down to the bounding box for all regions\n # (there's probably an skimage command that can do this in one line)\n #\n img = img[min_row:max_row,min_col:max_col]\n mask = mask[min_row:max_row,min_col:max_col]\n if max_row-min_row <5 or max_col-min_col<5: # skipping all images with no god regions\n pass\n else:\n # moving range to -1 to 1 to accomodate the resize function\n mean = np.mean(img)\n img = img - mean\n min = np.min(img)\n max = np.max(img)\n img = img/(max-min)\n new_img = resize(img,[512,512], mode='constant')\n out_images_per_patient.append(new_img)\n\n id = re.sub(r'.*_images_(.*)\\.npy',r'\\1',fname)\n patient_images_and_id = (out_images_per_patient,id)\n out_images.append(patient_images_and_id)\n print (\"Delete files: {} \\n\\t {} \".format(fname,re.sub(\"lungmask\",\"images\",fname)))\n os.remove(fname)\n os.remove(fname.replace(\"images\",\"lungmask\")) # images of one patient\n\n\n np.save(working_path+\"{}Images.npy\".format(set_name),out_images)","def mask(self):\n\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\n\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\n\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\n\n cv2.floodFill(image=mask,\n mask=mask_with_border,\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\n newVal=constants.COLOR_WHITE_MONO)\n\n return mask","def generate_MLmask(self):\r\n self.MLmask = np.zeros((self.MLtargetedImg.shape[0], self.MLtargetedImg.shape[1]))\r\n \r\n if len(self.selected_ML_Index) > 0:\r\n for selected_index in self.selected_ML_Index:\r\n self.MLmask = np.add(self.MLmask, self.Mask[:,:,selected_index])\r\n \r\n self.intergrate_into_final_mask()\r\n \r\n self.add_rois_of_selected()\r\n \r\n else:\r\n self.intergrate_into_final_mask()","def save_mask(image_as_array, imagefolder_new, imagetype_new, imagename):\n\n # Create argument parser for the thresholds\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-hl\",\n \"--h_lines_threshold\",\n help=\"Defines pixel threshold for horizontal lines in find_lines.py.\",\n type=float,\n default=0.01,\n )\n parser.add_argument(\n \"-vl\",\n \"--v_lines_threshold\",\n help=\"Defines pixel threshold for vertical lines in find_lines.py.\",\n type=float,\n default=0.005,\n )\n parser.add_argument(\n \"-b\",\n \"--beamstop_threshold\",\n help=\"Defines pixel threshold for find_beamstop.py.\",\n type=int,\n default=10,\n )\n args = parser.parse_args()\n\n # Convert image to grayscale\n gray_scale_img = normalize_image(image_as_array)\n\n # Create mask for horizontal lines\n h_lines_threshold = args.h_lines_threshold\n FILEPATH_mask = imagefolder_new + imagename + \"_mask\" + imagetype_new\n mask_horizontal_lines = find_horizontal_lines(gray_scale_img, h_lines_threshold)\n\n # Create mask for vertical lines\n v_lines_threshold = args.v_lines_threshold\n FILEPATH_mask = imagefolder_new + imagename.split(\".\")[0] + \"_mask\" + imagetype_new\n mask_vertical_lines = find_vertical_lines(gray_scale_img, v_lines_threshold)\n\n # Create mask for beamstop\n beamstop_threshold = args.beamstop_threshold\n coordinates = select_area_of_interest(gray_scale_img)\n mask_beamstop = create_mask(gray_scale_img, coordinates, beamstop_threshold)\n\n # Create mask for vertical line (holder)\n val = input(\"Is there a beamstop holder to mask ([Y]/n)? \")\n if val == \"Y\" or val == \"\":\n mask_vert = select_vert(gray_scale_img)\n\n # Combine masks\n mask_as_array = (\n mask_horizontal_lines * mask_vertical_lines * mask_beamstop * mask_vert\n )\n # Combine masks\n else:\n mask_as_array = mask_horizontal_lines * mask_vertical_lines * mask_beamstop\n\n # Convert from array to 3-channel PIL image\n mask_as_array_as_dummy_rgb = np.transpose(\n np.array(\n [\n np.transpose(mask_as_array * 255),\n np.transpose(mask_as_array * 255),\n np.transpose(mask_as_array * 255),\n ]\n ).astype(dtype=np.uint8)\n )\n img_mask = Image.fromarray(mask_as_array_as_dummy_rgb)\n\n # Save mask\n img_mask.save(FILEPATH_mask)","def maskall(image_input_path,shapeloc_input_path,txtloc_input_path, comploc_input_path, output_path):\n print(\"========== mask shapes and text ==============\")\n if os.path.exists(output_path):\n shutil.rmtree(output_path)\n os.makedirs(output_path)\n img_fn_list = get_images(image_input_path)\n wl = 4\n for img_fn in img_fn_list:\n print(img_fn)\n img_raw = cv2.imread(img_fn)\n img_gray = cv2.cvtColor(img_raw, cv2.COLOR_BGR2GRAY)\n img_binary = cv2.threshold(img_gray, 128, 255, cv2.THRESH_BINARY)[1]\n h, w = img_binary.shape[:2]\n img_blank = np.ones(shape=[h, w], dtype=np.uint8)*255\n\n with open(os.path.join (shapeloc_input_path, os.path.splitext(os.path.basename(img_fn))[0]) + \"_loc.txt\", 'r') as file1:\n for line in file1:\n cnt = [i for i in line.split()]\n loc = [int(i) for i in cnt[1:]]\n cv2.drawContours(img_blank, [np.array(loc).reshape((-1,1,2))], 0, (0), thickness = -1, lineType=8)\n\n with open(os.path.join (comploc_input_path, os.path.splitext(os.path.basename(img_fn))[0]) + \"_loc.txt\", 'r') as file2:\n for line in file2:\n cnt = [i for i in line.split()]\n loc = [int(i) for i in cnt[1:]]\n cv2.drawContours(img_blank, [np.array(loc).reshape((-1,1,2))], 0, (0), thickness = -1, lineType=8)\n\n with open(os.path.join (txtloc_input_path, os.path.splitext(os.path.basename(img_fn))[0]) + \"_loc.txt\", 'r') as file3:\n for line in file3:\n if bool(line and line.strip()):\n cnt = [i for i in line.split()] \n loc = [int(i) for i in cnt[1:]]\n # crop image with rectangle box and save\n x0,y0,w0,h0 = cv2.boundingRect(np.array(loc[:8]).astype(np.int32).reshape((-1, 2)))\n img_crop = img_blank[y0:y0+h0,x0:x0+w0].copy()\n hc, wc = img_crop.shape[:2]\n countzero = hc*wc - cv2.countNonZero(img_crop)\n if countzero *1.0 / (hc*wc) <= 0.25:\n # if new area is less than 25% of overlap with other proposed masked area\n cv2.drawContours(img_blank, [np.array(loc[:8]).astype(np.int32).reshape((-1, 1, 2))], 0, (0), thickness=-1, lineType=8)\n \n #img_mask = cv2.bitwise_and(img_blank, img_binary, mask = None)\n img_mask = cv2.bitwise_or(cv2.bitwise_not(img_blank), img_binary, mask = None)\n cv2.imwrite(os.path.join(output_path, os.path.basename(img_fn)), img_mask)","def find_lane_fast(img, left_fit, right_fit):\n\n nonzero = img.nonzero()\n nonzeroy = np.array(nonzero[0])\n nonzerox = np.array(nonzero[1])\n\n margin = 150\n left_lane_inds = ((nonzerox > (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) & (\n nonzerox < (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] + margin)))\n right_lane_inds = (\n (nonzerox > (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) & (\n nonzerox < (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] + margin)))\n\n # Again, extract left and right line pixel positions\n leftx = nonzerox[left_lane_inds]\n lefty = nonzeroy[left_lane_inds]\n rightx = nonzerox[right_lane_inds]\n righty = nonzeroy[right_lane_inds]\n\n # Fit a second order polynomial to each\n left_fit = np.polyfit(lefty, leftx, 2)\n right_fit = np.polyfit(righty, rightx, 2)\n\n return left_fit, right_fit","def CreateLandmask(Fieldset, test = False):\n \n \n \"\"\"\n This first set of lines creates a numpy array with u velocities and a numpy\n array with v velocities. First we get the U and V fields from the dataset. Then\n we compute a time chunk, which is needed because of the dataset. Then we only\n take the first slice of the U and V field (we do not need more for finding the land\n and ocean grids). As last we make an empty array which will be filled with zeros and \n ones.\n \"\"\"\n fU = Fieldset.U\n fV = Fieldset.V\n Fieldset.computeTimeChunk(fU.grid.time[0], 1) \n uvel_mask_c = fU.data[0,:,:] \n vvel_mask_c = fV.data[0,:,:]\n# vvel_mask_c = np.roll(vvel_mask_c, 1, axis = 0)\n landmask = np.zeros((uvel_mask_c.shape[0], uvel_mask_c.shape[1]))\n \n \"\"\"\n The first loop checks the value of the u and v velocitites. Notice that we get the\n values of two adjacent grid, since we're working with a C-grid.\n Visualizations of velocities in the C-grids(see below). So for a grid to be flagged identified\n as a land grid two U velocities and 2 V velocities need to be zero. The first loop makes all\n ocean grids 1 and land grids 0. \n ____ ____ ____ ____\n | V | V | \n | | | \n U T U T U\n | | | \n |____V____|_____V_____| \n \"\"\"\n \n for i in range (len(landmask[:,0])-1):\n for j in range (len(landmask[0,:])-1):\n u1 = uvel_mask_c[i,j]\n\n u2 = uvel_mask_c[i,j+1]\n\n v1 = vvel_mask_c[i,j]\n\n v2 = vvel_mask_c[i+1,j]\n\n if u1 != 0 or u2 != 0 or v1 != 0 or v2 != 0:\n landmask[i,j] = 1\n \n \n \"\"\"\n Change all zero to 1 and rest 0. since we want the land grids to be 1 and ocean\n grids to be 0. \n \"\"\"\n \n landmask = ChangeValues(landmask,0,1) \n \n \"\"\"\n The created landmask needs to be shifted upwards one grid. We will\n use the numpy roll function to do this.\n \"\"\"\n \n if test == True:\n plt.figure()\n plt.imshow(landmask)\n plt.colorbar()\n \n return landmask","def find_epilines(imgLeft, imgRight, ptsLeft, ptsRight, F):\n color = []\n for i in range(ptsLeft.shape[0]):\n color.append(tuple(np.random.randint(0, 255, 3).tolist()))\n print(color)\n\n # Find epilines corresponding to points in right image (right image)\n linesLeft = cv2.computeCorrespondEpilines(ptsRight.reshape(-1, 1, 2), 2, F)\n linesLeft = linesLeft.reshape(-1, 3)\n # Draw its lines on left image\n img5, img6 = drawlines(imgLeft, imgRight, linesLeft, ptsLeft, ptsRight, color)\n\n # Find epilines corresponding to points in left image (left image)\n linesRight = cv2.computeCorrespondEpilines(ptsLeft.reshape(-1, 1, 2), 1, F)\n linesRight = linesRight.reshape(-1, 3)\n # Draw its lines on right image\n img3, img4 = drawlines(imgRight, imgLeft, linesRight, ptsRight, ptsLeft, color)\n\n plt.subplot(121), plt.imshow(img5)\n plt.subplot(122), plt.imshow(img3)\n plt.show()","def first_processing(self,img):\r\n \r\n processed_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\r\n #cv2.imshow('Balc',processed_img)\r\n #vertices = np.array([[0,480],[0,200],[640,200], [640,480] ], np.int32)\r\n #processed_img = self.masking(processed_img,[vertices])\r\n processed_img = cv2.Canny(processed_img, threshold1 = 50, threshold2=100)\r\n processed_img = cv2.GaussianBlur(processed_img,(5,5),0)\r\n #masking image (only below 200px cheight processing--> no horizont is detected)\r\n #cv2.imshow('2',processed_img)\r\n lines = cv2.HoughLinesP(processed_img, 1, np.pi/180, 180,np.array([]),100, 30)\r\n return lines","def image_mask(image, patch_R, patch_C, seg_model):\n\n im = Image.open(image)\n im_name = os.path.basename(image).split('.')[0]\n im_width, im_height = im.width, im.height\n\n N = patch_R // patch_C\n\n W_ps_NI = im_width // patch_C # 31782 // 256 = 124\n # W_ps_NR = slide_width % patch_C # 31782 % 256 = 38\n H_ps_NI = im_height // patch_R # 24529 // 1024 = 23\n # H_ps_NR = slide_height % patch_R # 24529 % 1024 = 977\n\n cell_ratio = 0.85 # the threshold that decide the patch is background or not\n\n output_dir = os.path.join(current_path, \"..\", \"output\", \"output_mask\")\n if not os.path.isdir(output_dir): os.makedirs(output_dir)\n\n np_im = np.array(im)[:, :, 0:3] # exclude alpha\n for w in range(W_ps_NI):\n for h in range(H_ps_NI):\n subHIC = np_im[h * patch_R: (h+1) * patch_R, w * patch_C:(w+1) * patch_C, :]\n\n # rgb three channels value that >200 and <40 are ignored segment\n rgb_s = (abs(subHIC[:, :, 0] - 120) >= 80) & (abs(subHIC[:, :, 1] - 120) >= 80) & (\n abs(subHIC[:, :, 2] - 120) >= 80) # >200 <40\n\n if np.sum(rgb_s) <= (patch_R * patch_C) * cell_ratio:\n # segment\n subHIC = np.where(rgb_similarity(subHIC, 15, 195), 250, subHIC)\n # adjust equalization histogram and adjust brightness\n for k in range(subHIC.shape[2]):\n clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(N * 4, 4))\n subHIC[:, :, k] = clahe.apply(subHIC[:, :, k])\n subHIC = exposure.adjust_gamma(subHIC, gamma=1.5)\n subHIC = subHIC.reshape(N, patch_C, patch_C, 3)\n\n subHIC = subHIC.reshape(N, patch_C, patch_C, 3)\n allmask_prob_list = maskrcnn_detection(seg_model, subHIC)\n\n for i in range(len(allmask_prob_list)):\n for layer in range(allmask_prob_list[i].shape[2]):\n image, cnts, hierarchy = cv2.findContours(allmask_prob_list[i][:, :, layer],\n cv2.RETR_EXTERNAL,\n cv2.CHAIN_APPROX_SIMPLE)\n np_im[h * patch_R + i * patch_C: h * patch_R + (i + 1) * patch_C, w * patch_C:(w + 1) * patch_C,\n :] = cv2.drawContours(np_im[h * patch_R + i*patch_C: h*patch_R+(i+1)*patch_C, w * patch_C:(w + 1) * patch_C, :],\n cnts, -1, (0, 255, 0), 1)\n\n # np_im[h * patch_R + i*patch_C: h*patch_R+(i+1)*patch_C, w * patch_C:(w + 1) * patch_C, :] = subHIC[i]\n\n # plt.savefig(os.path.join(output_dir, f\"{im_name}w{w}h{h}N{i}.png\"))\n\n io.imsave(os.path.join(output_dir, f\"{im_name}.png\"), np_im)","def process_laneOffset(self):\n center_line = np.poly1d(np.mean([self.line_l.get_LinePoly().coeffs, self.line_r.get_LinePoly().coeffs], axis=0))\n # store the center line polynomial\n self.center_poly = center_line\n center_point = IMAGE_WIDTH/2 - center_line(709)\n offset_from_center =center_point* self.line_l.x_pxm\n self.lane_offset = offset_from_center\n return center_point","def GetCoastGrids(LandMask):\n \n \"\"\"\n Define a coastline map. This map will be set to 1 on all coast cells.\n \"\"\"\n \n \n CoastlineMap = np.zeros((LandMask.shape[0], LandMask.shape[1]))\n \n \"\"\"\n We will use a nested loop to loop through all cells of the Landmask cell. What this loop basically does is,\n when a cell has a value of 1 (land), it will make all surrounding cells 1, so we create kind of an extra line of \n grids around the landmask. In the end we will substract the landmask from the mask which is created by the nested loop, \n which result in only a mask with the coast grids. Notice, that when we're in the corner, upper, side, or lower row, and we\n meet a land cell, we should not make all surrounding cells 1. For example, we the lower left corner is a land grid, you should only make the inner cells 1. \n \"\"\"\n \n for i in range(LandMask.shape[0]-1):\n for j in range(LandMask.shape[1]-1):\n \n\n \"\"\"\n We have nine if statements, four for the corners, four for the sides and one for the middle\n of the landmask. \n \"\"\"\n\n if i == 0 and j == 0: #upper left corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j+1] = 1\n \n \n elif i == 0 and j != 0 and j != LandMask.shape[1]-1: #upper row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1, j] = 1\n CoastlineMap[i+1,j-1] = 1\n CoastlineMap[i+1,j+1] = 1\n \n \n elif i == 0 and j == LandMask.shape[1]-1: #upper right corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j-1] = 1\n \n elif i != 0 and i != LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #right row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i+1,j] = 1\n CoastlineMap[i-1,j] = 1\n \n CoastlineMap[i, j-1] = 1\n CoastlineMap[i+1,j-1] = 1\n CoastlineMap[i-1,j-1] = 1\n \n elif i == LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #lower right corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n \n CoastlineMap[i-1,j] = 1 \n CoastlineMap[i-1, j-1] = 1\n \n elif i == LandMask.shape[0]-1 and j != 0 and j != LandMask.shape[1]-1: #lower row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j-1] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i-1, j] = 1\n CoastlineMap[i-1,j-1] = 1\n CoastlineMap[i-1,j+1] = 1\n \n \n elif i == LandMask.shape[0]-1 and j == 0: #lower left corner\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i,j+1] = 1\n \n CoastlineMap[i+1,j] = 1 \n CoastlineMap[i+1, j+1] = 1\n \n elif i != 0 and i != LandMask.shape[0]-1 and j == 0: #left row\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1\n CoastlineMap[i+1,j] = 1\n CoastlineMap[i-1,j] = 1\n \n CoastlineMap[i, j+1] = 1\n CoastlineMap[i+1,j+1] = 1\n CoastlineMap[i-1,j+1] = 1\n \n else:\n \n if LandMask[i,j] == 1:\n \n CoastlineMap[i,j] = 1 #middle\n CoastlineMap[i+1,j] = 1#lowermiddle\n CoastlineMap[i-1,j] = 1#uppermiddle\n \n CoastlineMap[i+1, j-1] = 1\n CoastlineMap[i-1, j-1] = 1\n CoastlineMap[i, j-1] =1\n \n CoastlineMap[i+1, j+1] = 1\n CoastlineMap[i-1, j+1] = 1\n CoastlineMap[i, j+1] = 1\n \n \n \n \"\"\"\n Here we substract the landmaks from the coastline mask, resulting in only\n the coastline. \n \"\"\"\n \n \n Coastgrids = CoastlineMap - LandMask\n \n return Coastgrids, CoastlineMap","def add_image_mask(image, image_mask):\n try:\n # image1 * a + image2 * b + lambda\n # image1 and image2 must be the same shape.\n summed = cv2.addWeighted(image, 0.8, image_mask, 1, 0)\n return summed\n except:\n print(\"Unable to apply mask, Check the shape of mask and image\")","def get_mask(self, methods=None): \r\n plot_mask = np.ones(self.ndetects, np.bool_)\r\n rec_tr = self.rec_track\r\n\r\n for nm,method in enumerate(methods):\r\n method_mask = rec_tr[method] == 1\r\n plot_mask = np.multiply(~method_mask, plot_mask)\r\n\r\n return plot_mask","def get_ellipann_mask(self, x, y, a, b, theta, rin, rout):\n from sep import mask_ellipse\n ellipsemask_o = np.asarray(np.zeros((self.height,self.width)),dtype=\"bool\")\n ellipsemask_i = np.asarray(np.zeros((self.height,self.width)),dtype=\"bool\")\n\n mask_ellipse( ellipsemask_o, x, y, a, b, theta, r= rout)\n mask_ellipse( ellipsemask_i, x, y, a, b, theta, r= rin )\n\n return ~ ((~ellipsemask_o) + ellipsemask_i)","def pipeline(image,motorq):\n\n height = image.shape[0]\n width = image.shape[1]\n region_of_interest_vertices = [\n (0, height),\n (width / 2, 0),\n (width, height),\n ]\n blur = cv2.blur(image,(5,5))\n gray_image = cv2.cvtColor(blur, cv2.COLOR_RGB2GRAY)\n\n cannyed_image = cv2.Canny(gray_image, 100, 200)\n \n # cropped_image = region_of_interest(\n # cannyed_image,\n # np.array(\n # [region_of_interest_vertices],\n # np.int32\n # ),\n # )\n \n lines = cv2.HoughLinesP(\n cannyed_image,\n rho=6,\n theta=np.pi / 60,\n threshold=160,\n lines=np.array([]),\n minLineLength=40,\n maxLineGap=25\n )\n \n left_line_x = []\n left_line_y = []\n right_line_x = []\n right_line_y = []\n #print(lines)\n if not np.any(lines):\n return image\n \n for line in lines:\n for x1, y1, x2, y2 in line:\n #print line\n if (x2-x1) == 0:\n break\n slope = float(y2 - y1) / (x2 - x1)\n if math.fabs(slope) < 0.5:\n continue\n if slope <= 0:\n left_line_x.extend([x1, x2])\n left_line_y.extend([y1, y2])\n else:\n right_line_x.extend([x1, x2])\n right_line_y.extend([y1, y2])\n\n if len(left_line_x)==0 or len(right_line_x)==0:\n return image\n\n min_y = int(image.shape[0] * (3 / 5))\n max_y = int(image.shape[0])\n\n poly_left = np.poly1d(np.polyfit(\n left_line_y,\n left_line_x,\n deg=1\n ))\n \n left_x_start = int(poly_left(max_y))\n left_x_end = int(poly_left(min_y))\n \n poly_right = np.poly1d(np.polyfit(\n right_line_y,\n right_line_x,\n deg=1\n ))\n \n right_x_start = int(poly_right(max_y))\n right_x_end = int(poly_right(min_y))\n\n line_image = draw_lines(\n image,\n [[\n [left_x_start, max_y, left_x_end, min_y],\n [right_x_start, max_y, right_x_end, min_y],\n ]],\n thickness=5,\n )\n\n x_int = Intersect([left_x_start, max_y], [left_x_end, min_y], [right_x_start, max_y], [right_x_end, min_y])[0]\n #print(line_image.shape()[0])\n middle = line_image.shape[0]/2\n if x_int < middle-140:\n motorq.put( [ -13000 , 0 ] )\n elif x_int > middle+140:\n motorq.put( [ 0, -13000 ] )\n else:\n motorq.put( [ -13000, -13000 ] )\n\n \n\n\n return line_image","def __set_mask_regions(self):\n self.bottom_clip = np.int32(np.int32([[[60,0], [1179,0], [1179,650], [60,650]]]))\n self.roi_clip = np.int32(np.int32([[[640, 425], [1179,550], [979,719],\n [299,719], [100, 550], [640, 425]]]))","def get_mask(cls, azim):\n\n if cls.mask is None:\n raise ValueError(\"No mask defined for the station {}\".format(cls.name))\n\n azim %= 2 * np.pi\n\n if azim in cls.mask[0, :]:\n return cls.mask[1, np.where(azim == cls.mask[0, :])[0][0]]\n\n for next_i, mask_azim in enumerate(cls.mask[0, :]):\n if mask_azim > azim:\n break\n else:\n next_i = 0\n\n x0, y0 = cls.mask[:, next_i - 1]\n x1, y1 = cls.mask[:, next_i]\n\n if next_i - 1 == -1:\n x0 = 0\n\n return y0 + (y1 - y0) * (azim - x0) / (x1 - x0)","def _source_mask(self, ilens):\n x_masks = make_non_pad_mask(ilens)\n return x_masks.unsqueeze(-2)","def mask_border(self, left=3, right=3, top=3, bottom=3):\n self.MaskPrefix = 'b' + self.MaskPrefix #prepend 'b' for border\n print('Masking edge pixels: left={0}, right={1}, top={2}, bottom={3}'.format(left,right,top,bottom))\n for ig in self.Set:\n igram = self.load_ma(ig)\n igram[:top,:] = ma.masked\n igram[-bottom:,:] = ma.masked\n igram[:,:left] = ma.masked\n igram[:,-right:] = ma.masked\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\n print(mskFile)\n print('mask_border() complete: {0} interferograms'.format(self.Set.Nig))","def _get_mask(self, anno, idx):\n coco = self.coco\n img_info = coco.loadImgs(self.img_ids[idx])[0]\n\n m = np.zeros((img_info['height'], img_info['width']), dtype=np.float32)\n\n for obj in anno:\n if 'segmentation' in obj:\n if obj['iscrowd']:\n rle = pycocotools.mask.frPyObjects(obj['segmentation'],\n img_info['height'],\n img_info['width'])\n m += pycocotools.mask.decode(rle)\n elif obj['num_keypoints'] == 0:\n rles = pycocotools.mask.frPyObjects(obj['segmentation'],\n img_info['height'],\n img_info['width'])\n for rle in rles:\n m += pycocotools.mask.decode(rle)\n\n return m < 0.5","def land_unmasked(res='4x5', debug=False):\n from .GEOSChem_bpch import get_LWI_map # Kludge, use GEOS-Chem LWI\n\n # Create a np.ma mask\n if debug:\n print(('land_mask called for: ', res))\n m = np.ma.masked_not_equal(get_LWI_map(res=res), 1)\n if debug:\n print((mask, mask.shape))\n return m.mask","def inpaint(self, img_slice, mask_slice, min_x, max_x, min_y, max_y, views='lateral'):\n # create binary mask\n mask = np.zeros(img_slice.shape)\n mask[min_x:max_x, min_y:max_y] = 1\n # keep a copy of original to have background later \n img_orig = np.copy(img_slice)\n mask_binary = np.copy(mask)\n\n # rotate image if coronal\n if views=='coronal':\n img_slice = np.rot90(img_slice, axes=(1, 0)) # image is from lat,ax -> ax,lat\n mask_slice = np.rot90(mask_slice, axes=(1, 0))\n mask = np.rot90(mask, axes=(1, 0))\n \n # prepare binary mask for net\n mask = cv2.resize(mask, self.resize_size, interpolation=cv2.INTER_NEAREST)\n mask = torch.Tensor(mask) # gives dtype float32\n mask = mask.unsqueeze(0)\n mask = mask.unsqueeze(0)\n\n # prepare seg mask for net\n mask_slice[mask_slice==self.vertebra_id] = 0\n # resize to network size\n mask_seg = cv2.resize(mask_slice, self.resize_size, interpolation=cv2.INTER_NEAREST)\n mask_seg = np.uint8(np.round(mask_seg)) # just to be sure\n\n mask_seg = self.map_vert_to_class(mask_seg)\n mask_seg = torch.Tensor(mask_seg) # gives dtype float32\n mask_seg_one_hot = torch.nn.functional.one_hot(mask_seg.long(), num_classes=6)\n mask_seg_one_hot = mask_seg_one_hot.permute(2,0,1)\n mask_seg_one_hot = mask_seg_one_hot.unsqueeze(0)\n mask_seg = mask_seg.unsqueeze(0)\n mask_seg = mask_seg.unsqueeze(0)\n\n # prepare img for net \n img_slice = cv2.resize(img_slice, self.resize_size)\n img_slice = np.clip(img_slice, -1024, 3071) # clip to HU units\n img_slice = np.uint8(255*(img_slice+1024)/4095) # normalize to range 0-255 \n img_slice = img_slice[:,:, None]\n img_slice = self.toTensor(img_slice)\n img_slice = img_slice.unsqueeze(0)\n corrupt_img = (1-mask)*img_slice\n\n if self.use_cuda:\n mask = mask.cuda()\n mask_seg = mask_seg.cuda()\n corrupt_img = corrupt_img.cuda() \n\n # inpaint\n if views=='lateral':\n netG = self.netGlat\n elif views=='coronal':\n netG = self.netGcor\n\n # get prediction\n with torch.no_grad():\n _, inpainted_mask, inpainted_img = netG(corrupt_img, mask_seg, mask)\n inpainted_mask = self.softmax(inpainted_mask)\n\n #inpainted_mask = torch.argmax(inpainted_mask, dim=1)\n inpainted_img = inpainted_img * mask + corrupt_img * (1. - mask)\n inpainted_mask = inpainted_mask * mask + mask_seg_one_hot * (1. - mask)\n #inpainted_mask = self.map_class_to_vert(inpainted_mask)\n\n # set img back to how it was\n inpainted_img = inpainted_img.squeeze().detach().cpu().numpy()\n inpainted_img = (inpainted_img)*4095 - 1024 # normalize back to HU units \n inpainted_img = cv2.resize(inpainted_img, (self.orig_ax_length, self.orig_ax_length))\n # set mask back\n inpainted_mask = inpainted_mask.squeeze().detach().cpu().numpy()\n inpainted_mask_resized = np.zeros((6, self.orig_ax_length, self.orig_ax_length))\n for i in range(6):\n if views=='coronal':\n inpainted_mask_resized[i,:,:] = np.rot90(cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length))) #, interpolation=cv2.INTER_NEAREST)\n else:\n inpainted_mask_resized[i,:,:] = cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length)) #, interpolation=cv2.INTER_NEAREST)\n inpainted_mask = inpainted_mask_resized\n \n if views=='coronal':\n inpainted_img = np.rot90(inpainted_img) #, axes=(1, 0))\n\n return inpainted_img, inpainted_mask, mask_binary","def eline_mask(wave, lines, pad=None):\n isline = np.zeros(len(wave), dtype=bool)\n for w in lines:\n try:\n lo, hi = w\n except(TypeError):\n lo, hi = w-pad, w+pad\n isline = isline | ((wave > lo) & (wave < hi))\n\n return ~isline","def image_clip_to_segment_and_convert(image_ms_array, image_pan_array, mask_array, factor, image_height_size, \r\n image_width_size):\r\n \r\n img_pan_list = []\r\n img_ms_list = []\r\n mask_list = []\r\n \r\n n_bands = image_ms_array.shape[2]\r\n \r\n for i in range(0, image_pan_array.shape[0] - image_height_size, int(factor)):\r\n for j in range(0, image_pan_array.shape[1] - image_width_size, int(factor)):\r\n M_90 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 90, 1.0)\r\n M_180 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 180, 1.0)\r\n M_270 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 270, 1.0)\r\n \r\n img_original = image_pan_array[i : i + image_height_size, j : j + image_width_size, 0]\r\n img_rotate_90 = cv2.warpAffine(img_original, M_90, (image_height_size, image_width_size))\r\n img_rotate_180 = cv2.warpAffine(img_original, M_180, (image_width_size, image_height_size))\r\n img_rotate_270 = cv2.warpAffine(img_original, M_270, (image_height_size, image_width_size))\r\n img_flip_hor = cv2.flip(img_original, 0)\r\n img_flip_vert = cv2.flip(img_original, 1)\r\n img_flip_both = cv2.flip(img_original, -1)\r\n img_pan_list.extend([img_original, img_rotate_90, img_rotate_180, img_rotate_270, img_flip_hor, img_flip_vert, \r\n img_flip_both])\r\n mask_patch = mask_array[i : i + image_height_size, j : j + image_width_size, 0]\r\n label = mask_patch[int(image_height_size / 2), int(image_width_size / 2)]\r\n mask_list.extend([label] * 7)\r\n \r\n for i in range(0, int(image_ms_array.shape[0] - (image_height_size / factor)), 1):\r\n for j in range(0, int(image_ms_array.shape[1] - (image_width_size / factor)), 1):\r\n M_90_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 90, 1.0)\r\n M_180_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 180, 1.0)\r\n M_270_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 270, 1.0)\r\n \r\n img_original = image_ms_array[i : i + image_height_size, j : j + image_width_size, 0 : n_bands]\r\n img_rotate_90 = cv2.warpAffine(img_original, M_90_ms, (image_height_size, image_width_size))\r\n img_rotate_180 = cv2.warpAffine(img_original, M_180_ms, (image_width_size, image_height_size))\r\n img_rotate_270 = cv2.warpAffine(img_original, M_270_ms, (image_height_size, image_width_size))\r\n img_flip_hor = cv2.flip(img_original, 0)\r\n img_flip_vert = cv2.flip(img_original, 1)\r\n img_flip_both = cv2.flip(img_original, -1)\r\n img_ms_list.extend([img_original, img_rotate_90, img_rotate_180, img_rotate_270, img_flip_hor, img_flip_vert, \r\n img_flip_both])\r\n \r\n image_pan_segment_array = np.zeros((len(img_pan_list), image_height_size, image_width_size, image_pan_array.shape[2]))\r\n image_ms_segment_array = np.zeros((len(img_ms_list), int(image_height_size / factor), int(image_width_size / factor), \r\n image_ms_array.shape[2]))\r\n \r\n for index in range(len(img_pan_list)):\r\n image_pan_segment_array[index] = img_pan_list[index]\r\n image_ms_segment_array[index] = img_ms_list[index]\r\n \r\n mask_array = np.array(mask_list)\r\n \r\n return image_ms_segment_array, image_pan_segment_array, mask_array","def get_mask(self, image):\n mask = self.get_gradients(image)\n return mask","def get_arrow_mask(self, frame):\n # Adapte contrast and put in grayscale\n img = skimage.exposure.equalize_adapthist(frame)\n img = skimage.color.rgb2gray(img)\n # # apply Otsu thresholding method\n thres = skimage.filters.threshold_otsu(img)\n mask = np.where(img < skimage.filters.threshold_otsu(img), True, False)\n # Morphological cleaning\n mask = skimage.morphology.binary_opening(mask, skimage.morphology.disk(5))\n # Remove corners of room\n mask = skimage.segmentation.flood_fill(mask, (0,0), 0)\n mask = skimage.segmentation.flood_fill(mask, (0,mask.shape[1]-1), 0)\n mask = skimage.segmentation.flood_fill(mask, (mask.shape[0]-1,0), 0)\n mask = skimage.segmentation.flood_fill(mask, (mask.shape[0]-1,mask.shape[1]-1), 0)\n\n return mask","def data_assemble(self, x,y, r_cut, add_mask=5, pick_choice=False):\n #segmentation components\n obj_masks,center_mask_info, segments_deblend_list = self._seg_image(x, y, r_cut=r_cut)\n data_masks_center, _, xcenter, ycenter, c_index = center_mask_info\n image = self.cut_image(x,y,r_cut)\n self.raw_image = image\n src_mask = np.zeros_like(image)\n lens_mask = np.zeros_like(image)\n plu_mask = np.zeros_like(image)\n lenslight_mask_index = []\n if self.segmap is not None and self.interaction:\n segmap=self.segmap[0].data\n segdata = segmap[x - r_cut:x + r_cut + 1, y - r_cut:y + r_cut + 1]\n plt.imshow(segdata, origin='lower')\n nlabel = np.unique(segdata)\n for i in range(nlabel.shape[0] - 1):\n ax = (int((np.where(segdata == nlabel[i + 1])[0].max() - np.where(segdata == nlabel[i + 1])[0].min()) / 2 +\n np.where(segdata == nlabel[i + 1])[0].min()))\n ay = (int((np.where(segdata == nlabel[i + 1])[1].max() - np.where(segdata == nlabel[i + 1])[1].min()) / 3 +\n np.where(segdata == nlabel[i + 1])[1].min()))\n plt.text(ay, ax, repr(nlabel[i + 1]), color='r', fontsize=15)\n plt.title('Input segmentation map')\n plt.show()\n source_mask_index = [int(sidex) for sidex in input('Selection of data via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\n for i in source_mask_index:\n src_mask = src_mask + segdata*(segdata==i*1)\n # lens light\n lenslightyn = input('Hint: is there lens light? (y/n): ')\n if lenslightyn == 'y':\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\n for i in lenslight_mask_index:\n lens_mask = (lens_mask + segdata*(segdata==i*1))\n elif lenslightyn == 'n':\n lenslight_mask_index = []\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n # contamination\n pluyn = input('Hint: is there contamination? (y/n): ')\n if pluyn == 'y':\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\n for i in plution_mask_index:\n plu_mask = (plu_mask + segdata*(segdata==i*1))\n elif pluyn == 'n':\n plu_mask = np.zeros_like(image)\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n\n\n\n if self.segmap is None and self.interaction:\n self.plot_segmentation(image, segments_deblend_list, xcenter, ycenter, c_index)\n #source light\n if pick_choice:\n source_mask_index = [int(sidex) for sidex in input('Selection of data via segmentation index separated by space, e.g., 0 1 :').split()]\n for i in source_mask_index:\n src_mask = src_mask + obj_masks[i]\n #lens light\n lenslightyn = input('Hint: is there lens light? (y/n): ')\n if lenslightyn == 'y':\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via segmentation index separated by space, e.g., 0 1 :').split()]\n for i in lenslight_mask_index:\n lens_mask = (lens_mask + obj_masks[i])\n elif lenslightyn == 'n':\n lenslight_mask_index = []\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n # contamination\n pluyn = input('Hint: is there contamination? (y/n): ')\n if pluyn == 'y':\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via segmentation index separated by space, e.g., 0 1 :').split()]\n for i in plution_mask_index:\n plu_mask = (plu_mask + obj_masks[i])\n elif pluyn == 'n':\n plu_mask = np.zeros_like(image)\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n else:\n src_mask = data_masks_center\n\n\n #adding pixels around the selected masks\n selem = np.ones((add_mask, add_mask))\n src_mask = ndimage.binary_dilation(src_mask.astype(np.bool), selem)\n plu_mask_out = ndimage.binary_dilation(plu_mask.astype(np.bool), selem)\n plu_mask_out = (plu_mask_out - 1)*-1\n\n #select source region to fit, or to use whole observation to fit\n ##1.select source region to fit\n snr = self.snr\n source_mask = image * src_mask\n #create background image for picked\n if self.background_rms is None:\n _, _, std = sigma_clipped_stats(image, sigma=snr, mask=source_mask)\n tshape = image.shape\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\n else:\n tshape = image.shape\n std=np.mean(self.background_rms)\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\n\n no_source_mask = (src_mask * -1 + 1) * img_bkg\n picked_data = source_mask + no_source_mask\n\n ##2.use whole observation to fit while mask out the contamination\n maskedimg = image * plu_mask_out\n\n ##orginize the output 'kwargs_data'\n kwargs_data = {}\n if pick_choice:\n kwargs_data['image_data'] = picked_data#select source region to fit\n else:\n kwargs_data['image_data'] = maskedimg#use whole observation to fit while mask out the contamination\n\n if self.background_rms is None:\n kwargs_data['background_rms'] = std\n self.background_rms = std\n else:\n kwargs_data['background_rms'] = np.mean(self.background_rms)\n kwargs_data['exposure_time'] = self.exp_time\n kwargs_data['transform_pix2angle'] = np.array([[1, 0], [0, 1]]) * self.deltaPix\n ra_at_xy_0 = (y - r_cut) * self.deltaPix # (ra,dec) is (y_img,x_img)\n dec_at_xy_0 = (x - r_cut) * self.deltaPix\n kwargs_data['ra_at_xy_0'] = ra_at_xy_0\n kwargs_data['dec_at_xy_0'] = dec_at_xy_0\n\n #coordinate of the lens light\n xlenlight, ylenlight = [], []\n if lenslight_mask_index !=[]:\n for i in lenslight_mask_index:\n xlenlight.append(ra_at_xy_0 + int(xcenter[i]) * self.deltaPix )\n ylenlight.append(dec_at_xy_0 + int(ycenter[i])* self.deltaPix )\n\n #for output\n self.data = kwargs_data['image_data']\n self.kwargs_data = kwargs_data\n self.data_mask = src_mask\n self.lens_mask = lens_mask\n self.plu_mask = plu_mask_out\n self.obj_masks = obj_masks\n imageData = ImageData(**kwargs_data)\n self.imageData = imageData\n kwargs_seg = [segments_deblend_list, xcenter, ycenter, c_index]\n\n return kwargs_data, kwargs_seg, [xlenlight, ylenlight]","def avg_slope_intercept(image, lines):\n left_fit = []\n right_fit = []\n for line in lines:\n x1, y1, x2, y2 = line.reshape(4)\n # Fit first order function\n #params = np.polyfit((x1, y1), (x2, y2), 1)\n slope = (y2 - y1) / (x2 - x1)\n intercept = y1 - slope * x1\n if(slope < 0):\n left_fit.append((slope, intercept))\n cv2.line(image, (x1, y1), (x2, y2), (255, 0, 0), 2)\n else:\n right_fit.append((slope, intercept))\n cv2.line(image, (x1, y1), (x2, y2), (0, 255, 0), 2)\n\n if(DEBUG_IMAGES):\n cv2.imshow(\"Hough Lines\", image) \n\n left_fit_avg, right_fit_avg= [], []\n left_line, right_line = [], []\n if(len(left_fit) > 0):\n left_fit_avg = np.average(left_fit, axis=0)\n left_line = make_coordinates(image, left_fit_avg)\n if(len(right_fit) > 0):\n right_fit_avg = np.average(right_fit, axis=0)\n right_line = make_coordinates(image, right_fit_avg)\n\n \"\"\"\n left_line, right_line = [], []\n if(len(left_fit_avg) > 0):\n left_line = make_coordinates(image, left_fit_avg)\n if(len(right_fit_avg) > 0):\n right_line = make_coordinates(image, right_fit_avg)\n \"\"\"\n\n return np.array([left_line, right_line])","def __image_pipeline(self, img):\n \n ##### Lane finding pipeline #######\n resized = self.__resize_image(img)\n undistorted = self.__correct_distortion(resized)\n warped = self.__warp_image_to_biv(undistorted)\n thresholded = self.__threshold_image(warped)\n lines = self.__get_lane_lines(thresholded)\n lane_img = self.__draw_lane_lines(undistorted, thresholded, include_stats=True)\n\n\n ##### Vehicle Tracking pipeline #####\n\n hot_windows = self.windFinder.get_hot_windows(img)\n car_boxes, wrap_img = self.vTracker.image_pipeline(img, hot_windows,\n return_img=False) \n # img = cv2.addWeighted(img, 1, wrap_img, 0.5, 0)\n result = self.__draw_boxes(lane_img, car_boxes)\n\n return result","def make_lungmask(img, display=False):\n row_size= img.shape[0]\n col_size = img.shape[1]\n \n mean = np.mean(img)\n std = np.std(img)\n img = img-mean\n img = img/std\n\n # uses hounsfield values near lungs to normalize images\n\n middle = img[int(col_size/5):int(col_size/5*4),int(row_size/5):int(row_size/5*4)] \n mean = np.mean(middle) \n max = np.max(img)\n min = np.min(img)\n img[img==max]=mean\n img[img==min]=mean\n \n # uses kmeans to separate foreground (soft tissue / bone) and background (lung/air)\n\n kmeans = KMeans(n_clusters=2).fit(np.reshape(middle,[np.prod(middle.shape),1]))\n centers = sorted(kmeans.cluster_centers_.flatten())\n threshold = np.mean(centers)\n thresh_img = np.where(img<threshold,1.0,0.0)\n\n # performs erosion and dilation\n\n eroded = morphology.erosion(thresh_img,np.ones([3,3]))\n dilation = morphology.dilation(eroded,np.ones([8,8]))\n\n labels = measure.label(dilation) # Different labels are displayed in different colors\n label_vals = np.unique(labels)\n regions = measure.regionprops(labels)\n good_labels = []\n for prop in regions:\n B = prop.bbox\n if B[2]-B[0]<row_size/10*9 and B[3]-B[1]<col_size/10*9 and B[0]>row_size/5 and B[2]<col_size/5*4:\n good_labels.append(prop.label)\n mask = np.ndarray([row_size,col_size],dtype=np.int8)\n mask[:] = 0\n\n # makes mask\n\n for N in good_labels:\n mask = mask + np.where(labels==N,1,0)\n mask = morphology.dilation(mask,np.ones([10,10])) # one last dilation\n final = mask * img\n \n # shows and saves output\n\n plt.imshow(final)\n im = Image.fromarray(final*128)\n im = im.convert(\"L\")\n im.save(S)\n \n return","def normalization_mask(img, mask):\n zone1 = img[mask != 0]\n zone2 = img[mask == 0]\n zone1 = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\n zone2 = (zone2 - zone2.min()) / (zone2.max() - zone2.min())\n imge = img.copy()\n imge[mask != 0] = zone1\n imge[mask == 0] = zone2\n return imge","def draw_lane_lines(image, lines, color=[0, 0, 255], thickness=20):\n # Make a separate image to draw lines and combine with the orignal later\n line_image = np.zeros_like(image)\n if lines is not None:\n for line in lines:\n if(len(line) > 0):\n x1, y1, x2, y2 = line.reshape(4)\n cv2.line(line_image, (x1, y1), (x2, y2), color, thickness)\n return line_image","def lapsharp(image, maskret = False):\n #padded_image = np.pad(img, (1, 1), mode = 'symmetric')\n # lap is linear therefore;\n # lap f(x,y) = f(x + 1, y) + f(x - 1, y) + f(x, y + 1) + f(x, y - 1) - 4f(x,y)...\n #--------------------\n c = -1 # Depends on kernel\n # make zero kernal\n lapmask = np.zeros((3, 3))\n \n # add values to kernel\n lapmask[0,0] = 1\n lapmask[0,1] = 1\n lapmask[0,2] = 1\n\n lapmask[1,0] = 1\n lapmask[1,1] = -8\n lapmask[1,2] = 1\n\n lapmask[2,0] = 1\n lapmask[2,1] = 1\n lapmask[2,2] = 1\n #--------------------\n mask = convolve2d(image, lapmask, mode = 'same')\n result = image + c*mask\n\n # Map values to 0-255\n g1 = image - np.min(image)\n g = g1/np.max(g1) *255\n g = g.astype('uint8')\n\n if maskret == True:\n return g, mask\n else:\n return g.astype('uint8')","def getHitmask(self,image):\n\t\tmask = []\n\t\tfor x in range(image.get_width()):\n\t\t\tmask.append([])\n\t\t\tfor y in range(image.get_height()):\n\t\t\t\tmask[x].append(bool(image.get_at((x,y))[3]))\n\t\treturn mask","def apply_mask(self):\n for mask, param in self.masked_parameters:\n param.mul_(mask)","def lane_fill_poly(self, binary_warped,undist, inverse_perspective_transform, left_fit,right_fit):\r\n # Generate x and y values\r\n ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )\r\n left_fitx = self.get_val(ploty, left_fit)\r\n right_fitx = self.get_val(ploty, right_fit)\r\n \r\n # Create an image to draw the lines on\r\n warp_zero = np.zeros_like(binary_warped).astype(np.uint8)\r\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\r\n\r\n # Recast x and y for cv2.fillPoly()\r\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\r\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\r\n pts = np.hstack((pts_left, pts_right))\r\n\r\n # Draw the lane \r\n cv2.fillPoly(color_warp, np.int_([pts]), (255,255, 255))\r\n\r\n # Warp using inverse perspective transform\r\n newwarp = cv2.warpPerspective(color_warp, inverse_perspective_transform, (binary_warped.shape[1], binary_warped.shape[0])) \r\n # overlay\r\n #newwarp = cv.cvtColor(newwarp, cv.COLOR_BGR2RGB)\r\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\r\n \r\n return result","def road_lines():\n cv2.polylines(frame_1, [pts_1], True, yellow_color)\n cv2.polylines(frame_2, [pts_2], True, yellow_color)","def compute_mask(self, inputs, mask=None):\n return None","def get_mask(self, anno, img_info) -> np.ndarray:\n m = np.zeros((img_info[\"height\"], img_info[\"width\"]), dtype=np.float32)\n\n for obj in anno:\n if obj[\"iscrowd\"]:\n rle = pycocotools.mask.frPyObjects(obj[\"segmentation\"], img_info[\"height\"], img_info[\"width\"])\n mask = pycocotools.mask.decode(rle)\n if mask.shape != m.shape:\n logger.warning(f\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\")\n continue\n m += mask\n elif obj[\"num_keypoints\"] == 0:\n rles = pycocotools.mask.frPyObjects(obj[\"segmentation\"], img_info[\"height\"], img_info[\"width\"])\n for rle in rles:\n mask = pycocotools.mask.decode(rle)\n if mask.shape != m.shape:\n logger.warning(f\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\")\n continue\n\n m += mask\n\n return (m < 0.5).astype(np.float32)","def inflate_mask(mask):\n kernel = np.ones((12, 12), np.uint8)\n return cv2.dilate(mask, kernel, 1)","def find_tfl_lights(image: np.ndarray):\n kernel = np.array(\n [[0, 0, 0],\n [0, 0, 0],\n [0, 1, 0],\n [1, 3, 1],\n [0, 1, 0]])\n\n kernel = kernel - kernel.mean()\n\n red_image = image.copy()\n red_image = red_image[:, :, 0]\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(red_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n red_points = np.where(mask)\n positions = []\n final_red_points = []\n for point1 in range(len(red_points[0])):\n point = (red_points[0][point1], red_points[1][point1])\n pixel = image[point[0], point[1]]\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\n final_red_points.append(point)\n final_red_points = filter_points(final_red_points)\n positions += final_red_points\n auxilary = ['r'] * len(positions)\n red_x = [val[1] for val in final_red_points]\n red_y = [val[0] for val in final_red_points]\n green_image = image.copy()\n green_image = green_image[:, :, 1]\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(green_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n green_points = np.where(mask)\n final_green_points = []\n for point1 in range(len(green_points[0])):\n point = (green_points[0][point1], green_points[1][point1])\n pixel = image[point[0], point[1]]\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\n final_green_points.append(point)\n\n final_green_points = filter_points(final_green_points)\n positions += final_green_points\n auxilary += ['g'] * len(final_green_points)\n green_x = [val[1] for val in final_green_points]\n green_y = [val[0] for val in final_green_points]\n print(f\"There are {len(green_x) + len(red_x)} points\")\n return positions, auxilary","def __init__(self, roi_warped_points):\n\n # was the line detected in the last iteration?\n self.detected = False\n # x values of the last n fits of the line\n self.recent_xfitted = []\n #average x values of the fitted line over the last n iterations\n self.bestx = None\n #polynomial coefficients averaged over the last n iterations\n self.best_fit = [np.array([False])]\n #polinomial coefficients for the last n fits of the lane\n self.recent_fit = []\n #polynomial coefficients for the most recent fit\n self.current_fit = [np.array([False])]\n #radius of curvature of the line in some units\n self.radius_of_curvature = 0\n #distance in meters of vehicle center from the line\n self.line_base_pos = 0\n #difference in fit coefficients between last and new fits\n self.diffs = np.array([0,0,0], dtype='float')\n #x values for detected line pixels\n self.allx = None\n #maximum number of iterations to average\n self.max_n = 10 #25\n\n # roi image points in bird's view space\n self.roi_warped_points = roi_warped_points\n\n #y values for detected line pixels\n self.ally = np.linspace(0, self.roi_warped_points[2][1] - 1, self.roi_warped_points[2][1])\n\n # line base pos is calculated through the roi information\n # the used four point ROI has two points at the bottom that are straight\n # with respect to the bottom - as this points are right next to the lines,\n # they can be translated from pixels into meters with the knowledge of\n # a U.S. highway standard lane - this is an apprximation, but should be\n # good enough for this project\n # U.S. regulations minimum lane width: 3.7m\n self.xm_per_pix = 3.7 / (self.roi_warped_points[1][0] - self.roi_warped_points[0][0])\n\n # each dashed line is 3m long --> about 33m for warped image\n self.ym_per_pix = 33 / (self.roi_warped_points[2][1] - self.roi_warped_points[0][1])","def test_generate_lane_mask(self):\r\n\r\n sample_alignment = \"\"\">1\r\n .ATC-G\r\n >2\r\n .AACCG\r\n >3\r\n .ATC-G\r\n >4\r\n .AAC-G\"\"\".split('\\n')\r\n\r\n entropy_threshold = 0.70\r\n\r\n expected_lanemask = \"110101\"\r\n\r\n actual_lanemask = generate_lane_mask(sample_alignment,\r\n entropy_threshold)\r\n\r\n self.assertEqual(actual_lanemask, expected_lanemask)","def show_mask(image, mask): \n plt.subplot(1,2,1)\n plt.title('image')\n plt.imshow(image)\n plt.subplot(1,2,2)\n plt.title('mask')\n plt.imshow(mask)\n plt.show()","def __mask(input, mask):\n return cv2.bitwise_and(input, input, mask=mask)","def pipeline(image):\n # undistort image\n undistorted_image = undistort_image(image)\n superimposed_image = find_lanes(undistorted_image)\n labels = find_vehicles(undistorted_image)\n\n draw_img = draw_labeled_bboxes(superimposed_image, labels)\n\n \n return draw_img","def overlay(image, mask):\n if len(image.shape) == 3:\n image = image[:, :, 0]\n if len(mask.shape) == 3:\n mask = mask[:, :, 0]\n if np.amax(image) > 100:\n image = image / 255\n\n masked = np.ma.masked_where(mask == 0, mask)\n\n plt.figure()\n plt.subplot(1, 2, 1)\n plt.imshow(image, 'gray', interpolation='nearest')\n plt.subplot(1, 2, 2)\n plt.imshow(image, 'gray', interpolation='nearest')\n plt.imshow(masked, 'jet', interpolation='nearest', alpha=0.5)\n plt.show()","def _draw_mask_on_image(self, mask):\n mask = self.STANDARD_COLORS_ARRAY[mask]\n cv2.addWeighted(mask,self.config.ALPHA,self.image,1.0,0,self.image)","def draw_mask(self, image, ship, dims):\n # Get the center x, y and the size s\n x, y, s, r, m = dims\n\n #Load files\n if ship == 'cruiseship':\n ma_path = 'ships/cruiseship_isolated_mask.png'\n id = 1\n elif ship == 'tanker':\n ma_path = 'ships/tanker_isolated_mask.png'\n id = 2\n\n #Transforming mask\n mask = cv2.imread(ma_path)\n mask_transformed = self.transform(mask.copy(), dims)\n mask_shape = np.shape(mask_transformed)\n s_x = int((mask_shape[0]+0.5)//2)\n s_y = int((mask_shape[1]+0.5)//2)\n mask_transformed = mask_transformed[0:np.shape(image[x-s_x:x+s_x, y-s_y:y+s_y, :])[0],\n 0:np.shape(image[x-s_x:x+s_x, y-s_y:y+s_y, :])[1],\n :]\n\n mask_transformed_th = self.threshold(mask_transformed)\n\n #Adding mask to image\n image[x-s_x:x+s_x, y-s_y:y+s_y, :] = id/255*mask_transformed_th\n\n return image","def load_mask_one_layer(self, image_id):\r\n mask_path = self.mask_path[self.ids[image_id]]\r\n file_pattern = os.path.join(mask_path, \"*.png\")\r\n info = self.image_info[image_id]\r\n mask_files = glob.glob(file_pattern)\r\n #mask_tmp = cv2.imread(mask_files[0])\r\n mask_new = np.zeros([info['width'], info['height'], mask_files.__len__()+1], dtype=np.uint8) # one more for background\r\n count = 1\r\n mask_total = 0\r\n for i in mask_files:\r\n mask = cv2.imread(i)\r\n mask = mask[:, :, 1] / 255.0\r\n #mask = ski_transform.resize(mask, (info['height'], info['width']), mode='reflect')\r\n mask_new[:, :, count] = (mask)\r\n mask_total = mask_total * (mask == 0)\r\n mask_total = mask_total + (mask>0) * count\r\n count = count + 1\r\n return mask_total","def load_mask(self, image_id):\n image_info = self.image_info[image_id]\n if image_info[\"source\"] != \"face\":\n return super(self.__class__, self).load_mask(image_id)\n info = self.image_info[image_id]\n mask = np.zeros([info['height'], info['width'], len(info['boundingbox'])], dtype=np.uint8)\n for i, p in enumerate(info['boundingbox'].values()):\n rr, cc = skimage.draw.polygon(p['y'], p['x'])\n mask[rr, cc, i] = 1\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)","def getHitmask(image):\n mask = []\n for x in range(image.get_width()):\n mask.append([])\n for y in range(image.get_height()):\n mask[x].append(bool(image.get_at((x,y))[3]))\n return mask","def getHitmask(image):\n mask = []\n for x in range(image.get_width()):\n mask.append([])\n for y in range(image.get_height()):\n mask[x].append(bool(image.get_at((x,y))[3]))\n return mask","def getHitmask(image):\n mask = []\n for x in range(image.get_width()):\n mask.append([])\n for y in range(image.get_height()):\n mask[x].append(bool(image.get_at((x,y))[3]))\n return mask","def makeMask( Tables, Mode ):\n\n # get data from the corresponding tables\n ElasticModulusData = Tables[ \"ElasticModulus\" ].getRawData( )\n ShearModulusData = Tables[ \"ShearModulus\" ].getRawData( )\n PoissonRatiosData = Tables[ \"PoissonRatios\" ].getRawData( )\n MaterialPropertiesData = Tables[ \"MaterialProperties\" ].getRawData( )\n GeometryPropertiesData = Tables[ \"GeometryProperties\" ].getRawData( )\n\n\n Tables[ \"MaterialProperties\" ].setBufferData( \"General\", MaterialPropertiesData )\n\n Tables[ \"GeometryProperties\" ].setBufferData( \"General\", GeometryPropertiesData )\n\n\n if Mode == 0:\n\n Tables[ \"ElasticModulus\" ].setBufferData( \"GeneralOrthotropic\",\n ElasticModulusData )\n\n Tables[ \"ShearModulus\" ].setBufferData( \"GeneralOrthotropic\",\n ShearModulusData )\n\n Tables[ \"PoissonRatios\" ].setBufferData( \"GeneralOrthotropic\",\n PoissonRatiosData )\n\n\n elif Mode == 1:\n\n Tables[ \"ElasticModulus\" ].setBufferData( \"GeneralIsotropic\",\n ElasticModulusData )\n\n Tables[ \"ShearModulus\" ].setBufferData( \"GeneralIsotropic\",\n ShearModulusData )\n\n Tables[ \"PoissonRatios\" ].setBufferData( \"GeneralIsotropic\",\n PoissonRatiosData )","def GetMaskImage(self) -> \"itkImageUS2 const *\":\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIUS2_GetMaskImage(self)","def outline_to_mask(line, x, y):\n mpath = mplp.Path(line)\n X, Y = np.meshgrid(x, y)\n points = np.array((X.flatten(), Y.flatten())).T\n mask = mpath.contains_points(points).reshape(X.shape)\n return mask","def route_bitlines(self):\n # adds the BL on metal 2\n offset = vector(self.bitcell.get_pin(self.bitcell_bl).cx(),0) - vector(0.5 * self.m2_width,0)\n self.add_layout_pin(text=\"bl\",\n layer=\"metal2\",\n offset=offset,\n width=drc['minwidth_metal2'],\n height=self.height)\n\n # adds the BR on metal 2\n offset = vector(self.bitcell.get_pin(self.bitcell_br).cx(),0) - vector(0.5 * self.m2_width,0)\n self.add_layout_pin(text=\"br\",\n layer=\"metal2\",\n offset=offset,\n width=drc['minwidth_metal2'],\n height=self.height)","def edges(i):\n Oxy = i.copy()\n Kx = [-1, 0, 1, -2, 0, 2, -1, 0, 1]\n Ky = [-1, -2, -1, 0, 0, 0, 1, 2, 1]\n\n Ox = correlate(i, Kx)\n Oy = correlate(i,Ky)\n\n Oxy[\"pixels\"] = [ (x**2 + y**2)**(1/2) for x, y in zip(Ox[\"pixels\"], Oy[\"pixels\"])]\n\n result = round_and_clip_image(Oxy)\n return result"],"string":"[\n \"def calcmask(self, *args, **kwargs):\\n return _image.image_calcmask(self, *args, **kwargs)\",\n \"def set_lanes(left_lines, right_lines, image):\\n \\n Y_LANE_EXTRAP = 35 # percent up from bottom of image to extrapolate lane lines\\n \\n image_wk = np.copy(image) # working copy\\n image_lines = np.copy(image_wk)*0 # create a blank to draw lines on\\n im_y = image_wk.shape[0]\\n \\n y1_lane = im_y\\n y2_lane = np.int32(im_y - (Y_LANE_EXTRAP/100*im_y))\\n \\n # Process left lane\\n if left_lines:\\n z_left = my_linear_polyfit(left_lines)\\n x1_lane = np.int32( (y1_lane - z_left[1]) / z_left[0] ) # x = (y-b)/m\\n x2_lane = np.int32( (y2_lane - z_left[1]) / z_left[0] )\\n \\n # Draw left lane on blank image\\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\\n \\n # Process right lane\\n if right_lines:\\n z_right = my_linear_polyfit(right_lines)\\n x1_lane = np.int32( (y1_lane - z_right[1]) / z_right[0] ) # x = (y-b)/m\\n x2_lane = np.int32( (y2_lane - z_right[1]) / z_right[0] )\\n \\n # Draw right lane on blank image\\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\\n \\n # Overlay detected left/right lanes on road image\\n image_wk = weighted_img(image_lines, image_wk)\\n \\n # Output road image with overlaid left/right lanes\\n return image_wk\",\n \"def mask(self):\",\n \"def get_mask(self, img):\\n raise NotImplementedError()\",\n \"def lane(self, mask, win_color = None):\\n\\n # the nonzero point\\n solid = np.nonzero(mask)\\n sx, sy = solid[1], solid[0]\\n\\n # make a image to draw on\\n out_img = np.dstack([np.zeros_like(mask)]*3)*255\\n if self.fit is None:\\n # get the intial poly line for window sliding\\n\\n # get the midpoint for both line, expecting it shows up in the lower half\\n self.h, self.w = mask.shape\\n self.midpoint = self.w//2\\n self.win_height = self.h//self.nb_win\\n\\n curv_head = self.h//self.frac\\n histogram = np.sum(mask[:curv_head, :], axis = 0)\\n mid_l = np.argmax(histogram[:self.midpoint])\\n mid_r = np.argmax(histogram[self.midpoint:]) + self.midpoint\\n\\n # the indice for solid pixel in left and right\\n l_lane_idc = []\\n r_lane_idc = []\\n\\n # slide the windows down up\\n btm = self.h\\n for n in range(self.nb_win):\\n # right window\\n ul_l = (mid_l - self.half, btm - self.win_height)\\n lr_l = (mid_l + self.half, btm)\\n\\n # left window\\n ul_r = (mid_r - self.half, btm - self.win_height)\\n lr_r = (mid_r + self.half, btm)\\n\\n\\n # draw the retangle on the image\\n if win_color:\\n cv2.rectangle(out_img, lr_l, ul_l, win_color, 2)\\n cv2.rectangle(out_img, lr_r, ul_r, win_color, 2)\\n\\n\\n # the indice within window\\n within_l = ((sx>=ul_l[0]) & \\\\\\n (sx<=lr_l[0]) & \\\\\\n (sy>=ul_l[1]) & \\\\\\n (sy<=lr_l[1])).nonzero()[0]\\n\\n within_r = ((sx>=ul_r[0]) & \\\\\\n (sx<=lr_r[0]) & \\\\\\n (sy>=ul_r[1]) & \\\\\\n (sy<=lr_r[1])).nonzero()[0]\\n\\n # append to the lane\\n l_lane_idc.append(within_l)\\n r_lane_idc.append(within_r)\\n\\n if len(within_r) > self.minpix:\\n mid_r = np.int(np.mean(sx[within_r]))\\n if len(within_l) > self.minpix:\\n mid_l = np.int(np.mean(sx[within_l]))\\n btm -= self.win_height\\n\\n # concatenate the windows\\n l_lane_idc = np.concatenate(l_lane_idc)\\n r_lane_idc = np.concatenate(r_lane_idc)\\n try:\\n self.fit = [np.polyfit(sy[l_lane_idc], sx[l_lane_idc], 2),\\n np.polyfit(sy[r_lane_idc], sx[r_lane_idc], 2)]\\n except:\\n return out_img\\n\\n\\n else:\\n # if we've fitted the lane, use that as guide\\n l_fit, r_fit = self.fit\\n l_lane_idc = ((sx >= np.polyval(l_fit, sy) - self.half) &\\n (sx <= np.polyval(l_fit, sy) + self.half)).nonzero()[0]\\n r_lane_idc = ((sx >= np.polyval(r_fit, sy) - self.half) &\\n (sx <= np.polyval(r_fit, sy) + self.half)).nonzero()[0]\\n\\n\\n curv_head = self.h//self.frac\\n l_curv_count = np.sum((sy >= curv_head) & (sx <= self.midpoint))\\n r_curv_count = np.sum((sy >= curv_head) & (sx >= self.midpoint))\\n\\n if l_curv_count >= self.curv_count:\\n try: self.fit[0] = np.polyfit(sy[l_lane_idc], sx[l_lane_idc], 2)\\n except: pass\\n if r_curv_count >= self.curv_count:\\n try: self.fit[1] = np.polyfit(sy[r_lane_idc], sx[r_lane_idc], 2)\\n except: pass\\n\\n # draw the lane area\\n l_fit, r_fit = self.fit\\n y_cord = np.linspace(0, self.h - 1, self.h)\\n lane_l = np.polyval(l_fit, y_cord)\\n lane_r = np.polyval(r_fit, y_cord)\\n\\n\\n if not win_color:\\n pts_l = np.array([np.vstack([lane_l, y_cord]).T])\\n pts_r = np.array([np.flipud(np.vstack([lane_r, y_cord]).T)])\\n\\n pts = np.hstack((pts_l, pts_r))\\n cv2.fillPoly(out_img, np.int_(pts), [0, 100, 0])\\n\\n # draw red on left\\n out_img[sy[l_lane_idc], sx[l_lane_idc]] = RED\\n # draw blue on right\\n out_img[sy[r_lane_idc], sx[r_lane_idc]] = BLUE\\n\\n\\n # put text showing meters away center and radius\\n l_btm = np.polyval(l_fit, self.h)\\n r_btm = np.polyval(r_fit, self.h)\\n mpp = self.lane_width/(r_btm - l_btm) # meters per pixel\\n\\n mid_lane = int((r_btm + l_btm)/2)\\n dev = (self.midpoint - mid_lane)\\n radius = np.mean(self.curvature(mpp))\\n\\n side = ''\\n side = 'L' if dev < 0 else 'R'\\n dev_text = (\\\"%.2fm %s\\\"%(np.abs(mpp*dev), side))\\n radius_text = (\\\"RADIUS %.2fm\\\"%(radius)) if radius < 2000 else 'STRAIGHT'\\n\\n (dev_w, dev_h), _ = cv2.getTextSize(dev_text,\\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\\n fontScale = 1, thickness = 2)\\n\\n (radius_w, radius_h), _ = cv2.getTextSize(radius_text,\\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\\n fontScale = 1, thickness = 3)\\n\\n\\n dev_org = (int(mid_lane + 2*dev - dev_w//2), self.h - 30)\\n radius_org = (int(mid_lane - radius_w//2), self.h - 80)\\n\\n\\n\\n cv2.line(out_img, (mid_lane, self.h - 20),\\n (mid_lane, self.h - 40 - dev_h),\\n color = [255,255,255], thickness = 3)\\n\\n cv2.putText(out_img, radius_text,\\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\\n fontScale = 1, thickness = 3,\\n org = radius_org, color = [0, 0, 0])\\n\\n cv2.putText(out_img, dev_text,\\n fontFace = cv2.FONT_HERSHEY_SIMPLEX,\\n fontScale = 1, thickness = 2,\\n org = dev_org, color = [0, 0, 0])\\n\\n return out_img\",\n \"def mask(self):\\n mask = np.zeros((self.height, self.width))\\n pts = [\\n np.array(anno).reshape(-1, 2).round().astype(int)\\n for anno in self.segmentation\\n ]\\n mask = cv2.fillPoly(mask, pts, 1)\\n return mask\",\n \"def mask_image(image):\\n pass\",\n \"def _generate_mask(self):\\r\\n mask = np.zeros((self.width, self.height), np.uint8)\\r\\n size = int((self.width + self.height) * 0.01)\\r\\n if self.width < 32 or self.height < 32:\\r\\n raise Exception(\\\"Width and Height of mask must be at least 64!\\\")\\r\\n for _ in range(randint(1,int(0.5*self.width))):\\r\\n x1 = randint(0, self.width-1)\\r\\n thickness = 1\\r\\n cv2.line(mask, (0, x1),(self.height-1, x1), 1, thickness)\\r\\n return 1 - mask\",\n \"def createMasks(inputFolderName=\\\"Masks_From_VolumeTracing\\\", outputFolderName=\\\"Masks_From_VolumeTracing_Lines_From_VolumeTracing\\\"):\\n\\n root, df = loader.dataModules()\\n\\n PATH_TO_RAW_FRAMES_PARENT_DIR = os.path.join(root, inputFolderName) # frames path\\n PATH_TO_OUTPUT_DIR = os.path.join(root, outputFolderName) # frames path\\n \\n os.makedirs(PATH_TO_OUTPUT_DIR, exist_ok=True) # creates ground truth mask parent directory\\n\\n print(\\\"Drawing lines on each mask from VolumeTracings\\\")\\n for i in tqdm(range(len(df))): # iterates through each row of data frame\\n videoName = df.iloc[i, 0] # name of video\\n frameNumber = df.iloc[i, 1] # timing for clip\\n\\n frameName = videoName + \\\".avi_\\\" + str(frameNumber) + \\\".png\\\" # concatenate video name with frame number as file name\\n PATH_TO_RAW_FRAME = os.path.join(PATH_TO_RAW_FRAMES_PARENT_DIR, frameName)\\n PATH_TO_OUTPUT_RAW_FRAME = os.path.join(PATH_TO_OUTPUT_DIR, frameName)\\n\\n image = cv2.imread(\\\"/Users/ishan/Downloads/Untraced.png\\\") # read in the image from the specified frame path\\n if os.path.exists(PATH_TO_RAW_FRAME) and videoName == \\\"0X16A6CEDE7F61E211\\\" and int(frameNumber) == 131: # checks if frame exists\\n x1 = list(literal_eval(df.iloc[i, 2])) # x1 coords\\n y1 = list(literal_eval(df.iloc[i, 3])) # y1 coords\\n x2 = list(literal_eval(df.iloc[i, 4])) # x2 coords\\n y2 = list(literal_eval(df.iloc[i, 5])) # y2 coords\\n\\n for coord in range(len(x1)): # iterate through each coordinate\\n if coord is 0: # gets the perpendicular/long line\\n longLine1stCoords = (int(x1[coord]), int(y1[coord]))\\n longLine2ndCoords = (int(x2[coord]), int(y2[coord]))\\n else: # draws the parallel lines\\n cv2.line(image, (int(x1[coord]), int(y1[coord])), (int(x2[coord]), int(y2[coord])), (255, 255, 255), 1)\\n \\n cv2.line(image, longLine1stCoords, longLine2ndCoords, (255, 255, 255), 1) # Drawing the perpendicular/long line in different color\\n\\n cv2.imwrite(\\\"/Users/ishan/Downloads/Traced.png\\\", image)\",\n \"def my_lane_detection_pipeline(image, debug_images=False):\\n\\n # Step 1 - Filter and enhance image by lane color\\n image_s1 = filter_lane_color(image)\\n \\n # Step 2 - Canny edge detection with Gaussian blur and region mask\\n image_s2 = detect_lane_edges(image_s1)\\n \\n # Step 3 - Raw line detection by Hough transform and classify left/right by angle\\n (image_s3, left_lines, right_lines) = detect_lane_lines(image_s2, image)\\n \\n # Step 4 - Set left/right lanes by weighted linear polyfit of raw lines\\n image_s4 = set_lanes(left_lines, right_lines, image_s3)\\n \\n # Save images of each step for debugging and documentation\\n if debug_images:\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s0.jpg'), image)\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s1.jpg'), image_s1, cmap = 'gray')\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s2.jpg'), image_s2)\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s3.jpg'), image_s3)\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s4.jpg'), image_s4)\\n \\n # Output image with overlaid raw lane lines and detected left/right lanes\\n return image_s4\",\n \"def apply_lane_mask(fastalines, lane_mask, verbose=False):\\r\\n return apply_lane_mask_and_gap_filter(fastalines, lane_mask,\\r\\n allowed_gap_frac=1, verbose=False)\",\n \"def pipeline(self,img,debug=0):\\n\\t\\timg = self.cam.undist(img)\\n\\t\\t#get warped binary image\\n\\t\\tbinary_warped = self.cam.warp(Image(img).binary_th())\\n\\t\\tbw_shape = binary_warped.shape\\n\\t\\t\\n\\t\\tif (self.leftLine.detected == True and self.rightLine.detected == True):\\n\\t\\t\\tself.quick_search(binary_warped,debug)\\n\\t\\telse:\\n\\t\\t\\tself.blind_search(binary_warped,debug)\\n\\t\\n\\t\\tif (self.leftLine.fit!=None and self.rightLine.fit!=None):\\n\\t\\t\\tpolygon = self.fill_lane(bw_shape)\\n\\t\\t\\tunwarped_polygon = self.cam.unwarp(polygon)\\n\\t\\t\\t# calculate position of lane's center \\n\\t\\t\\ttemp = np.nonzero(unwarped_polygon[-1,:,1])[0]\\n\\t\\t\\tleft, right = temp[0], temp[-1]\\n\\t\\t\\tself.center = (int(bw_shape[1]/2) - (int((right-left)/2)+int(left)))*7.4/1280\\n\\t\\t\\timg_lines = weighted_img(unwarped_polygon,img, α=1, β=0.5, λ=0.)\\n\\t\\t\\t# write text on image\\n\\t\\t\\tfont = cv2.FONT_HERSHEY_SIMPLEX\\n\\t\\t\\ttext1 = 'Radius of Curvature: {:.0f}m'.format(np.mean((self.leftLine.radius, self.rightLine.radius)))\\n\\t\\t\\ttext2 = 'Distance is {:.2f}m {} of center'.format(abs(self.center), 'left' if self.center<0 else 'right')\\n\\n\\t\\t\\tcv2.putText(img_lines, text1, (100,100), font, 1,(255,255,255),2)\\n\\t\\t\\tcv2.putText(img_lines, text2 ,(100,140), font, 1,(255,255,255),2)\\n\\t\\t\\t\\n\\t\\t\\tif (debug==1):\\n\\t\\t\\t\\tshow_2gr(polygon, unwarped_polygon)\\n\\t\\t\\t\\tshow_2gr(binary_warped, unwarped_polygon)\\n\\n\\t\\t\\treturn img_lines\\n\\n\\t\\telse:\\n\\t\\t\\t# no lines detected and not fit available: return original image\\n\\t\\t\\t# without lines\\n\\t\\t\\treturn img\",\n \"def apply_lane_mask(fastalines, lane_mask, verbose=False):\\n return apply_lane_mask_and_gap_filter(fastalines, lane_mask,\\\\\\n allowed_gap_frac=1, verbose=False)\",\n \"def fix_generate_mask(self):\\r\\n mask = np.zeros((self.width, self.height), np.uint8)\\r\\n size = int((self.width + self.height) * 0.01)\\r\\n if self.width < 32 or self.height < 32:\\r\\n raise Exception(\\\"Width and Height of mask must be at least 64!\\\")\\r\\n i = 0\\r\\n for _ in range(1, int(0.3 * self.width)):\\r\\n index_xline = random.sample(range(0, self.width), int(0.5 * self.width))\\r\\n x1 = index_xline[i]\\r\\n i += 1\\r\\n thickness = 1\\r\\n cv2.line(mask, (0, x1), (self.height - 1, x1), 1, thickness)\\r\\n\\r\\n return 1 - mask\",\n \"def mark_lane_lines(undist, warped, ploty, left_fitx, right_fitx, Minv):\\n # Create an image to draw the lines on\\n warp_zero = np.zeros_like(warped).astype(np.uint8)\\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\\n\\n # Recast the x and y points into usable format for cv2.fillPoly()\\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\\n pts = np.hstack((pts_left, pts_right))\\n\\n # Draw the lane onto the warped blank image\\n cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))\\n\\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\\n newwarp = cv2.warpPerspective(color_warp, Minv, (warped.shape[1], warped.shape[0])) \\n # Combine the result with the original image\\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\\n return result\",\n \"def Mask(self) -> int:\",\n \"def draw_lines(img, lines, color=[0, 0, 255], thickness=10):\\n \\n yFinal = 540 # tweak these values as per the frame size\\n yIni = 350\\n xPlus = []\\n yPlus = []\\n xMinus = []\\n yMinus= []\\n slope_range = 0.2\\n\\n if lines is not None:\\n for line in lines:\\n if line is not None:\\n for x1,y1,x2,y2 in line:\\n # check slope \\n slope = (y2-y1)/(x2-x1)\\n\\t\\t \\n \\t\\t # Collect all points with + ve slope (right lane)\\n if (slope > slope_range):\\n xPlus.append(x1)\\n xPlus.append(x2)\\n yPlus.append(y1)\\n yPlus.append(y2)\\n\\n # Collect all points with - ve slope (left lane)\\n elif ((slope) < (-slope_range)):\\n xMinus.append(x1)\\n xMinus.append(x2)\\n yMinus.append(y1)\\n yMinus.append(y2)\\n # If out of range, lists defined in beginning of this function will be empty \\n else:\\n continue\\n \\n # draw right lane\\n x1,y1,x2,y2 = fit_line(xPlus, yPlus, yIni, yFinal)\\n cv2.line(img,(x1,y1),(x2,y2),color, thickness) \\n\\n # draw left lane\\n x1,y1,x2,y2 = fit_line(xMinus, yMinus, yIni, yFinal)\\n cv2.line(img,(x1,y1),(x2,y2),color,thickness)\",\n \"def detect_lane_lines(image_edges, image_orig):\\n \\n HOUGH_RHO = 1 # distance resolution in pixels of the Hough grid\\n HOUGH_THETA = np.pi/180 # angular resolution in radians of the Hough grid\\n HOUGH_THRESH = 15 # minimum number of votes (intersections in Hough grid cell) <15,20>\\n HOUGH_MIN_LEN = 40 # minimum number of pixels making up a line <40,100>\\n HOUGH_MAX_GAP = 100 # maximum gap in pixels between connectable line segments <100,250>\\n \\n LINE_MIN_ANGLE = 20 # degrees\\n \\n image_wk = np.copy(image_orig) # working copy\\n \\n # Run Hough transform on edge-detected image\\n raw_lines = cv2.HoughLinesP(image_edges, HOUGH_RHO, HOUGH_THETA, HOUGH_THRESH, np.array([]),\\n HOUGH_MIN_LEN, HOUGH_MAX_GAP)\\n \\n # Group lines by left/right angle and side of center line\\n left_lines = []\\n right_lines = []\\n x_center = np.int32((image_wk.shape[1]/2))\\n for line in raw_lines:\\n for x1, y1, x2, y2 in line:\\n theta = np.arctan((y2-y1)/(x2-x1)) /np.pi*180\\n \\n if (theta < -LINE_MIN_ANGLE) and (x1 < x_center) and (x2 < x_center):\\n left_lines.append(line)\\n \\n elif (theta > LINE_MIN_ANGLE) and (x1 > x_center) and (x2 > x_center):\\n right_lines.append(line)\\n \\n # Draw raw left/right lines on road image\\n draw_lines(image_wk, left_lines, (255,0,255), 2)\\n draw_lines(image_wk, right_lines, (0,255,0), 2)\\n \\n # Output road image with drawn raw lines and lists of left/right line coordinates\\n return (image_wk, left_lines, right_lines)\",\n \"def slope_lines(self,image):\\r\\n img_copy = image.copy()\\r\\n \\r\\n left_lines,right_lines=self.makeLeftRightline()\\r\\n left_line = np.mean(left_lines, axis=0)\\r\\n right_line = np.mean(right_lines, axis=0)\\r\\n\\r\\n poly_vertices = []\\r\\n order = [0,1,3,2]\\r\\n\\r\\n for slope, intercept in [left_line, right_line]:\\r\\n #getting height of image in y1\\r\\n rows, cols = image.shape[:2]\\r\\n y1= int(rows) \\r\\n #taking y2 upto 68% of y1\\r\\n y2= int(rows*0.68) \\r\\n #y=mx +c can be written as x=(y-c)/m\\r\\n x1=int((y1-intercept)/slope)\\r\\n x2=int((y2-intercept)/slope)\\r\\n poly_vertices.append((x1, y1))\\r\\n poly_vertices.append((x2, y2))\\r\\n\\r\\n # DRAWING LINES AND PATH ON THE IMAGE\\r\\n thickness_of_line=9\\r\\n color_of_line=[20, 255, 20]\\r\\n lines=np.array([[[x1,y1,x2,y2]]])\\r\\n for i in lines:\\r\\n for x1,y1,x2,y2 in i:\\r\\n cv2.line(img_copy, (x1, y1), (x2, y2), color_of_line, thickness_of_line)\\r\\n poly_vertices = [poly_vertices[i] for i in order]\\r\\n #filling polygon color\\r\\n cv2.fillPoly(img_copy, pts = np.array([poly_vertices],'int32'), color = (200,20,20))\\r\\n final_out=cv2.addWeighted(image,0.7,img_copy,0.4,0.)\\r\\n return final_out\",\n \"def filterBankPatch(img, width=5):\\n half = width / 2 # e.g. for 5, it's 2\\n imgE = Views.extendBorder(img)\\n ops = [offset(imgE, [x, y]) for x in xrange(-half, half + 1) for y in xrange(-half, half + 1)]\\n return ops\",\n \"def apply(self, image):\\n\\n bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\\n\\n # Convert to float image\\n float_im = bgr.copy().astype('float32') / 255\\n blurred = cv2.GaussianBlur(float_im, ksize=(9, 9), sigmaX=1, sigmaY=9)\\n cplanes = colors.bgr2cpaces(blurred)\\n lanes, py, pw = finder.find_lane_pixels(cplanes, self.pfilter, gamma=0.4)\\n\\n binary = lanes\\n\\n # Find lanes and fit curves\\n if not self.curve:\\n self.sw.find(binary)\\n self.curve= CurveSearch(self.sw.left_fit, self.sw.right_fit,\\n image_size=self.warped_image_size, margin=20)\\n lane = self.sw.visualize_lane()\\n curve_rad = self.measure_curvature(self.sw.left_fit, self.sw.right_fit)\\n offset = self.measure_offset(self.sw.left_fit, self.sw.right_fit)\\n else:\\n self.curve.find(binary)\\n lane = self.curve.visualize_lane()\\n curve_rad = self.measure_curvature(self.curve.left_fit, self.curve.right_fit)\\n offset = self.measure_offset(self.curve.left_fit, self.curve.right_fit)\\n\\n non_warped_lane = self.warp_inverse(lane)\\n\\n result = cv2.addWeighted(image, 1, non_warped_lane, 0.3, 0)\\n cv2.putText(result, \\\"Curve Radius: {:.0f}m\\\".format(curve_rad), (50,50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255))\\n cv2.putText(result, \\\"Off Center: {:.2f}m\\\".format(offset), (50, 100),\\n cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255))\\n\\n return result\",\n \"def get_regions_mask(self, input):\",\n \"def get_masked_scene(orig, mask, local_context_size = 80, dilation=False):\\n orig_scene = orig.copy()\\n mask_scene = mask.copy()\\n orig_scene_no_mask = orig.copy()\\n \\n mask_info = np.where(mask_scene == 0) \\n min_x = max(min(mask_info[0]) - local_context_size, 0)\\n max_x = max(mask_info[0]) + local_context_size\\n min_y = max(min(mask_info[1]) - local_context_size, 0)\\n max_y = max(mask_info[1]) + local_context_size\\n \\n orig_scene = orig_scene[min_x:max_x,min_y:max_y]\\n orig_scene_no_mask = orig_scene_no_mask[min_x:max_x,min_y:max_y]\\n mask_scene = mask_scene[min_x:max_x,min_y:max_y]\\n \\n dialation_mask = np.zeros(mask_scene.shape) + 255\\n \\n if dilation:\\n dialation_mask = cv2.dilate(255-mask_scene, np.ones((local_context_size,local_context_size)))\\n \\n #implot(dialation_mask)\\n #plt.imshow(dialation_mask, 'gray')\\n \\n for x in range(mask_scene.shape[0]):\\n for y in range(mask_scene.shape[1]):\\n if mask_scene[x, y] == 0:\\n orig_scene[x, y, :] = 0\\n orig_scene_no_mask[x,y,:] = 0\\n if dilation:\\n if dialation_mask[x,y] == 0:\\n orig_scene[x, y, :] = 0\\n \\n return orig_scene, mask_scene, orig_scene_no_mask, dialation_mask\",\n \"def _generateTotalMask(self):\\r\\n\\r\\n mask = np.zeros(self.altPosMap.shape)\\r\\n\\r\\n for patch in self.finalPatches.itervalues():\\r\\n mask = mask + patch.array.astype(np.float)\\r\\n\\r\\n mask = ni.binary_closing(mask,\\r\\n structure=np.array([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]),\\r\\n iterations=self.params['borderWidth'])\\r\\n\\r\\n return mask.astype(np.int8)\",\n \"def plot_lanes(self, img, ax):\\n left_fit, right_fit, left_fit_curve, right_fit_curve, left_lane_inds, right_lane_inds, out_img, nonzerox, nonzeroy = self.detect_lanes(img)\\n # Visualization\\n ploty = np.linspace(0, img.shape[0]-1, img.shape[0] )\\n left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]\\n right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\\n\\n out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]\\n out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255]\\n ax.imshow(out_img)\\n ax.plot(left_fitx, ploty, color='yellow')\\n ax.plot(right_fitx, ploty, color='yellow')\\n return left_fit, right_fit, left_fit_curve, right_fit_curve\",\n \"def fill_lane(self,img_shape):\\n\\n\\t\\tbinary_l = np.zeros(img_shape, dtype=np.uint8)\\n\\n\\t\\tploty = np.linspace(0, img_shape[0]-1, img_shape[0])\\n\\t\\tplotx_l = self.leftLine.fit[0]*ploty**2 + self.leftLine.fit[1]*ploty + self.leftLine.fit[2]\\n\\t\\tplotx_r = self.rightLine.fit[0]*ploty**2 + self.rightLine.fit[1]*ploty + self.rightLine.fit[2]\\n\\n\\t\\tline_points_l = np.column_stack((plotx_l,ploty))\\n\\t\\tline_points_r = np.column_stack((plotx_r,ploty))\\n\\t\\tline_points = np.concatenate((line_points_l,line_points_r[::-1],line_points_l[:1]))\\n\\n\\t\\tcv2.fillPoly(binary_l, np.int32([line_points]),color=255)\\n\\n\\t\\tpolygon = np.dstack((np.zeros(img_shape),binary_l,np.zeros(img_shape))).astype('uint8')\\n\\t\\t\\n\\t\\treturn polygon\\n\\t\\tunwarped_polygon = self.cam.unwarp(polygon)\\n\\t\\treturn unwarped_polygon\",\n \"def test(shape=(1000,2000)):\\n mask = Mask()\\n mask.addCircle(400,300,250)\\n mask.subtractCircle(400,300,150)\\n mask.addRectangle(350,250,1500,700)\\n plt.imshow( mask.getMask(shape) )\\n return mask\",\n \"def linesolve(mask, meta):\\n for func in RULE_FUNCS:\\n func(mask, meta)\",\n \"def __mask_region(self, img, vertices):\\n\\n mask = np.zeros_like(img) \\n if len(img.shape) > 2:\\n channel_count = img.shape[2] # i.e. 3 or 4 depending on your image\\n ignore_mask_color = (255,) * channel_count\\n else:\\n ignore_mask_color = 255\\n cv2.fillConvexPoly(mask, vertices, ignore_mask_color)\\n masked_image = cv2.bitwise_and(img, mask)\\n return masked_image\",\n \"def __generate_mask(self):\\n mask = np.concatenate([np.ones(len(self.fixed[0])),\\n np.zeros(self.num_points),\\n np.ones(len(self.fixed[1]))])\\n return mask\",\n \"def filter_lane_color(image):\\n \\n YELLOW_HSV_LOWER = np.array([20, 100, 100])\\n YELLOW_HSV_UPPER = np.array([40, 255, 255])\\n \\n WHITE_HSV_LOWER = np.array([0, 0, 220])\\n WHITE_HSV_UPPER = np.array([255, 255, 255])\\n \\n image_wk = np.copy(image) # working copy\\n image_hsv = cv2.cvtColor(image_wk, cv2.COLOR_RGB2HSV) # RGB -> HSV\\n \\n yellow_mask = cv2.inRange(image_hsv, YELLOW_HSV_LOWER, YELLOW_HSV_UPPER)\\n white_mask = cv2.inRange(image_hsv, WHITE_HSV_LOWER, WHITE_HSV_UPPER)\\n both_mask = yellow_mask + white_mask\\n \\n image_wk = grayscale(image_wk) # RGB -> GRAY\\n image_wk = cv2.bitwise_or(image_wk, both_mask) # GRAY + yellow/white mask\\n \\n # Output grayscale road image with enhanced yellow/white areas\\n return image_wk\",\n \"def ice_unmasked(res='4x5', debug=False):\\n # Create a np.ma mask\\n m = np.logical_not((land_unmasked(res)*ocean_unmasked(res)))\\n if debug:\\n print((mask, mask.shape))\\n return m\",\n \"def poly2mask(self):\\n self.x_gridnum = int((self.x_range[1] - self.x_range[0]) / self.x_gridsize)\\n self.y_gridnum = int((self.y_range[1] - self.y_range[0]) / self.y_gridsize)\\n img = Image.new(\\\"L\\\", (self.x_gridnum, self.y_gridnum), 0)\\n\\n self.perimeter = 0.0\\n for ii in self.polygons:\\n pp = np.array(ii) * self.CD # polygon\\n polygonlen = len(pp)\\n self.perimeter += np.sum(np.abs(pp[0:-1] - pp[1:polygonlen]))\\n pp[:, 0] = (pp[:, 0] - self.x_range[0]) / self.x_gridsize\\n pp[:, 1] = (pp[:, 1] - self.y_range[0]) / self.y_gridsize\\n vetex_list = list(pp)\\n polygon = [tuple(y) for y in vetex_list]\\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\\n\\n self.data = np.array(img)\\n self.data = np.float64(self.data)\\n\\n self.spat_part = pyfftw.empty_aligned(\\n (self.y_gridnum, self.x_gridnum), dtype=\\\"complex128\\\"\\n )\\n self.freq_part = pyfftw.empty_aligned(\\n (self.y_gridnum, self.x_gridnum), dtype=\\\"complex128\\\"\\n )\\n self.fft_mask = pyfftw.FFTW(self.spat_part, self.freq_part, axes=(0, 1))\",\n \"def draw_final_image(self, image, warped, undist, ploty, left_fitx, right_fitx, Minv, left_rad, right_rad):\\n gray = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)\\n # Create an image to draw the lines on\\n warp_zero = np.zeros_like(gray).astype(np.uint8)\\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\\n\\n # Recast the x and y points into usable format for cv2.fillPoly()\\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\\n pts = np.hstack((pts_left, pts_right))\\n\\n # Draw the lane onto the warped blank image\\n cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))\\n\\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\\n newwarp = cv2.warpPerspective(color_warp, Minv, (image.shape[1], image.shape[0]))\\n # Combine the result with the original image\\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\\n\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n off_center = calculate_center(left_fitx, right_fitx, image.shape)\\n direction_str = 'left' if off_center < 0 else 'right'\\n center_str = '{:.2f} m of center {}'.format(abs(off_center), direction_str)\\n cv2.putText(result, center_str, (430, 630), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\\n if left_rad and right_rad:\\n curvature = 0.5 * (round(right_rad / 1000, 1) + round(left_rad / 1000, 1))\\n else:\\n curvature = 0\\n str2 = 'Radius of curvature: {} km'.format(curvature)\\n cv2.putText(result, str2, (430, 670), font, 1, (0, 0, 255), 2, cv2.LINE_AA)\\n\\n if self.args.is_test:\\n plt.imshow(result)\\n plt.show()\\n\\n return result\",\n \"def process_image(image):\\n \\n # (step 1) get gray image\\n gray = grayscale(image)\\n \\n # (step 2) do gaussian blur with kernel size is 3\\n blur_gray = gaussian_blur(gray, 3)\\n \\n # (step 3) do canny edge detction with low 50 and hight 150\\n canny_edges = canny(blur_gray, 50, 150)\\n \\n # (step 4) region of interset\\n imshape = image.shape\\n left_bottom = (50,imshape[0])\\n right_bottom = (imshape[1]-50,imshape[0])\\n left_top = (420, 330)\\n right_top = (imshape[1]-420, 330)\\n # used later to discard lines which are out of the ROI\\n polygon = Polygon([(50,imshape[0]+1),(imshape[1]-50,imshape[0]+1), (imshape[1]-420, 329), (420, 329)])\\n vertices = np.array([[left_bottom,left_top, right_top, right_bottom]], dtype=np.int32)\\n masked_edge = region_of_interest(canny_edges, vertices)\\n \\n # (step 5) get lane lines from hough transform\\n rho = 2\\n theta = np.pi/18 \\n threshold = 15\\n min_line_length = 10\\n max_line_gap = 20\\n lines = hough_lines(masked_edge, rho, theta, threshold, min_line_length, max_line_gap)\\n \\n # (step 6) seperate left and right lines\\n left_lines = []\\n right_lines = []\\n for line in lines:\\n for x1,y1,x2,y2 in line:\\n if y1 > y2:\\n temp_line = [x1,y1,x2,y2]\\n if x2 != x1:\\n m = (float(y2) - float(y1)) / (float(x2) - float(x1))\\n else:\\n m = 1000 # it will be dicarded, any high value will work\\n temp_line.append(m)\\n if x1 < x2:\\n left_lines.append(temp_line)\\n else:\\n right_lines.append(temp_line)\\n else:\\n temp_line = [x2,y2,x1,y1]\\n if x2 != x1:\\n m = (float(y1) - float(y2)) / (float(x1) - float(x2))\\n else:\\n m = 1000\\n temp_line.append(m)\\n if x1 > x2:\\n left_lines.append(temp_line)\\n else:\\n right_lines.append(temp_line)\\n \\n # (step 7) get left and right lines slopes, can be done with step 6 although\\n left_slop = []\\n for left_line in left_lines:\\n x1 = left_line[0]; y1 = left_line[1]; x2 = left_line[2]; y2 = left_line[3]; \\n if x1 != x2:\\n left_slop.append( (float(y2) - float(y1)) / (float(x2) - float(x1)) )\\n average_left_slop = sum(left_slop)/len(left_slop) # not used yet\\n \\n right_slop = []\\n for right_line in right_lines:\\n x1 = right_line[0]; y1 = right_line[1]; x2 = right_line[2]; y2 = right_line[3]; \\n if x1 != x2:\\n right_slop.append( (float(y2) - float(y1)) / (float(x2) - float(x1)) )\\n average_right_slope = sum(right_slop)/len(right_slop) # not used yet\\n \\n \\n # (step 8) delete left lines which deviate from thersold_s slope\\n thersold_s = 0.4\\n delet_left_index = []\\n i = 0\\n for left_line in left_lines:\\n x1 = left_line[0]; y1 = left_line[1]; x2 = left_line[2]; y2 = left_line[3]; m = left_line[4]; \\n if abs(m) < thersold_s:\\n delet_left_index.append(i)\\n i=i+1\\n for i in range((len(delet_left_index)-1), -1, -1):\\n del left_lines[delet_left_index[i]]\\n \\n # (step 9) delete right lines which deviate from average slope\\n delet_index_right = []\\n i = 0\\n for right_line in right_lines:\\n x1 = right_line[0]; y1 = right_line[1]; x2 = right_line[2]; y2 = right_line[3]; m = right_line[4]; \\n if abs(m) < thersold_s:\\n delet_index_right.append(i)\\n i=i+1\\n for i in range((len(delet_index_right)-1), -1, -1):\\n del right_lines[delet_index_right[i]]\\n \\n # (step 10) extrapolate left and right lines\\n left_line_draw = True\\n x_lefts = []\\n y_lefts = []\\n for line in left_lines:\\n x1, y1, x2, y2, m = line\\n x_lefts.append(x1)\\n x_lefts.append(x2) \\n y_lefts.append(y1)\\n y_lefts.append(y2)\\n \\n if len(x_lefts) > 0:\\n slope_left, c_left = np.polyfit(x_lefts, y_lefts, 1)\\n else:\\n slope_left, c_left = 1, 1\\n left_line_draw = False\\n \\n right_line_draw = True\\n x_rights = []\\n y_rights = []\\n for line in right_lines:\\n x1, y1, x2, y2, m = line\\n x_rights.append(x1)\\n x_rights.append(x2)\\n y_rights.append(y1)\\n y_rights.append(y2)\\n if len(x_rights) > 0:\\n slope_right, c_right = np.polyfit(x_rights, y_rights, 1)\\n else:\\n slope_right, c_right = 1, 1\\n right_line_draw = False\\n \\n y1_left = 530 # again hardcoded values, from ROI\\n y2_left = 330 # again hardcoded values, from ROI\\n x1_left = int((y1_left - c_left) / slope_left)\\n x2_left = int((y2_left - c_left) / slope_left)\\n \\n y1_right = 530 # again hardcoded values, from ROI\\n y2_right = 330 # again hardcoded values, from ROI \\n x1_right = int((y1_right - c_right) / slope_right)\\n x2_right = int((y2_right - c_right) / slope_right)\\n \\n # (step 11) check if left/right line is out of ROI\\n left_point1 = Point(x1_left, y1_left)\\n left_point2 = Point(x2_left, y2_left)\\n \\n right_point1 = Point(x1_right, y1_right)\\n right_point2 = Point(x2_right, y2_right)\\n \\n if polygon.contains(left_point1) and polygon.contains(left_point2):\\n left_line_draw = True\\n else:\\n #print (\\\"left line out\\\", left_point1, left_point2)\\n left_line_draw = False\\n \\n if polygon.contains(right_point1) and polygon.contains(right_point2):\\n right_line_draw = True\\n else:\\n #print (\\\"right line out\\\", right_point1, right_point2)\\n right_line_draw = False\\n \\n \\n # (step 12) draw lines\\n line_image = np.copy(image)\\n # Draw the right and left lines on image\\n if left_line_draw:\\n cv2.line(line_image, (x1_left, y1_left), (x2_left, y2_left), (255,0,0),5)\\n if right_line_draw:\\n cv2.line(line_image, (x1_right, y1_right), (x2_right, y2_right), (255,0,0),5)\\n \\n # Create a \\\"color\\\" binary image to combine with line image\\n color_edges = np.dstack((masked_edge, masked_edge, masked_edge)) \\n \\n # Draw the lines on the edge image\\n lines_edges = cv2.addWeighted(color_edges, 0.4, line_image, 1, 0) \\n #plt.imshow(lines_edges)\\n #plt.show()\\n return lines_edges\",\n \"def draw_lane_on_img(undist, warped, left_fitx, right_fitx, ploty, Minv, curvature, distance):\\n # Create an image to draw the lines on\\n warp_zero = np.zeros_like(warped).astype(np.uint8)\\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\\n\\n # Recast the x and y points into usable format for cv2.fillPoly()\\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\\n pts = np.hstack((pts_left, pts_right))\\n\\n # Draw the lane onto the warped blank image\\n cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))\\n\\n # Draw lane boundary\\n left_lane = np.int32(pts_left)\\n right_lane = np.int32(pts_right)\\n color_warp = cv2.polylines(color_warp, [left_lane], False, (255,0,0), 16)\\n color_warp = cv2.polylines(color_warp, [right_lane], False, (0, 0, 255), 16)\\n\\n # Warp the blank back to original image space using inverse perspective matrix (Minv)\\n newwarp = cv2.warpPerspective(color_warp, Minv, (undist.shape[1], undist.shape[0])) \\n # Combine the result with the original image\\n result = cv2.addWeighted(undist, 1, newwarp, 0.4, 0)\\n\\n # Write out the curvature and relative position\\n curv_info = \\\"Radius of Curvature ={0:.2f}(m).\\\".format(curvature)\\n if distance > 0:\\n pos_info = \\\" Car is {0:.2f}m right of center.\\\".format(distance)\\n else:\\n pos_info = \\\" Car is {0:.2f}m left of center.\\\".format(-distance)\\n info = curv_info + pos_info\\n cv2.putText(result, info, (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2, bottomLeftOrigin=False)\\n\\n return result\",\n \"def draw_lines(args, img, lines, color=[255, 0, 0], thickness=8):\\n slopes = [ (line[0][3]-line[0][1])/(line[0][2]-line[0][0]) for line in lines]\\n rights = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope > 0.0 ] # and slope < 0.5 and not np.isnan(slope) ]\\n lefts = [ [line, slope, line[0][1] - slope*line[0][0]] for line,slope in zip(lines, slopes) if slope < 0.0 ] # and slope > -0.5 and not np.isnan(slope) ]\\n #lefts[0] = [ [[x1,y1,x2,y2]] , slope , y_intercept ]\\n\\n y_mins = [ min(line[0][1],line[0][3]) for line in lines]\\n y_min = min(y_mins)\\n y_max = img.shape[0]\\n\\n log_new = [slopes, rights, lefts, y_mins, y_min, y_max]\\n\\n for lanes in [rights,lefts]:\\n slope_mean = np.mean( [ lane[1] for lane in lanes ] )\\n slope_std = np.std ( [ lane[1] for lane in lanes ] )\\n if slope_std == 0:\\n slope = slope_mean\\n else:\\n slope = np.mean( [ lane[1] for lane in lanes if lane[1] - slope_mean < 2*slope_std ] ) \\n print()\\n print('slope : {}'.format(slope))\\n\\n intercept_mean = np.mean( [ lane[2] for lane in lanes ] )\\n intercept_std = np.std ( [ lane[2] for lane in lanes ] )\\n if intercept_std == 0:\\n intercept = intercept_mean\\n else:\\n intercept = np.mean( [ lane[2] for lane in lanes if lane[2] - intercept_mean < 2*intercept_std ] )\\n print('intercept : {}'.format(intercept))\\n \\n x_min = int( ( y_min - intercept ) / slope ) \\n x_max = int( ( y_max - intercept ) / slope )\\n\\n log_new.append(slope)\\n log_new.append(intercept)\\n log_new.append(x_min)\\n log_new.append(x_max)\\n\\n cv2.line(img, (x_min, y_min), (x_max, y_max), color, thickness)\\n\\n try: \\n log_line = pd.read_csv(args.path+args.csv_file, skiprows=[0], names=args.header)\\n except:\\n log_line = pd.DataFrame([ ], columns=args.header)\\n finally:\\n df = pd.DataFrame([ log_new ], columns=args.header)\\n # update log: add new entry into the log\\n result = pd.concat([log_line, df], ignore_index=True)\\n result.to_csv(args.path+args.csv_file) #, index=False)\",\n \"def get_lane_lines(self, lines, image):\\n # get image shape\\n img_height, img_width, _ = image.shape\\n\\n # get left and right lanes\\n slope_lower_bnd, slope_upper_bnd = self.slope_params[\\\"bounds\\\"]\\n left_lane, right_lane = get_lanes_segments(\\n lines, slope_lower_bnd, slope_upper_bnd\\n )\\n\\n # use get_line_end_pts to convert left_lane and right_lane to their corresponding end points\\n left_lane = get_line_end_pts(\\n left_lane, y1=img_height, y2=self.LANE_LINE_IMG_RATIO * img_height\\n )\\n right_lane = get_line_end_pts(\\n right_lane, y1=img_height, y2=self.LANE_LINE_IMG_RATIO * img_height\\n )\\n\\n # update cache and apply probablistic smoothing\\n left_lane, self.left_lane_cache = self.probablistic_smoothing(\\n left_lane, self.left_lane_cache\\n )\\n\\n right_lane, self.right_lane_cache = self.probablistic_smoothing(\\n right_lane, self.right_lane_cache\\n )\\n\\n return left_lane, right_lane\",\n \"def pipeline(image, plot = False):\\n # undistort image\\n undistorted_image = undistort_image(image)\\n \\n # R&S|sobel-x thresholding\\n _, _, _, _, threshold_image = thresholding(undistorted_image)\\n \\n # yellow mask\\n _, mask_yellow = filter_color(undistorted_image, np.array([20,100,100]), np.array([50,255,255]))\\n \\n # white mask\\n _, mask_white = filter_color(undistorted_image, np.array([0,0,220]), np.array([255,35,255]))\\n \\n # combine yellow and white mask\\n mask = cv2.bitwise_or(mask_yellow, mask_white)\\n comb_image = np.zeros_like(threshold_image)\\n \\n # combine mask and thresholded image\\n comb_image[(mask > 0)&(threshold_image == 1)] = 1\\n \\n # warp the binary image\\n warped_image, Minv = warp(comb_image, src, dst)\\n if plot:\\n plt.figure(2)\\n plt.imshow(warped_image, cmap = \\\"gray\\\")\\n plt.title(\\\"Binary warped image\\\")\\n \\n # calculate polynomial fit\\n left_fitx, right_fitx, ploty, left_curverad, right_curverad, offset = fit_polynomial(warped_image, plot)\\n \\n # superimpose lines on top of the polynomial\\n superimposed_image = mark_lane_lines(undistorted_image, warped_image, ploty, left_fitx, right_fitx, Minv)\\n cv2.putText(superimposed_image, \\\"Left curvature = \\\" + str(np.round(left_curverad, 2)) + \\\" m\\\",(40,40), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n cv2.putText(superimposed_image,\\\"Right curvature = \\\" + str(np.round(right_curverad, 2)) + \\\" m\\\",(40,80), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n cv2.putText(superimposed_image,\\\"Offset = \\\" + str(np.round(offset*100, 2)) + \\\" cm\\\",(40,120), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n \\n return superimposed_image\",\n \"def get_mask(self):\\n\\t\\treturn pygame.mask.from_surface(self.img)\",\n \"def lane_find(self, binary_warped):\\n\\t\\t# Identify the x and y positions of all nonzero pixels in the image\\n\\t\\tnonzero = binary_warped.nonzero()\\n\\t\\tnonzeroy = np.array(nonzero[0])\\n\\t\\tnonzerox = np.array(nonzero[1])\\n\\t\\t# Set th ewidth of the windows +/- margin\\n\\t\\tmargin = 100\\n\\t\\tleft_lane_inds = ((nonzerox > (self.left_fit[0] * (nonzeroy ** 2) + self.left_fit[1] * nonzeroy + self.left_fit[2] - margin)) & \\n\\t\\t\\t(nonzerox < (self.left_fit[0] * (nonzeroy ** 2) + self.left_fit[1] * nonzeroy + self.left_fit[2] + margin)))\\n\\t\\tright_lane_inds = ((nonzerox > (self.right_fit[0] * (nonzeroy ** 2) + self.right_fit[1] * nonzeroy + self.right_fit[2] - margin)) & \\n\\t\\t\\t(nonzerox < (self.right_fit[0] * (nonzeroy ** 2) + self.right_fit[1] * nonzeroy + self.right_fit[2] + margin)))\\n\\t\\t# Again, extract left and right line pixel positions\\n\\t\\tleftx = nonzerox[left_lane_inds]\\n\\t\\tlefty = nonzeroy[left_lane_inds]\\n\\t\\trightx = nonzerox[right_lane_inds]\\n\\t\\trighty = nonzeroy[right_lane_inds]\\n\\t\\t# Fit a second order polynomial to each\\n\\t\\tself.left_fit = np.polyfit(lefty, leftx, 2)\\n\\t\\tself.right_fit = np.polyfit(righty, rightx, 2)\\n\\t\\t# Generate x and y values for plotting\\n\\t\\tploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0])\\n\\t\\tleft_fitx = self.left_fit[0] * ploty ** 2 + self.left_fit[1] * ploty + self.left_fit[2]\\n\\t\\tright_fitx = self.right_fit[0] * ploty ** 2 + self.right_fit[1] * ploty + self.right_fit[2]\\n\\t\\treturn left_fitx, right_fitx\",\n \"def mask_the_images(working_path,set_name):\\n\\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41cf2fb1198e.npy')\\n out_images = [] #final set of images for all patients\\n for fname in file_list:\\n out_images_per_patient = []\\n print (\\\"working on file \\\", fname)\\n imgs_to_process = np.load(fname.replace(\\\"lungmask\\\",\\\"images\\\")) # images of one patient\\n masks = np.load(fname)\\n for i in range(len(imgs_to_process)):\\n mask = masks[i]\\n img = imgs_to_process[i]\\n new_size = [512,512] # we're scaling back up to the original size of the image\\n img= mask*img # apply lung mask\\n #\\n # renormalizing the masked image (in the mask region)\\n #\\n new_mean = np.mean(img[mask>0])\\n new_std = np.std(img[mask>0])\\n #\\n # Pulling the background color up to the lower end\\n # of the pixel range for the lungs\\n #\\n old_min = np.min(img) # background color\\n img[img==old_min] = new_mean-1.2*new_std # resetting backgound color\\n img = img-new_mean\\n img = img/new_std\\n #make image bounding box (min row, min col, max row, max col)\\n labels = measure.label(mask)\\n regions = measure.regionprops(labels)\\n #\\n # Finding the global min and max row over all regions\\n #\\n min_row = 512\\n max_row = 0\\n min_col = 512\\n max_col = 0\\n for prop in regions:\\n B = prop.bbox\\n if min_row > B[0]:\\n min_row = B[0]\\n if min_col > B[1]:\\n min_col = B[1]\\n if max_row < B[2]:\\n max_row = B[2]\\n if max_col < B[3]:\\n max_col = B[3]\\n width = max_col-min_col\\n height = max_row - min_row\\n if width > height:\\n max_row=min_row+width\\n else:\\n max_col = min_col+height\\n #\\n # cropping the image down to the bounding box for all regions\\n # (there's probably an skimage command that can do this in one line)\\n #\\n img = img[min_row:max_row,min_col:max_col]\\n mask = mask[min_row:max_row,min_col:max_col]\\n if max_row-min_row <5 or max_col-min_col<5: # skipping all images with no god regions\\n pass\\n else:\\n # moving range to -1 to 1 to accomodate the resize function\\n mean = np.mean(img)\\n img = img - mean\\n min = np.min(img)\\n max = np.max(img)\\n img = img/(max-min)\\n new_img = resize(img,[512,512], mode='constant')\\n out_images_per_patient.append(new_img)\\n\\n id = re.sub(r'.*_images_(.*)\\\\.npy',r'\\\\1',fname)\\n patient_images_and_id = (out_images_per_patient,id)\\n out_images.append(patient_images_and_id)\\n print (\\\"Delete files: {} \\\\n\\\\t {} \\\".format(fname,re.sub(\\\"lungmask\\\",\\\"images\\\",fname)))\\n os.remove(fname)\\n os.remove(fname.replace(\\\"images\\\",\\\"lungmask\\\")) # images of one patient\\n\\n\\n np.save(working_path+\\\"{}Images.npy\\\".format(set_name),out_images)\",\n \"def mask(self):\\n\\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\\n\\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\\n\\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\\n\\n cv2.floodFill(image=mask,\\n mask=mask_with_border,\\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\\n newVal=constants.COLOR_WHITE_MONO)\\n\\n return mask\",\n \"def generate_MLmask(self):\\r\\n self.MLmask = np.zeros((self.MLtargetedImg.shape[0], self.MLtargetedImg.shape[1]))\\r\\n \\r\\n if len(self.selected_ML_Index) > 0:\\r\\n for selected_index in self.selected_ML_Index:\\r\\n self.MLmask = np.add(self.MLmask, self.Mask[:,:,selected_index])\\r\\n \\r\\n self.intergrate_into_final_mask()\\r\\n \\r\\n self.add_rois_of_selected()\\r\\n \\r\\n else:\\r\\n self.intergrate_into_final_mask()\",\n \"def save_mask(image_as_array, imagefolder_new, imagetype_new, imagename):\\n\\n # Create argument parser for the thresholds\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"-hl\\\",\\n \\\"--h_lines_threshold\\\",\\n help=\\\"Defines pixel threshold for horizontal lines in find_lines.py.\\\",\\n type=float,\\n default=0.01,\\n )\\n parser.add_argument(\\n \\\"-vl\\\",\\n \\\"--v_lines_threshold\\\",\\n help=\\\"Defines pixel threshold for vertical lines in find_lines.py.\\\",\\n type=float,\\n default=0.005,\\n )\\n parser.add_argument(\\n \\\"-b\\\",\\n \\\"--beamstop_threshold\\\",\\n help=\\\"Defines pixel threshold for find_beamstop.py.\\\",\\n type=int,\\n default=10,\\n )\\n args = parser.parse_args()\\n\\n # Convert image to grayscale\\n gray_scale_img = normalize_image(image_as_array)\\n\\n # Create mask for horizontal lines\\n h_lines_threshold = args.h_lines_threshold\\n FILEPATH_mask = imagefolder_new + imagename + \\\"_mask\\\" + imagetype_new\\n mask_horizontal_lines = find_horizontal_lines(gray_scale_img, h_lines_threshold)\\n\\n # Create mask for vertical lines\\n v_lines_threshold = args.v_lines_threshold\\n FILEPATH_mask = imagefolder_new + imagename.split(\\\".\\\")[0] + \\\"_mask\\\" + imagetype_new\\n mask_vertical_lines = find_vertical_lines(gray_scale_img, v_lines_threshold)\\n\\n # Create mask for beamstop\\n beamstop_threshold = args.beamstop_threshold\\n coordinates = select_area_of_interest(gray_scale_img)\\n mask_beamstop = create_mask(gray_scale_img, coordinates, beamstop_threshold)\\n\\n # Create mask for vertical line (holder)\\n val = input(\\\"Is there a beamstop holder to mask ([Y]/n)? \\\")\\n if val == \\\"Y\\\" or val == \\\"\\\":\\n mask_vert = select_vert(gray_scale_img)\\n\\n # Combine masks\\n mask_as_array = (\\n mask_horizontal_lines * mask_vertical_lines * mask_beamstop * mask_vert\\n )\\n # Combine masks\\n else:\\n mask_as_array = mask_horizontal_lines * mask_vertical_lines * mask_beamstop\\n\\n # Convert from array to 3-channel PIL image\\n mask_as_array_as_dummy_rgb = np.transpose(\\n np.array(\\n [\\n np.transpose(mask_as_array * 255),\\n np.transpose(mask_as_array * 255),\\n np.transpose(mask_as_array * 255),\\n ]\\n ).astype(dtype=np.uint8)\\n )\\n img_mask = Image.fromarray(mask_as_array_as_dummy_rgb)\\n\\n # Save mask\\n img_mask.save(FILEPATH_mask)\",\n \"def maskall(image_input_path,shapeloc_input_path,txtloc_input_path, comploc_input_path, output_path):\\n print(\\\"========== mask shapes and text ==============\\\")\\n if os.path.exists(output_path):\\n shutil.rmtree(output_path)\\n os.makedirs(output_path)\\n img_fn_list = get_images(image_input_path)\\n wl = 4\\n for img_fn in img_fn_list:\\n print(img_fn)\\n img_raw = cv2.imread(img_fn)\\n img_gray = cv2.cvtColor(img_raw, cv2.COLOR_BGR2GRAY)\\n img_binary = cv2.threshold(img_gray, 128, 255, cv2.THRESH_BINARY)[1]\\n h, w = img_binary.shape[:2]\\n img_blank = np.ones(shape=[h, w], dtype=np.uint8)*255\\n\\n with open(os.path.join (shapeloc_input_path, os.path.splitext(os.path.basename(img_fn))[0]) + \\\"_loc.txt\\\", 'r') as file1:\\n for line in file1:\\n cnt = [i for i in line.split()]\\n loc = [int(i) for i in cnt[1:]]\\n cv2.drawContours(img_blank, [np.array(loc).reshape((-1,1,2))], 0, (0), thickness = -1, lineType=8)\\n\\n with open(os.path.join (comploc_input_path, os.path.splitext(os.path.basename(img_fn))[0]) + \\\"_loc.txt\\\", 'r') as file2:\\n for line in file2:\\n cnt = [i for i in line.split()]\\n loc = [int(i) for i in cnt[1:]]\\n cv2.drawContours(img_blank, [np.array(loc).reshape((-1,1,2))], 0, (0), thickness = -1, lineType=8)\\n\\n with open(os.path.join (txtloc_input_path, os.path.splitext(os.path.basename(img_fn))[0]) + \\\"_loc.txt\\\", 'r') as file3:\\n for line in file3:\\n if bool(line and line.strip()):\\n cnt = [i for i in line.split()] \\n loc = [int(i) for i in cnt[1:]]\\n # crop image with rectangle box and save\\n x0,y0,w0,h0 = cv2.boundingRect(np.array(loc[:8]).astype(np.int32).reshape((-1, 2)))\\n img_crop = img_blank[y0:y0+h0,x0:x0+w0].copy()\\n hc, wc = img_crop.shape[:2]\\n countzero = hc*wc - cv2.countNonZero(img_crop)\\n if countzero *1.0 / (hc*wc) <= 0.25:\\n # if new area is less than 25% of overlap with other proposed masked area\\n cv2.drawContours(img_blank, [np.array(loc[:8]).astype(np.int32).reshape((-1, 1, 2))], 0, (0), thickness=-1, lineType=8)\\n \\n #img_mask = cv2.bitwise_and(img_blank, img_binary, mask = None)\\n img_mask = cv2.bitwise_or(cv2.bitwise_not(img_blank), img_binary, mask = None)\\n cv2.imwrite(os.path.join(output_path, os.path.basename(img_fn)), img_mask)\",\n \"def find_lane_fast(img, left_fit, right_fit):\\n\\n nonzero = img.nonzero()\\n nonzeroy = np.array(nonzero[0])\\n nonzerox = np.array(nonzero[1])\\n\\n margin = 150\\n left_lane_inds = ((nonzerox > (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) & (\\n nonzerox < (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] + margin)))\\n right_lane_inds = (\\n (nonzerox > (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) & (\\n nonzerox < (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] + margin)))\\n\\n # Again, extract left and right line pixel positions\\n leftx = nonzerox[left_lane_inds]\\n lefty = nonzeroy[left_lane_inds]\\n rightx = nonzerox[right_lane_inds]\\n righty = nonzeroy[right_lane_inds]\\n\\n # Fit a second order polynomial to each\\n left_fit = np.polyfit(lefty, leftx, 2)\\n right_fit = np.polyfit(righty, rightx, 2)\\n\\n return left_fit, right_fit\",\n \"def CreateLandmask(Fieldset, test = False):\\n \\n \\n \\\"\\\"\\\"\\n This first set of lines creates a numpy array with u velocities and a numpy\\n array with v velocities. First we get the U and V fields from the dataset. Then\\n we compute a time chunk, which is needed because of the dataset. Then we only\\n take the first slice of the U and V field (we do not need more for finding the land\\n and ocean grids). As last we make an empty array which will be filled with zeros and \\n ones.\\n \\\"\\\"\\\"\\n fU = Fieldset.U\\n fV = Fieldset.V\\n Fieldset.computeTimeChunk(fU.grid.time[0], 1) \\n uvel_mask_c = fU.data[0,:,:] \\n vvel_mask_c = fV.data[0,:,:]\\n# vvel_mask_c = np.roll(vvel_mask_c, 1, axis = 0)\\n landmask = np.zeros((uvel_mask_c.shape[0], uvel_mask_c.shape[1]))\\n \\n \\\"\\\"\\\"\\n The first loop checks the value of the u and v velocitites. Notice that we get the\\n values of two adjacent grid, since we're working with a C-grid.\\n Visualizations of velocities in the C-grids(see below). So for a grid to be flagged identified\\n as a land grid two U velocities and 2 V velocities need to be zero. The first loop makes all\\n ocean grids 1 and land grids 0. \\n ____ ____ ____ ____\\n | V | V | \\n | | | \\n U T U T U\\n | | | \\n |____V____|_____V_____| \\n \\\"\\\"\\\"\\n \\n for i in range (len(landmask[:,0])-1):\\n for j in range (len(landmask[0,:])-1):\\n u1 = uvel_mask_c[i,j]\\n\\n u2 = uvel_mask_c[i,j+1]\\n\\n v1 = vvel_mask_c[i,j]\\n\\n v2 = vvel_mask_c[i+1,j]\\n\\n if u1 != 0 or u2 != 0 or v1 != 0 or v2 != 0:\\n landmask[i,j] = 1\\n \\n \\n \\\"\\\"\\\"\\n Change all zero to 1 and rest 0. since we want the land grids to be 1 and ocean\\n grids to be 0. \\n \\\"\\\"\\\"\\n \\n landmask = ChangeValues(landmask,0,1) \\n \\n \\\"\\\"\\\"\\n The created landmask needs to be shifted upwards one grid. We will\\n use the numpy roll function to do this.\\n \\\"\\\"\\\"\\n \\n if test == True:\\n plt.figure()\\n plt.imshow(landmask)\\n plt.colorbar()\\n \\n return landmask\",\n \"def find_epilines(imgLeft, imgRight, ptsLeft, ptsRight, F):\\n color = []\\n for i in range(ptsLeft.shape[0]):\\n color.append(tuple(np.random.randint(0, 255, 3).tolist()))\\n print(color)\\n\\n # Find epilines corresponding to points in right image (right image)\\n linesLeft = cv2.computeCorrespondEpilines(ptsRight.reshape(-1, 1, 2), 2, F)\\n linesLeft = linesLeft.reshape(-1, 3)\\n # Draw its lines on left image\\n img5, img6 = drawlines(imgLeft, imgRight, linesLeft, ptsLeft, ptsRight, color)\\n\\n # Find epilines corresponding to points in left image (left image)\\n linesRight = cv2.computeCorrespondEpilines(ptsLeft.reshape(-1, 1, 2), 1, F)\\n linesRight = linesRight.reshape(-1, 3)\\n # Draw its lines on right image\\n img3, img4 = drawlines(imgRight, imgLeft, linesRight, ptsRight, ptsLeft, color)\\n\\n plt.subplot(121), plt.imshow(img5)\\n plt.subplot(122), plt.imshow(img3)\\n plt.show()\",\n \"def first_processing(self,img):\\r\\n \\r\\n processed_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\r\\n #cv2.imshow('Balc',processed_img)\\r\\n #vertices = np.array([[0,480],[0,200],[640,200], [640,480] ], np.int32)\\r\\n #processed_img = self.masking(processed_img,[vertices])\\r\\n processed_img = cv2.Canny(processed_img, threshold1 = 50, threshold2=100)\\r\\n processed_img = cv2.GaussianBlur(processed_img,(5,5),0)\\r\\n #masking image (only below 200px cheight processing--> no horizont is detected)\\r\\n #cv2.imshow('2',processed_img)\\r\\n lines = cv2.HoughLinesP(processed_img, 1, np.pi/180, 180,np.array([]),100, 30)\\r\\n return lines\",\n \"def image_mask(image, patch_R, patch_C, seg_model):\\n\\n im = Image.open(image)\\n im_name = os.path.basename(image).split('.')[0]\\n im_width, im_height = im.width, im.height\\n\\n N = patch_R // patch_C\\n\\n W_ps_NI = im_width // patch_C # 31782 // 256 = 124\\n # W_ps_NR = slide_width % patch_C # 31782 % 256 = 38\\n H_ps_NI = im_height // patch_R # 24529 // 1024 = 23\\n # H_ps_NR = slide_height % patch_R # 24529 % 1024 = 977\\n\\n cell_ratio = 0.85 # the threshold that decide the patch is background or not\\n\\n output_dir = os.path.join(current_path, \\\"..\\\", \\\"output\\\", \\\"output_mask\\\")\\n if not os.path.isdir(output_dir): os.makedirs(output_dir)\\n\\n np_im = np.array(im)[:, :, 0:3] # exclude alpha\\n for w in range(W_ps_NI):\\n for h in range(H_ps_NI):\\n subHIC = np_im[h * patch_R: (h+1) * patch_R, w * patch_C:(w+1) * patch_C, :]\\n\\n # rgb three channels value that >200 and <40 are ignored segment\\n rgb_s = (abs(subHIC[:, :, 0] - 120) >= 80) & (abs(subHIC[:, :, 1] - 120) >= 80) & (\\n abs(subHIC[:, :, 2] - 120) >= 80) # >200 <40\\n\\n if np.sum(rgb_s) <= (patch_R * patch_C) * cell_ratio:\\n # segment\\n subHIC = np.where(rgb_similarity(subHIC, 15, 195), 250, subHIC)\\n # adjust equalization histogram and adjust brightness\\n for k in range(subHIC.shape[2]):\\n clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(N * 4, 4))\\n subHIC[:, :, k] = clahe.apply(subHIC[:, :, k])\\n subHIC = exposure.adjust_gamma(subHIC, gamma=1.5)\\n subHIC = subHIC.reshape(N, patch_C, patch_C, 3)\\n\\n subHIC = subHIC.reshape(N, patch_C, patch_C, 3)\\n allmask_prob_list = maskrcnn_detection(seg_model, subHIC)\\n\\n for i in range(len(allmask_prob_list)):\\n for layer in range(allmask_prob_list[i].shape[2]):\\n image, cnts, hierarchy = cv2.findContours(allmask_prob_list[i][:, :, layer],\\n cv2.RETR_EXTERNAL,\\n cv2.CHAIN_APPROX_SIMPLE)\\n np_im[h * patch_R + i * patch_C: h * patch_R + (i + 1) * patch_C, w * patch_C:(w + 1) * patch_C,\\n :] = cv2.drawContours(np_im[h * patch_R + i*patch_C: h*patch_R+(i+1)*patch_C, w * patch_C:(w + 1) * patch_C, :],\\n cnts, -1, (0, 255, 0), 1)\\n\\n # np_im[h * patch_R + i*patch_C: h*patch_R+(i+1)*patch_C, w * patch_C:(w + 1) * patch_C, :] = subHIC[i]\\n\\n # plt.savefig(os.path.join(output_dir, f\\\"{im_name}w{w}h{h}N{i}.png\\\"))\\n\\n io.imsave(os.path.join(output_dir, f\\\"{im_name}.png\\\"), np_im)\",\n \"def process_laneOffset(self):\\n center_line = np.poly1d(np.mean([self.line_l.get_LinePoly().coeffs, self.line_r.get_LinePoly().coeffs], axis=0))\\n # store the center line polynomial\\n self.center_poly = center_line\\n center_point = IMAGE_WIDTH/2 - center_line(709)\\n offset_from_center =center_point* self.line_l.x_pxm\\n self.lane_offset = offset_from_center\\n return center_point\",\n \"def GetCoastGrids(LandMask):\\n \\n \\\"\\\"\\\"\\n Define a coastline map. This map will be set to 1 on all coast cells.\\n \\\"\\\"\\\"\\n \\n \\n CoastlineMap = np.zeros((LandMask.shape[0], LandMask.shape[1]))\\n \\n \\\"\\\"\\\"\\n We will use a nested loop to loop through all cells of the Landmask cell. What this loop basically does is,\\n when a cell has a value of 1 (land), it will make all surrounding cells 1, so we create kind of an extra line of \\n grids around the landmask. In the end we will substract the landmask from the mask which is created by the nested loop, \\n which result in only a mask with the coast grids. Notice, that when we're in the corner, upper, side, or lower row, and we\\n meet a land cell, we should not make all surrounding cells 1. For example, we the lower left corner is a land grid, you should only make the inner cells 1. \\n \\\"\\\"\\\"\\n \\n for i in range(LandMask.shape[0]-1):\\n for j in range(LandMask.shape[1]-1):\\n \\n\\n \\\"\\\"\\\"\\n We have nine if statements, four for the corners, four for the sides and one for the middle\\n of the landmask. \\n \\\"\\\"\\\"\\n\\n if i == 0 and j == 0: #upper left corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j+1] = 1\\n \\n \\n elif i == 0 and j != 0 and j != LandMask.shape[1]-1: #upper row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1, j] = 1\\n CoastlineMap[i+1,j-1] = 1\\n CoastlineMap[i+1,j+1] = 1\\n \\n \\n elif i == 0 and j == LandMask.shape[1]-1: #upper right corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j-1] = 1\\n \\n elif i != 0 and i != LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #right row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i+1,j] = 1\\n CoastlineMap[i-1,j] = 1\\n \\n CoastlineMap[i, j-1] = 1\\n CoastlineMap[i+1,j-1] = 1\\n CoastlineMap[i-1,j-1] = 1\\n \\n elif i == LandMask.shape[0]-1 and j == LandMask.shape[1]-1: #lower right corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n \\n CoastlineMap[i-1,j] = 1 \\n CoastlineMap[i-1, j-1] = 1\\n \\n elif i == LandMask.shape[0]-1 and j != 0 and j != LandMask.shape[1]-1: #lower row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j-1] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i-1, j] = 1\\n CoastlineMap[i-1,j-1] = 1\\n CoastlineMap[i-1,j+1] = 1\\n \\n \\n elif i == LandMask.shape[0]-1 and j == 0: #lower left corner\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i,j+1] = 1\\n \\n CoastlineMap[i+1,j] = 1 \\n CoastlineMap[i+1, j+1] = 1\\n \\n elif i != 0 and i != LandMask.shape[0]-1 and j == 0: #left row\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1\\n CoastlineMap[i+1,j] = 1\\n CoastlineMap[i-1,j] = 1\\n \\n CoastlineMap[i, j+1] = 1\\n CoastlineMap[i+1,j+1] = 1\\n CoastlineMap[i-1,j+1] = 1\\n \\n else:\\n \\n if LandMask[i,j] == 1:\\n \\n CoastlineMap[i,j] = 1 #middle\\n CoastlineMap[i+1,j] = 1#lowermiddle\\n CoastlineMap[i-1,j] = 1#uppermiddle\\n \\n CoastlineMap[i+1, j-1] = 1\\n CoastlineMap[i-1, j-1] = 1\\n CoastlineMap[i, j-1] =1\\n \\n CoastlineMap[i+1, j+1] = 1\\n CoastlineMap[i-1, j+1] = 1\\n CoastlineMap[i, j+1] = 1\\n \\n \\n \\n \\\"\\\"\\\"\\n Here we substract the landmaks from the coastline mask, resulting in only\\n the coastline. \\n \\\"\\\"\\\"\\n \\n \\n Coastgrids = CoastlineMap - LandMask\\n \\n return Coastgrids, CoastlineMap\",\n \"def add_image_mask(image, image_mask):\\n try:\\n # image1 * a + image2 * b + lambda\\n # image1 and image2 must be the same shape.\\n summed = cv2.addWeighted(image, 0.8, image_mask, 1, 0)\\n return summed\\n except:\\n print(\\\"Unable to apply mask, Check the shape of mask and image\\\")\",\n \"def get_mask(self, methods=None): \\r\\n plot_mask = np.ones(self.ndetects, np.bool_)\\r\\n rec_tr = self.rec_track\\r\\n\\r\\n for nm,method in enumerate(methods):\\r\\n method_mask = rec_tr[method] == 1\\r\\n plot_mask = np.multiply(~method_mask, plot_mask)\\r\\n\\r\\n return plot_mask\",\n \"def get_ellipann_mask(self, x, y, a, b, theta, rin, rout):\\n from sep import mask_ellipse\\n ellipsemask_o = np.asarray(np.zeros((self.height,self.width)),dtype=\\\"bool\\\")\\n ellipsemask_i = np.asarray(np.zeros((self.height,self.width)),dtype=\\\"bool\\\")\\n\\n mask_ellipse( ellipsemask_o, x, y, a, b, theta, r= rout)\\n mask_ellipse( ellipsemask_i, x, y, a, b, theta, r= rin )\\n\\n return ~ ((~ellipsemask_o) + ellipsemask_i)\",\n \"def pipeline(image,motorq):\\n\\n height = image.shape[0]\\n width = image.shape[1]\\n region_of_interest_vertices = [\\n (0, height),\\n (width / 2, 0),\\n (width, height),\\n ]\\n blur = cv2.blur(image,(5,5))\\n gray_image = cv2.cvtColor(blur, cv2.COLOR_RGB2GRAY)\\n\\n cannyed_image = cv2.Canny(gray_image, 100, 200)\\n \\n # cropped_image = region_of_interest(\\n # cannyed_image,\\n # np.array(\\n # [region_of_interest_vertices],\\n # np.int32\\n # ),\\n # )\\n \\n lines = cv2.HoughLinesP(\\n cannyed_image,\\n rho=6,\\n theta=np.pi / 60,\\n threshold=160,\\n lines=np.array([]),\\n minLineLength=40,\\n maxLineGap=25\\n )\\n \\n left_line_x = []\\n left_line_y = []\\n right_line_x = []\\n right_line_y = []\\n #print(lines)\\n if not np.any(lines):\\n return image\\n \\n for line in lines:\\n for x1, y1, x2, y2 in line:\\n #print line\\n if (x2-x1) == 0:\\n break\\n slope = float(y2 - y1) / (x2 - x1)\\n if math.fabs(slope) < 0.5:\\n continue\\n if slope <= 0:\\n left_line_x.extend([x1, x2])\\n left_line_y.extend([y1, y2])\\n else:\\n right_line_x.extend([x1, x2])\\n right_line_y.extend([y1, y2])\\n\\n if len(left_line_x)==0 or len(right_line_x)==0:\\n return image\\n\\n min_y = int(image.shape[0] * (3 / 5))\\n max_y = int(image.shape[0])\\n\\n poly_left = np.poly1d(np.polyfit(\\n left_line_y,\\n left_line_x,\\n deg=1\\n ))\\n \\n left_x_start = int(poly_left(max_y))\\n left_x_end = int(poly_left(min_y))\\n \\n poly_right = np.poly1d(np.polyfit(\\n right_line_y,\\n right_line_x,\\n deg=1\\n ))\\n \\n right_x_start = int(poly_right(max_y))\\n right_x_end = int(poly_right(min_y))\\n\\n line_image = draw_lines(\\n image,\\n [[\\n [left_x_start, max_y, left_x_end, min_y],\\n [right_x_start, max_y, right_x_end, min_y],\\n ]],\\n thickness=5,\\n )\\n\\n x_int = Intersect([left_x_start, max_y], [left_x_end, min_y], [right_x_start, max_y], [right_x_end, min_y])[0]\\n #print(line_image.shape()[0])\\n middle = line_image.shape[0]/2\\n if x_int < middle-140:\\n motorq.put( [ -13000 , 0 ] )\\n elif x_int > middle+140:\\n motorq.put( [ 0, -13000 ] )\\n else:\\n motorq.put( [ -13000, -13000 ] )\\n\\n \\n\\n\\n return line_image\",\n \"def __set_mask_regions(self):\\n self.bottom_clip = np.int32(np.int32([[[60,0], [1179,0], [1179,650], [60,650]]]))\\n self.roi_clip = np.int32(np.int32([[[640, 425], [1179,550], [979,719],\\n [299,719], [100, 550], [640, 425]]]))\",\n \"def get_mask(cls, azim):\\n\\n if cls.mask is None:\\n raise ValueError(\\\"No mask defined for the station {}\\\".format(cls.name))\\n\\n azim %= 2 * np.pi\\n\\n if azim in cls.mask[0, :]:\\n return cls.mask[1, np.where(azim == cls.mask[0, :])[0][0]]\\n\\n for next_i, mask_azim in enumerate(cls.mask[0, :]):\\n if mask_azim > azim:\\n break\\n else:\\n next_i = 0\\n\\n x0, y0 = cls.mask[:, next_i - 1]\\n x1, y1 = cls.mask[:, next_i]\\n\\n if next_i - 1 == -1:\\n x0 = 0\\n\\n return y0 + (y1 - y0) * (azim - x0) / (x1 - x0)\",\n \"def _source_mask(self, ilens):\\n x_masks = make_non_pad_mask(ilens)\\n return x_masks.unsqueeze(-2)\",\n \"def mask_border(self, left=3, right=3, top=3, bottom=3):\\n self.MaskPrefix = 'b' + self.MaskPrefix #prepend 'b' for border\\n print('Masking edge pixels: left={0}, right={1}, top={2}, bottom={3}'.format(left,right,top,bottom))\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n igram[:top,:] = ma.masked\\n igram[-bottom:,:] = ma.masked\\n igram[:,:left] = ma.masked\\n igram[:,-right:] = ma.masked\\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\\n print(mskFile)\\n print('mask_border() complete: {0} interferograms'.format(self.Set.Nig))\",\n \"def _get_mask(self, anno, idx):\\n coco = self.coco\\n img_info = coco.loadImgs(self.img_ids[idx])[0]\\n\\n m = np.zeros((img_info['height'], img_info['width']), dtype=np.float32)\\n\\n for obj in anno:\\n if 'segmentation' in obj:\\n if obj['iscrowd']:\\n rle = pycocotools.mask.frPyObjects(obj['segmentation'],\\n img_info['height'],\\n img_info['width'])\\n m += pycocotools.mask.decode(rle)\\n elif obj['num_keypoints'] == 0:\\n rles = pycocotools.mask.frPyObjects(obj['segmentation'],\\n img_info['height'],\\n img_info['width'])\\n for rle in rles:\\n m += pycocotools.mask.decode(rle)\\n\\n return m < 0.5\",\n \"def land_unmasked(res='4x5', debug=False):\\n from .GEOSChem_bpch import get_LWI_map # Kludge, use GEOS-Chem LWI\\n\\n # Create a np.ma mask\\n if debug:\\n print(('land_mask called for: ', res))\\n m = np.ma.masked_not_equal(get_LWI_map(res=res), 1)\\n if debug:\\n print((mask, mask.shape))\\n return m.mask\",\n \"def inpaint(self, img_slice, mask_slice, min_x, max_x, min_y, max_y, views='lateral'):\\n # create binary mask\\n mask = np.zeros(img_slice.shape)\\n mask[min_x:max_x, min_y:max_y] = 1\\n # keep a copy of original to have background later \\n img_orig = np.copy(img_slice)\\n mask_binary = np.copy(mask)\\n\\n # rotate image if coronal\\n if views=='coronal':\\n img_slice = np.rot90(img_slice, axes=(1, 0)) # image is from lat,ax -> ax,lat\\n mask_slice = np.rot90(mask_slice, axes=(1, 0))\\n mask = np.rot90(mask, axes=(1, 0))\\n \\n # prepare binary mask for net\\n mask = cv2.resize(mask, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask = torch.Tensor(mask) # gives dtype float32\\n mask = mask.unsqueeze(0)\\n mask = mask.unsqueeze(0)\\n\\n # prepare seg mask for net\\n mask_slice[mask_slice==self.vertebra_id] = 0\\n # resize to network size\\n mask_seg = cv2.resize(mask_slice, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask_seg = np.uint8(np.round(mask_seg)) # just to be sure\\n\\n mask_seg = self.map_vert_to_class(mask_seg)\\n mask_seg = torch.Tensor(mask_seg) # gives dtype float32\\n mask_seg_one_hot = torch.nn.functional.one_hot(mask_seg.long(), num_classes=6)\\n mask_seg_one_hot = mask_seg_one_hot.permute(2,0,1)\\n mask_seg_one_hot = mask_seg_one_hot.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n\\n # prepare img for net \\n img_slice = cv2.resize(img_slice, self.resize_size)\\n img_slice = np.clip(img_slice, -1024, 3071) # clip to HU units\\n img_slice = np.uint8(255*(img_slice+1024)/4095) # normalize to range 0-255 \\n img_slice = img_slice[:,:, None]\\n img_slice = self.toTensor(img_slice)\\n img_slice = img_slice.unsqueeze(0)\\n corrupt_img = (1-mask)*img_slice\\n\\n if self.use_cuda:\\n mask = mask.cuda()\\n mask_seg = mask_seg.cuda()\\n corrupt_img = corrupt_img.cuda() \\n\\n # inpaint\\n if views=='lateral':\\n netG = self.netGlat\\n elif views=='coronal':\\n netG = self.netGcor\\n\\n # get prediction\\n with torch.no_grad():\\n _, inpainted_mask, inpainted_img = netG(corrupt_img, mask_seg, mask)\\n inpainted_mask = self.softmax(inpainted_mask)\\n\\n #inpainted_mask = torch.argmax(inpainted_mask, dim=1)\\n inpainted_img = inpainted_img * mask + corrupt_img * (1. - mask)\\n inpainted_mask = inpainted_mask * mask + mask_seg_one_hot * (1. - mask)\\n #inpainted_mask = self.map_class_to_vert(inpainted_mask)\\n\\n # set img back to how it was\\n inpainted_img = inpainted_img.squeeze().detach().cpu().numpy()\\n inpainted_img = (inpainted_img)*4095 - 1024 # normalize back to HU units \\n inpainted_img = cv2.resize(inpainted_img, (self.orig_ax_length, self.orig_ax_length))\\n # set mask back\\n inpainted_mask = inpainted_mask.squeeze().detach().cpu().numpy()\\n inpainted_mask_resized = np.zeros((6, self.orig_ax_length, self.orig_ax_length))\\n for i in range(6):\\n if views=='coronal':\\n inpainted_mask_resized[i,:,:] = np.rot90(cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length))) #, interpolation=cv2.INTER_NEAREST)\\n else:\\n inpainted_mask_resized[i,:,:] = cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length)) #, interpolation=cv2.INTER_NEAREST)\\n inpainted_mask = inpainted_mask_resized\\n \\n if views=='coronal':\\n inpainted_img = np.rot90(inpainted_img) #, axes=(1, 0))\\n\\n return inpainted_img, inpainted_mask, mask_binary\",\n \"def eline_mask(wave, lines, pad=None):\\n isline = np.zeros(len(wave), dtype=bool)\\n for w in lines:\\n try:\\n lo, hi = w\\n except(TypeError):\\n lo, hi = w-pad, w+pad\\n isline = isline | ((wave > lo) & (wave < hi))\\n\\n return ~isline\",\n \"def image_clip_to_segment_and_convert(image_ms_array, image_pan_array, mask_array, factor, image_height_size, \\r\\n image_width_size):\\r\\n \\r\\n img_pan_list = []\\r\\n img_ms_list = []\\r\\n mask_list = []\\r\\n \\r\\n n_bands = image_ms_array.shape[2]\\r\\n \\r\\n for i in range(0, image_pan_array.shape[0] - image_height_size, int(factor)):\\r\\n for j in range(0, image_pan_array.shape[1] - image_width_size, int(factor)):\\r\\n M_90 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 90, 1.0)\\r\\n M_180 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 180, 1.0)\\r\\n M_270 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 270, 1.0)\\r\\n \\r\\n img_original = image_pan_array[i : i + image_height_size, j : j + image_width_size, 0]\\r\\n img_rotate_90 = cv2.warpAffine(img_original, M_90, (image_height_size, image_width_size))\\r\\n img_rotate_180 = cv2.warpAffine(img_original, M_180, (image_width_size, image_height_size))\\r\\n img_rotate_270 = cv2.warpAffine(img_original, M_270, (image_height_size, image_width_size))\\r\\n img_flip_hor = cv2.flip(img_original, 0)\\r\\n img_flip_vert = cv2.flip(img_original, 1)\\r\\n img_flip_both = cv2.flip(img_original, -1)\\r\\n img_pan_list.extend([img_original, img_rotate_90, img_rotate_180, img_rotate_270, img_flip_hor, img_flip_vert, \\r\\n img_flip_both])\\r\\n mask_patch = mask_array[i : i + image_height_size, j : j + image_width_size, 0]\\r\\n label = mask_patch[int(image_height_size / 2), int(image_width_size / 2)]\\r\\n mask_list.extend([label] * 7)\\r\\n \\r\\n for i in range(0, int(image_ms_array.shape[0] - (image_height_size / factor)), 1):\\r\\n for j in range(0, int(image_ms_array.shape[1] - (image_width_size / factor)), 1):\\r\\n M_90_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 90, 1.0)\\r\\n M_180_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 180, 1.0)\\r\\n M_270_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 270, 1.0)\\r\\n \\r\\n img_original = image_ms_array[i : i + image_height_size, j : j + image_width_size, 0 : n_bands]\\r\\n img_rotate_90 = cv2.warpAffine(img_original, M_90_ms, (image_height_size, image_width_size))\\r\\n img_rotate_180 = cv2.warpAffine(img_original, M_180_ms, (image_width_size, image_height_size))\\r\\n img_rotate_270 = cv2.warpAffine(img_original, M_270_ms, (image_height_size, image_width_size))\\r\\n img_flip_hor = cv2.flip(img_original, 0)\\r\\n img_flip_vert = cv2.flip(img_original, 1)\\r\\n img_flip_both = cv2.flip(img_original, -1)\\r\\n img_ms_list.extend([img_original, img_rotate_90, img_rotate_180, img_rotate_270, img_flip_hor, img_flip_vert, \\r\\n img_flip_both])\\r\\n \\r\\n image_pan_segment_array = np.zeros((len(img_pan_list), image_height_size, image_width_size, image_pan_array.shape[2]))\\r\\n image_ms_segment_array = np.zeros((len(img_ms_list), int(image_height_size / factor), int(image_width_size / factor), \\r\\n image_ms_array.shape[2]))\\r\\n \\r\\n for index in range(len(img_pan_list)):\\r\\n image_pan_segment_array[index] = img_pan_list[index]\\r\\n image_ms_segment_array[index] = img_ms_list[index]\\r\\n \\r\\n mask_array = np.array(mask_list)\\r\\n \\r\\n return image_ms_segment_array, image_pan_segment_array, mask_array\",\n \"def get_mask(self, image):\\n mask = self.get_gradients(image)\\n return mask\",\n \"def get_arrow_mask(self, frame):\\n # Adapte contrast and put in grayscale\\n img = skimage.exposure.equalize_adapthist(frame)\\n img = skimage.color.rgb2gray(img)\\n # # apply Otsu thresholding method\\n thres = skimage.filters.threshold_otsu(img)\\n mask = np.where(img < skimage.filters.threshold_otsu(img), True, False)\\n # Morphological cleaning\\n mask = skimage.morphology.binary_opening(mask, skimage.morphology.disk(5))\\n # Remove corners of room\\n mask = skimage.segmentation.flood_fill(mask, (0,0), 0)\\n mask = skimage.segmentation.flood_fill(mask, (0,mask.shape[1]-1), 0)\\n mask = skimage.segmentation.flood_fill(mask, (mask.shape[0]-1,0), 0)\\n mask = skimage.segmentation.flood_fill(mask, (mask.shape[0]-1,mask.shape[1]-1), 0)\\n\\n return mask\",\n \"def data_assemble(self, x,y, r_cut, add_mask=5, pick_choice=False):\\n #segmentation components\\n obj_masks,center_mask_info, segments_deblend_list = self._seg_image(x, y, r_cut=r_cut)\\n data_masks_center, _, xcenter, ycenter, c_index = center_mask_info\\n image = self.cut_image(x,y,r_cut)\\n self.raw_image = image\\n src_mask = np.zeros_like(image)\\n lens_mask = np.zeros_like(image)\\n plu_mask = np.zeros_like(image)\\n lenslight_mask_index = []\\n if self.segmap is not None and self.interaction:\\n segmap=self.segmap[0].data\\n segdata = segmap[x - r_cut:x + r_cut + 1, y - r_cut:y + r_cut + 1]\\n plt.imshow(segdata, origin='lower')\\n nlabel = np.unique(segdata)\\n for i in range(nlabel.shape[0] - 1):\\n ax = (int((np.where(segdata == nlabel[i + 1])[0].max() - np.where(segdata == nlabel[i + 1])[0].min()) / 2 +\\n np.where(segdata == nlabel[i + 1])[0].min()))\\n ay = (int((np.where(segdata == nlabel[i + 1])[1].max() - np.where(segdata == nlabel[i + 1])[1].min()) / 3 +\\n np.where(segdata == nlabel[i + 1])[1].min()))\\n plt.text(ay, ax, repr(nlabel[i + 1]), color='r', fontsize=15)\\n plt.title('Input segmentation map')\\n plt.show()\\n source_mask_index = [int(sidex) for sidex in input('Selection of data via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in source_mask_index:\\n src_mask = src_mask + segdata*(segdata==i*1)\\n # lens light\\n lenslightyn = input('Hint: is there lens light? (y/n): ')\\n if lenslightyn == 'y':\\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in lenslight_mask_index:\\n lens_mask = (lens_mask + segdata*(segdata==i*1))\\n elif lenslightyn == 'n':\\n lenslight_mask_index = []\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n # contamination\\n pluyn = input('Hint: is there contamination? (y/n): ')\\n if pluyn == 'y':\\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in plution_mask_index:\\n plu_mask = (plu_mask + segdata*(segdata==i*1))\\n elif pluyn == 'n':\\n plu_mask = np.zeros_like(image)\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n\\n\\n\\n if self.segmap is None and self.interaction:\\n self.plot_segmentation(image, segments_deblend_list, xcenter, ycenter, c_index)\\n #source light\\n if pick_choice:\\n source_mask_index = [int(sidex) for sidex in input('Selection of data via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in source_mask_index:\\n src_mask = src_mask + obj_masks[i]\\n #lens light\\n lenslightyn = input('Hint: is there lens light? (y/n): ')\\n if lenslightyn == 'y':\\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in lenslight_mask_index:\\n lens_mask = (lens_mask + obj_masks[i])\\n elif lenslightyn == 'n':\\n lenslight_mask_index = []\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n # contamination\\n pluyn = input('Hint: is there contamination? (y/n): ')\\n if pluyn == 'y':\\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in plution_mask_index:\\n plu_mask = (plu_mask + obj_masks[i])\\n elif pluyn == 'n':\\n plu_mask = np.zeros_like(image)\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n else:\\n src_mask = data_masks_center\\n\\n\\n #adding pixels around the selected masks\\n selem = np.ones((add_mask, add_mask))\\n src_mask = ndimage.binary_dilation(src_mask.astype(np.bool), selem)\\n plu_mask_out = ndimage.binary_dilation(plu_mask.astype(np.bool), selem)\\n plu_mask_out = (plu_mask_out - 1)*-1\\n\\n #select source region to fit, or to use whole observation to fit\\n ##1.select source region to fit\\n snr = self.snr\\n source_mask = image * src_mask\\n #create background image for picked\\n if self.background_rms is None:\\n _, _, std = sigma_clipped_stats(image, sigma=snr, mask=source_mask)\\n tshape = image.shape\\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\\n else:\\n tshape = image.shape\\n std=np.mean(self.background_rms)\\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\\n\\n no_source_mask = (src_mask * -1 + 1) * img_bkg\\n picked_data = source_mask + no_source_mask\\n\\n ##2.use whole observation to fit while mask out the contamination\\n maskedimg = image * plu_mask_out\\n\\n ##orginize the output 'kwargs_data'\\n kwargs_data = {}\\n if pick_choice:\\n kwargs_data['image_data'] = picked_data#select source region to fit\\n else:\\n kwargs_data['image_data'] = maskedimg#use whole observation to fit while mask out the contamination\\n\\n if self.background_rms is None:\\n kwargs_data['background_rms'] = std\\n self.background_rms = std\\n else:\\n kwargs_data['background_rms'] = np.mean(self.background_rms)\\n kwargs_data['exposure_time'] = self.exp_time\\n kwargs_data['transform_pix2angle'] = np.array([[1, 0], [0, 1]]) * self.deltaPix\\n ra_at_xy_0 = (y - r_cut) * self.deltaPix # (ra,dec) is (y_img,x_img)\\n dec_at_xy_0 = (x - r_cut) * self.deltaPix\\n kwargs_data['ra_at_xy_0'] = ra_at_xy_0\\n kwargs_data['dec_at_xy_0'] = dec_at_xy_0\\n\\n #coordinate of the lens light\\n xlenlight, ylenlight = [], []\\n if lenslight_mask_index !=[]:\\n for i in lenslight_mask_index:\\n xlenlight.append(ra_at_xy_0 + int(xcenter[i]) * self.deltaPix )\\n ylenlight.append(dec_at_xy_0 + int(ycenter[i])* self.deltaPix )\\n\\n #for output\\n self.data = kwargs_data['image_data']\\n self.kwargs_data = kwargs_data\\n self.data_mask = src_mask\\n self.lens_mask = lens_mask\\n self.plu_mask = plu_mask_out\\n self.obj_masks = obj_masks\\n imageData = ImageData(**kwargs_data)\\n self.imageData = imageData\\n kwargs_seg = [segments_deblend_list, xcenter, ycenter, c_index]\\n\\n return kwargs_data, kwargs_seg, [xlenlight, ylenlight]\",\n \"def avg_slope_intercept(image, lines):\\n left_fit = []\\n right_fit = []\\n for line in lines:\\n x1, y1, x2, y2 = line.reshape(4)\\n # Fit first order function\\n #params = np.polyfit((x1, y1), (x2, y2), 1)\\n slope = (y2 - y1) / (x2 - x1)\\n intercept = y1 - slope * x1\\n if(slope < 0):\\n left_fit.append((slope, intercept))\\n cv2.line(image, (x1, y1), (x2, y2), (255, 0, 0), 2)\\n else:\\n right_fit.append((slope, intercept))\\n cv2.line(image, (x1, y1), (x2, y2), (0, 255, 0), 2)\\n\\n if(DEBUG_IMAGES):\\n cv2.imshow(\\\"Hough Lines\\\", image) \\n\\n left_fit_avg, right_fit_avg= [], []\\n left_line, right_line = [], []\\n if(len(left_fit) > 0):\\n left_fit_avg = np.average(left_fit, axis=0)\\n left_line = make_coordinates(image, left_fit_avg)\\n if(len(right_fit) > 0):\\n right_fit_avg = np.average(right_fit, axis=0)\\n right_line = make_coordinates(image, right_fit_avg)\\n\\n \\\"\\\"\\\"\\n left_line, right_line = [], []\\n if(len(left_fit_avg) > 0):\\n left_line = make_coordinates(image, left_fit_avg)\\n if(len(right_fit_avg) > 0):\\n right_line = make_coordinates(image, right_fit_avg)\\n \\\"\\\"\\\"\\n\\n return np.array([left_line, right_line])\",\n \"def __image_pipeline(self, img):\\n \\n ##### Lane finding pipeline #######\\n resized = self.__resize_image(img)\\n undistorted = self.__correct_distortion(resized)\\n warped = self.__warp_image_to_biv(undistorted)\\n thresholded = self.__threshold_image(warped)\\n lines = self.__get_lane_lines(thresholded)\\n lane_img = self.__draw_lane_lines(undistorted, thresholded, include_stats=True)\\n\\n\\n ##### Vehicle Tracking pipeline #####\\n\\n hot_windows = self.windFinder.get_hot_windows(img)\\n car_boxes, wrap_img = self.vTracker.image_pipeline(img, hot_windows,\\n return_img=False) \\n # img = cv2.addWeighted(img, 1, wrap_img, 0.5, 0)\\n result = self.__draw_boxes(lane_img, car_boxes)\\n\\n return result\",\n \"def make_lungmask(img, display=False):\\n row_size= img.shape[0]\\n col_size = img.shape[1]\\n \\n mean = np.mean(img)\\n std = np.std(img)\\n img = img-mean\\n img = img/std\\n\\n # uses hounsfield values near lungs to normalize images\\n\\n middle = img[int(col_size/5):int(col_size/5*4),int(row_size/5):int(row_size/5*4)] \\n mean = np.mean(middle) \\n max = np.max(img)\\n min = np.min(img)\\n img[img==max]=mean\\n img[img==min]=mean\\n \\n # uses kmeans to separate foreground (soft tissue / bone) and background (lung/air)\\n\\n kmeans = KMeans(n_clusters=2).fit(np.reshape(middle,[np.prod(middle.shape),1]))\\n centers = sorted(kmeans.cluster_centers_.flatten())\\n threshold = np.mean(centers)\\n thresh_img = np.where(img<threshold,1.0,0.0)\\n\\n # performs erosion and dilation\\n\\n eroded = morphology.erosion(thresh_img,np.ones([3,3]))\\n dilation = morphology.dilation(eroded,np.ones([8,8]))\\n\\n labels = measure.label(dilation) # Different labels are displayed in different colors\\n label_vals = np.unique(labels)\\n regions = measure.regionprops(labels)\\n good_labels = []\\n for prop in regions:\\n B = prop.bbox\\n if B[2]-B[0]<row_size/10*9 and B[3]-B[1]<col_size/10*9 and B[0]>row_size/5 and B[2]<col_size/5*4:\\n good_labels.append(prop.label)\\n mask = np.ndarray([row_size,col_size],dtype=np.int8)\\n mask[:] = 0\\n\\n # makes mask\\n\\n for N in good_labels:\\n mask = mask + np.where(labels==N,1,0)\\n mask = morphology.dilation(mask,np.ones([10,10])) # one last dilation\\n final = mask * img\\n \\n # shows and saves output\\n\\n plt.imshow(final)\\n im = Image.fromarray(final*128)\\n im = im.convert(\\\"L\\\")\\n im.save(S)\\n \\n return\",\n \"def normalization_mask(img, mask):\\n zone1 = img[mask != 0]\\n zone2 = img[mask == 0]\\n zone1 = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\\n zone2 = (zone2 - zone2.min()) / (zone2.max() - zone2.min())\\n imge = img.copy()\\n imge[mask != 0] = zone1\\n imge[mask == 0] = zone2\\n return imge\",\n \"def draw_lane_lines(image, lines, color=[0, 0, 255], thickness=20):\\n # Make a separate image to draw lines and combine with the orignal later\\n line_image = np.zeros_like(image)\\n if lines is not None:\\n for line in lines:\\n if(len(line) > 0):\\n x1, y1, x2, y2 = line.reshape(4)\\n cv2.line(line_image, (x1, y1), (x2, y2), color, thickness)\\n return line_image\",\n \"def lapsharp(image, maskret = False):\\n #padded_image = np.pad(img, (1, 1), mode = 'symmetric')\\n # lap is linear therefore;\\n # lap f(x,y) = f(x + 1, y) + f(x - 1, y) + f(x, y + 1) + f(x, y - 1) - 4f(x,y)...\\n #--------------------\\n c = -1 # Depends on kernel\\n # make zero kernal\\n lapmask = np.zeros((3, 3))\\n \\n # add values to kernel\\n lapmask[0,0] = 1\\n lapmask[0,1] = 1\\n lapmask[0,2] = 1\\n\\n lapmask[1,0] = 1\\n lapmask[1,1] = -8\\n lapmask[1,2] = 1\\n\\n lapmask[2,0] = 1\\n lapmask[2,1] = 1\\n lapmask[2,2] = 1\\n #--------------------\\n mask = convolve2d(image, lapmask, mode = 'same')\\n result = image + c*mask\\n\\n # Map values to 0-255\\n g1 = image - np.min(image)\\n g = g1/np.max(g1) *255\\n g = g.astype('uint8')\\n\\n if maskret == True:\\n return g, mask\\n else:\\n return g.astype('uint8')\",\n \"def getHitmask(self,image):\\n\\t\\tmask = []\\n\\t\\tfor x in range(image.get_width()):\\n\\t\\t\\tmask.append([])\\n\\t\\t\\tfor y in range(image.get_height()):\\n\\t\\t\\t\\tmask[x].append(bool(image.get_at((x,y))[3]))\\n\\t\\treturn mask\",\n \"def apply_mask(self):\\n for mask, param in self.masked_parameters:\\n param.mul_(mask)\",\n \"def lane_fill_poly(self, binary_warped,undist, inverse_perspective_transform, left_fit,right_fit):\\r\\n # Generate x and y values\\r\\n ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )\\r\\n left_fitx = self.get_val(ploty, left_fit)\\r\\n right_fitx = self.get_val(ploty, right_fit)\\r\\n \\r\\n # Create an image to draw the lines on\\r\\n warp_zero = np.zeros_like(binary_warped).astype(np.uint8)\\r\\n color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\\r\\n\\r\\n # Recast x and y for cv2.fillPoly()\\r\\n pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\\r\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\\r\\n pts = np.hstack((pts_left, pts_right))\\r\\n\\r\\n # Draw the lane \\r\\n cv2.fillPoly(color_warp, np.int_([pts]), (255,255, 255))\\r\\n\\r\\n # Warp using inverse perspective transform\\r\\n newwarp = cv2.warpPerspective(color_warp, inverse_perspective_transform, (binary_warped.shape[1], binary_warped.shape[0])) \\r\\n # overlay\\r\\n #newwarp = cv.cvtColor(newwarp, cv.COLOR_BGR2RGB)\\r\\n result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\\r\\n \\r\\n return result\",\n \"def road_lines():\\n cv2.polylines(frame_1, [pts_1], True, yellow_color)\\n cv2.polylines(frame_2, [pts_2], True, yellow_color)\",\n \"def compute_mask(self, inputs, mask=None):\\n return None\",\n \"def get_mask(self, anno, img_info) -> np.ndarray:\\n m = np.zeros((img_info[\\\"height\\\"], img_info[\\\"width\\\"]), dtype=np.float32)\\n\\n for obj in anno:\\n if obj[\\\"iscrowd\\\"]:\\n rle = pycocotools.mask.frPyObjects(obj[\\\"segmentation\\\"], img_info[\\\"height\\\"], img_info[\\\"width\\\"])\\n mask = pycocotools.mask.decode(rle)\\n if mask.shape != m.shape:\\n logger.warning(f\\\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\\\")\\n continue\\n m += mask\\n elif obj[\\\"num_keypoints\\\"] == 0:\\n rles = pycocotools.mask.frPyObjects(obj[\\\"segmentation\\\"], img_info[\\\"height\\\"], img_info[\\\"width\\\"])\\n for rle in rles:\\n mask = pycocotools.mask.decode(rle)\\n if mask.shape != m.shape:\\n logger.warning(f\\\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\\\")\\n continue\\n\\n m += mask\\n\\n return (m < 0.5).astype(np.float32)\",\n \"def inflate_mask(mask):\\n kernel = np.ones((12, 12), np.uint8)\\n return cv2.dilate(mask, kernel, 1)\",\n \"def find_tfl_lights(image: np.ndarray):\\n kernel = np.array(\\n [[0, 0, 0],\\n [0, 0, 0],\\n [0, 1, 0],\\n [1, 3, 1],\\n [0, 1, 0]])\\n\\n kernel = kernel - kernel.mean()\\n\\n red_image = image.copy()\\n red_image = red_image[:, :, 0]\\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(red_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n red_points = np.where(mask)\\n positions = []\\n final_red_points = []\\n for point1 in range(len(red_points[0])):\\n point = (red_points[0][point1], red_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\\n final_red_points.append(point)\\n final_red_points = filter_points(final_red_points)\\n positions += final_red_points\\n auxilary = ['r'] * len(positions)\\n red_x = [val[1] for val in final_red_points]\\n red_y = [val[0] for val in final_red_points]\\n green_image = image.copy()\\n green_image = green_image[:, :, 1]\\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(green_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n green_points = np.where(mask)\\n final_green_points = []\\n for point1 in range(len(green_points[0])):\\n point = (green_points[0][point1], green_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\\n final_green_points.append(point)\\n\\n final_green_points = filter_points(final_green_points)\\n positions += final_green_points\\n auxilary += ['g'] * len(final_green_points)\\n green_x = [val[1] for val in final_green_points]\\n green_y = [val[0] for val in final_green_points]\\n print(f\\\"There are {len(green_x) + len(red_x)} points\\\")\\n return positions, auxilary\",\n \"def __init__(self, roi_warped_points):\\n\\n # was the line detected in the last iteration?\\n self.detected = False\\n # x values of the last n fits of the line\\n self.recent_xfitted = []\\n #average x values of the fitted line over the last n iterations\\n self.bestx = None\\n #polynomial coefficients averaged over the last n iterations\\n self.best_fit = [np.array([False])]\\n #polinomial coefficients for the last n fits of the lane\\n self.recent_fit = []\\n #polynomial coefficients for the most recent fit\\n self.current_fit = [np.array([False])]\\n #radius of curvature of the line in some units\\n self.radius_of_curvature = 0\\n #distance in meters of vehicle center from the line\\n self.line_base_pos = 0\\n #difference in fit coefficients between last and new fits\\n self.diffs = np.array([0,0,0], dtype='float')\\n #x values for detected line pixels\\n self.allx = None\\n #maximum number of iterations to average\\n self.max_n = 10 #25\\n\\n # roi image points in bird's view space\\n self.roi_warped_points = roi_warped_points\\n\\n #y values for detected line pixels\\n self.ally = np.linspace(0, self.roi_warped_points[2][1] - 1, self.roi_warped_points[2][1])\\n\\n # line base pos is calculated through the roi information\\n # the used four point ROI has two points at the bottom that are straight\\n # with respect to the bottom - as this points are right next to the lines,\\n # they can be translated from pixels into meters with the knowledge of\\n # a U.S. highway standard lane - this is an apprximation, but should be\\n # good enough for this project\\n # U.S. regulations minimum lane width: 3.7m\\n self.xm_per_pix = 3.7 / (self.roi_warped_points[1][0] - self.roi_warped_points[0][0])\\n\\n # each dashed line is 3m long --> about 33m for warped image\\n self.ym_per_pix = 33 / (self.roi_warped_points[2][1] - self.roi_warped_points[0][1])\",\n \"def test_generate_lane_mask(self):\\r\\n\\r\\n sample_alignment = \\\"\\\"\\\">1\\r\\n .ATC-G\\r\\n >2\\r\\n .AACCG\\r\\n >3\\r\\n .ATC-G\\r\\n >4\\r\\n .AAC-G\\\"\\\"\\\".split('\\\\n')\\r\\n\\r\\n entropy_threshold = 0.70\\r\\n\\r\\n expected_lanemask = \\\"110101\\\"\\r\\n\\r\\n actual_lanemask = generate_lane_mask(sample_alignment,\\r\\n entropy_threshold)\\r\\n\\r\\n self.assertEqual(actual_lanemask, expected_lanemask)\",\n \"def show_mask(image, mask): \\n plt.subplot(1,2,1)\\n plt.title('image')\\n plt.imshow(image)\\n plt.subplot(1,2,2)\\n plt.title('mask')\\n plt.imshow(mask)\\n plt.show()\",\n \"def __mask(input, mask):\\n return cv2.bitwise_and(input, input, mask=mask)\",\n \"def pipeline(image):\\n # undistort image\\n undistorted_image = undistort_image(image)\\n superimposed_image = find_lanes(undistorted_image)\\n labels = find_vehicles(undistorted_image)\\n\\n draw_img = draw_labeled_bboxes(superimposed_image, labels)\\n\\n \\n return draw_img\",\n \"def overlay(image, mask):\\n if len(image.shape) == 3:\\n image = image[:, :, 0]\\n if len(mask.shape) == 3:\\n mask = mask[:, :, 0]\\n if np.amax(image) > 100:\\n image = image / 255\\n\\n masked = np.ma.masked_where(mask == 0, mask)\\n\\n plt.figure()\\n plt.subplot(1, 2, 1)\\n plt.imshow(image, 'gray', interpolation='nearest')\\n plt.subplot(1, 2, 2)\\n plt.imshow(image, 'gray', interpolation='nearest')\\n plt.imshow(masked, 'jet', interpolation='nearest', alpha=0.5)\\n plt.show()\",\n \"def _draw_mask_on_image(self, mask):\\n mask = self.STANDARD_COLORS_ARRAY[mask]\\n cv2.addWeighted(mask,self.config.ALPHA,self.image,1.0,0,self.image)\",\n \"def draw_mask(self, image, ship, dims):\\n # Get the center x, y and the size s\\n x, y, s, r, m = dims\\n\\n #Load files\\n if ship == 'cruiseship':\\n ma_path = 'ships/cruiseship_isolated_mask.png'\\n id = 1\\n elif ship == 'tanker':\\n ma_path = 'ships/tanker_isolated_mask.png'\\n id = 2\\n\\n #Transforming mask\\n mask = cv2.imread(ma_path)\\n mask_transformed = self.transform(mask.copy(), dims)\\n mask_shape = np.shape(mask_transformed)\\n s_x = int((mask_shape[0]+0.5)//2)\\n s_y = int((mask_shape[1]+0.5)//2)\\n mask_transformed = mask_transformed[0:np.shape(image[x-s_x:x+s_x, y-s_y:y+s_y, :])[0],\\n 0:np.shape(image[x-s_x:x+s_x, y-s_y:y+s_y, :])[1],\\n :]\\n\\n mask_transformed_th = self.threshold(mask_transformed)\\n\\n #Adding mask to image\\n image[x-s_x:x+s_x, y-s_y:y+s_y, :] = id/255*mask_transformed_th\\n\\n return image\",\n \"def load_mask_one_layer(self, image_id):\\r\\n mask_path = self.mask_path[self.ids[image_id]]\\r\\n file_pattern = os.path.join(mask_path, \\\"*.png\\\")\\r\\n info = self.image_info[image_id]\\r\\n mask_files = glob.glob(file_pattern)\\r\\n #mask_tmp = cv2.imread(mask_files[0])\\r\\n mask_new = np.zeros([info['width'], info['height'], mask_files.__len__()+1], dtype=np.uint8) # one more for background\\r\\n count = 1\\r\\n mask_total = 0\\r\\n for i in mask_files:\\r\\n mask = cv2.imread(i)\\r\\n mask = mask[:, :, 1] / 255.0\\r\\n #mask = ski_transform.resize(mask, (info['height'], info['width']), mode='reflect')\\r\\n mask_new[:, :, count] = (mask)\\r\\n mask_total = mask_total * (mask == 0)\\r\\n mask_total = mask_total + (mask>0) * count\\r\\n count = count + 1\\r\\n return mask_total\",\n \"def load_mask(self, image_id):\\n image_info = self.image_info[image_id]\\n if image_info[\\\"source\\\"] != \\\"face\\\":\\n return super(self.__class__, self).load_mask(image_id)\\n info = self.image_info[image_id]\\n mask = np.zeros([info['height'], info['width'], len(info['boundingbox'])], dtype=np.uint8)\\n for i, p in enumerate(info['boundingbox'].values()):\\n rr, cc = skimage.draw.polygon(p['y'], p['x'])\\n mask[rr, cc, i] = 1\\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)\",\n \"def getHitmask(image):\\n mask = []\\n for x in range(image.get_width()):\\n mask.append([])\\n for y in range(image.get_height()):\\n mask[x].append(bool(image.get_at((x,y))[3]))\\n return mask\",\n \"def getHitmask(image):\\n mask = []\\n for x in range(image.get_width()):\\n mask.append([])\\n for y in range(image.get_height()):\\n mask[x].append(bool(image.get_at((x,y))[3]))\\n return mask\",\n \"def getHitmask(image):\\n mask = []\\n for x in range(image.get_width()):\\n mask.append([])\\n for y in range(image.get_height()):\\n mask[x].append(bool(image.get_at((x,y))[3]))\\n return mask\",\n \"def makeMask( Tables, Mode ):\\n\\n # get data from the corresponding tables\\n ElasticModulusData = Tables[ \\\"ElasticModulus\\\" ].getRawData( )\\n ShearModulusData = Tables[ \\\"ShearModulus\\\" ].getRawData( )\\n PoissonRatiosData = Tables[ \\\"PoissonRatios\\\" ].getRawData( )\\n MaterialPropertiesData = Tables[ \\\"MaterialProperties\\\" ].getRawData( )\\n GeometryPropertiesData = Tables[ \\\"GeometryProperties\\\" ].getRawData( )\\n\\n\\n Tables[ \\\"MaterialProperties\\\" ].setBufferData( \\\"General\\\", MaterialPropertiesData )\\n\\n Tables[ \\\"GeometryProperties\\\" ].setBufferData( \\\"General\\\", GeometryPropertiesData )\\n\\n\\n if Mode == 0:\\n\\n Tables[ \\\"ElasticModulus\\\" ].setBufferData( \\\"GeneralOrthotropic\\\",\\n ElasticModulusData )\\n\\n Tables[ \\\"ShearModulus\\\" ].setBufferData( \\\"GeneralOrthotropic\\\",\\n ShearModulusData )\\n\\n Tables[ \\\"PoissonRatios\\\" ].setBufferData( \\\"GeneralOrthotropic\\\",\\n PoissonRatiosData )\\n\\n\\n elif Mode == 1:\\n\\n Tables[ \\\"ElasticModulus\\\" ].setBufferData( \\\"GeneralIsotropic\\\",\\n ElasticModulusData )\\n\\n Tables[ \\\"ShearModulus\\\" ].setBufferData( \\\"GeneralIsotropic\\\",\\n ShearModulusData )\\n\\n Tables[ \\\"PoissonRatios\\\" ].setBufferData( \\\"GeneralIsotropic\\\",\\n PoissonRatiosData )\",\n \"def GetMaskImage(self) -> \\\"itkImageUS2 const *\\\":\\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIUS2_GetMaskImage(self)\",\n \"def outline_to_mask(line, x, y):\\n mpath = mplp.Path(line)\\n X, Y = np.meshgrid(x, y)\\n points = np.array((X.flatten(), Y.flatten())).T\\n mask = mpath.contains_points(points).reshape(X.shape)\\n return mask\",\n \"def route_bitlines(self):\\n # adds the BL on metal 2\\n offset = vector(self.bitcell.get_pin(self.bitcell_bl).cx(),0) - vector(0.5 * self.m2_width,0)\\n self.add_layout_pin(text=\\\"bl\\\",\\n layer=\\\"metal2\\\",\\n offset=offset,\\n width=drc['minwidth_metal2'],\\n height=self.height)\\n\\n # adds the BR on metal 2\\n offset = vector(self.bitcell.get_pin(self.bitcell_br).cx(),0) - vector(0.5 * self.m2_width,0)\\n self.add_layout_pin(text=\\\"br\\\",\\n layer=\\\"metal2\\\",\\n offset=offset,\\n width=drc['minwidth_metal2'],\\n height=self.height)\",\n \"def edges(i):\\n Oxy = i.copy()\\n Kx = [-1, 0, 1, -2, 0, 2, -1, 0, 1]\\n Ky = [-1, -2, -1, 0, 0, 0, 1, 2, 1]\\n\\n Ox = correlate(i, Kx)\\n Oy = correlate(i,Ky)\\n\\n Oxy[\\\"pixels\\\"] = [ (x**2 + y**2)**(1/2) for x, y in zip(Ox[\\\"pixels\\\"], Oy[\\\"pixels\\\"])]\\n\\n result = round_and_clip_image(Oxy)\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6409335","0.6389279","0.63278013","0.6144017","0.61208165","0.61032546","0.6092377","0.60494506","0.60046375","0.60025907","0.5973677","0.5961888","0.5948796","0.59485275","0.5888697","0.5870006","0.58533627","0.58333975","0.58228105","0.5813124","0.5807416","0.580159","0.579338","0.5772188","0.5757274","0.57037526","0.5703511","0.5679529","0.5670779","0.565622","0.5647827","0.564725","0.5641768","0.5620053","0.5616392","0.5605545","0.5581712","0.5578086","0.55703264","0.5561449","0.55577433","0.55531734","0.5545946","0.5540725","0.5535255","0.55274147","0.5527272","0.5521666","0.55215544","0.55173886","0.5514728","0.5514665","0.54976124","0.54973257","0.54918873","0.5489841","0.5484597","0.54843765","0.54807997","0.5477644","0.547633","0.5467868","0.54665375","0.54601556","0.54570866","0.5449122","0.54456854","0.5443765","0.5441722","0.54385895","0.54384977","0.5434177","0.5415842","0.5410673","0.5398977","0.539672","0.53924614","0.5391677","0.53848714","0.53845996","0.5378761","0.5377635","0.53762764","0.5370782","0.53635466","0.5345498","0.53445905","0.534312","0.5340558","0.5334904","0.53305244","0.53225935","0.53195196","0.5312726","0.5312726","0.5312726","0.5293481","0.5292978","0.5292796","0.5292744","0.5289116"],"string":"[\n \"0.6409335\",\n \"0.6389279\",\n \"0.63278013\",\n \"0.6144017\",\n \"0.61208165\",\n \"0.61032546\",\n \"0.6092377\",\n \"0.60494506\",\n \"0.60046375\",\n \"0.60025907\",\n \"0.5973677\",\n \"0.5961888\",\n \"0.5948796\",\n \"0.59485275\",\n \"0.5888697\",\n \"0.5870006\",\n \"0.58533627\",\n \"0.58333975\",\n \"0.58228105\",\n \"0.5813124\",\n \"0.5807416\",\n \"0.580159\",\n \"0.579338\",\n \"0.5772188\",\n \"0.5757274\",\n \"0.57037526\",\n \"0.5703511\",\n \"0.5679529\",\n \"0.5670779\",\n \"0.565622\",\n \"0.5647827\",\n \"0.564725\",\n \"0.5641768\",\n \"0.5620053\",\n \"0.5616392\",\n \"0.5605545\",\n \"0.5581712\",\n \"0.5578086\",\n \"0.55703264\",\n \"0.5561449\",\n \"0.55577433\",\n \"0.55531734\",\n \"0.5545946\",\n \"0.5540725\",\n \"0.5535255\",\n \"0.55274147\",\n \"0.5527272\",\n \"0.5521666\",\n \"0.55215544\",\n \"0.55173886\",\n \"0.5514728\",\n \"0.5514665\",\n \"0.54976124\",\n \"0.54973257\",\n \"0.54918873\",\n \"0.5489841\",\n \"0.5484597\",\n \"0.54843765\",\n \"0.54807997\",\n \"0.5477644\",\n \"0.547633\",\n \"0.5467868\",\n \"0.54665375\",\n \"0.54601556\",\n \"0.54570866\",\n \"0.5449122\",\n \"0.54456854\",\n \"0.5443765\",\n \"0.5441722\",\n \"0.54385895\",\n \"0.54384977\",\n \"0.5434177\",\n \"0.5415842\",\n \"0.5410673\",\n \"0.5398977\",\n \"0.539672\",\n \"0.53924614\",\n \"0.5391677\",\n \"0.53848714\",\n \"0.53845996\",\n \"0.5378761\",\n \"0.5377635\",\n \"0.53762764\",\n \"0.5370782\",\n \"0.53635466\",\n \"0.5345498\",\n \"0.53445905\",\n \"0.534312\",\n \"0.5340558\",\n \"0.5334904\",\n \"0.53305244\",\n \"0.53225935\",\n \"0.53195196\",\n \"0.5312726\",\n \"0.5312726\",\n \"0.5312726\",\n \"0.5293481\",\n \"0.5292978\",\n \"0.5292796\",\n \"0.5292744\",\n \"0.5289116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14796,"cells":{"query":{"kind":"string","value":"Use The current values of Curvature and Offset from Left and Right Lanes to decide if Lanes are sane"},"document":{"kind":"string","value":"def curvature_sanity(left_curvature, left_offset, right_curvature, right_offset):\n if return_queue_len(flag='L') >= 1 and return_queue_len(flag='R') >= 1:\n offset = center_position - (left_offset + right_offset) / 2.\n offset_measure = np.abs(overall_offset - offset)\n return True if offset_measure < 0.2 else False\n else:\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _curvature(self):\n y_eval = self.left_fitx.shape[0] - 10\n left_curverad = (((1 + (2 * self.left_fit[0] * y_eval + self.left_fit[1]) ** 2) ** 1.5) /\n np.absolute(2 * self.left_fit[0]))\n right_curverad = (((1 + (2 * self.right_fit[0] * y_eval + self.right_fit[1]) ** 2) ** 1.5) /\n np.absolute(2 * self.right_fit[0]))\n return left_curverad, right_curverad","def sanity_check(self):\n score = 0\n curvatures = self._curvature()\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\n # difference in curvature is more than 15%\n score -= 1\n\n diff_std = np.std(self.right_fitx - self.left_fitx)\n if diff_std > 30:\n # std of the difference between the right lane and left lane is more than 30 pixel\n score -= 1\n\n # roughly parallel\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\n # difference in slope is more than 15%\n score -= 1\n\n return score","def GetLoCorner(self):\n ...","def fix_curvature(self) -> None:\n self.n1.fix = True\n self.n2.fix = True","def calculate_leg_xy_limits(self, visualize=False):\n \n #Find the fixed plate position at the \"0\" point\n gonio_zero = copy.copy(self)\n gonio_zero.relative_sample_position = column([0.0, 0.0, 0.0]) #Tell the sample to be centered well.\n gonio_zero.getplatepos(0.0, 0.0, 0.0)\n fixed_plate_zero = np.copy(gonio_zero.fixed_plate)\n #This defines the center of the following matrices\n self.fixed_plate_zero = fixed_plate_zero\n \n #Now we generate a matrix of allowed positions around those points.\n self.leg_safe_xaxis = np.arange(-self.travel, self.travel, self.leg_safe_resolution)\n self.leg_safe_zaxis = np.copy(self.leg_safe_xaxis)\n\n #Create the \"safe zone\" array, initialized to False\n self.leg_safe_zone = np.zeros( (3, self.leg_safe_xaxis.size, self.leg_safe_zaxis.size), dtype=bool ) \n\n #Now make a reasonable approximation\n real_travel_x = 12.5\n real_travel_z = real_travel_x\n for leg in range(3):\n for i_x in range(self.leg_safe_xaxis.size):\n x = self.leg_safe_xaxis[i_x]\n if abs(x)<real_travel_x:\n for i_z in range(self.leg_safe_zaxis.size):\n z = self.leg_safe_zaxis[i_z]\n if abs(z)<real_travel_z:\n self.leg_safe_zone[leg, i_x, i_z] = True\n# #Upper left corner of leg A (0)\n# center = int(len(self.leg_safe_xaxis)/2)\n# self.leg_safe_zone[0, :, :] = False\n# self.leg_safe_zone[0, :center, :center] = True\n# self.leg_safe_zone[1, :, :] = False\n# self.leg_safe_zone[1, center:, 0:center] = True\n# self.leg_safe_zone[2, :, :center] = False\n\n\n if visualize:\n pylab.figure(0)\n pylab.hold(True)\n for leg in range(3):\n pylab.pcolor(self.leg_safe_xaxis+fixed_plate_zero[COORD_X, leg], self.leg_safe_zaxis+fixed_plate_zero[COORD_Z, leg], self.leg_safe_zone[leg, :, :].transpose())\n pylab.xlabel(\"x\")\n pylab.ylabel(\"z\")\n pylab.title(\"Allowable XZ leg positions for the 3 legs.\")\n pylab.draw()\n pylab.axis('equal')\n #pylab.show()","def check_borders(self):\n # Go Homer!\n # https://en.wikipedia.org/wiki/Torus#Flat_torus\n if self._posn.x < 0:\n self._posn.x += self._win_w\n elif self._posn.x > self._win_w:\n self._posn.x -= self._win_w\n if self._posn.y < 0:\n self._posn.y += self._win_h\n elif self._posn.y > self._win_h:\n self._posn.y -= self._win_h","def check_boundary(self):\n\n\t\tif self.Bubble_initial_pos[0] <= self.Bubble_radius or self.Bubble_initial_pos[0] >= self.tk_pic.width - self.Bubble_radius:\n\t\t\tself.Bubble_vel[0] = -self.Bubble_vel[0]","def is_valid(self):\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\n return posit1 & posit2 & self.feller()","def detectBorders(self, points):\n lane1 = []; lane2 = []\n self.leftLane = [None for _ in range(int(np.floor(self.BIRDVIEW_HEIGHT / self.slideThickness)))]\n self.rightLane = [None for _ in range(int(np.floor(self.BIRDVIEW_HEIGHT / self.slideThickness)))]\n\n pointMap = np.zeros((points.shape[0], 20))\n prePoint = np.zeros((points.shape[0], 20))\n postPoint = np.zeros((points.shape[0], 20))\n\n dis = 10\n max1 = -1; max2 = -1\n\n ##\n ## /!\\ UNSAFE LOOP, TODO: FIX\n ##\n for i in range(points.shape[0]):\n for j in range(len(points[i])):\n pointMap[i][j] = 1\n prePoint[i][j] = -1\n postPoint[i][j] = -1\n\n for i in reversed(range(points.shape[0] - 2)):\n\n for j in range(len(points[i])):\n\n err = 320\n for m in range(1, min(points.shape[0] - 1 - i, 5)):\n check = False ## TODO: why unused ?\n\n for k in range(len(points[i + 1])):\n\n (x_m, y_m) = points[i + m][k].pt\n (x, y) = points[i][j].pt\n\n if (abs(x_m - x) < dis and abs(y_m - y) < err):\n err = abs(x_m - x)\n\n pointMap[i][j] = pointMap[i + m][k] + 1\n prePoint[i][j] = k\n postPoint[i + m][k] = j\n check = True\n\n break ## breaks out of the m loop. Why is it not conditioned by check ? TODO: ???\n\n if (pointMap[i][j] > max1):\n max1 = pointMap[i][j]\n posMax = cv2.KeyPoint(i, j, _size=0)\n \n else:\n posMax = None\n\n for i in range(points.shape[0]):\n for j in range(len(points[i])):\n if posMax:\n if (pointMap[i][j] > max2 and (i != posMax.pt[0] or j != posMax.pt[1]) and postPoint[i][j] == -1): #FIXME \"local variable 'posMax' referenced before assignment\" possible\n max2 = pointMap[i][j]\n posMax2 = cv2.KeyPoint(i, j, _size=0)\n\n\n\n if max1 == -1:\n return\n\n # DEFINES LANE 1 POINTS\n while (max1 >= 1):\n (x,y) = points[int(posMax.pt[0])][int(posMax.pt[1])].pt\n lane1.append(\n [x,y]\n )\n if (max1 == 1):\n break\n\n posMax = cv2.KeyPoint(\n posMax.pt[0]+1,\n prePoint[int(posMax.pt[0])][int(posMax.pt[1])],\n _size=0\n )\n\n max1 -= 1\n\n # DEFINES LANE 2 POINTS\n while (max2 >= 1):\n (x,y) = points[int(posMax2.pt[0])][int(posMax2.pt[1])].pt\n lane2.append(\n [x, y]\n )\n if (max2 == 1):\n break\n\n posMax2 = cv2.KeyPoint(\n posMax2.pt[0]+1,\n prePoint[int(posMax2.pt[0])][int(posMax2.pt[1])],\n _size=0\n )\n\n max2-= 1\n\n subLane1 = np.array(lane1[0:5])\n subLane2 = np.array(lane2[0:5])\n\n # checking if sublane has an empty value\n\n line1 = cv2.fitLine(subLane1, 2, 0, 0.01, 0.01)\n line2 = cv2.fitLine(subLane2, 2, 0, 0.01, 0.01)\n\n try:\n lane1X = (self.BIRDVIEW_WIDTH - line1[3]) * line1[0] / line1[1] + line1[2]\n except:\n lane1X = 0\n\n try:\n lane2X = (self.BIRDVIEW_WIDTH - line2[3]) * line2[0] / line2[1] + line2[2]\n except:\n lane2X = 0\n \n if (lane1X < lane2X):\n for i in range(len(lane1)):\n self.leftLane[int(np.floor(lane1[i][1] / self.slideThickness ))] = lane1[i]\n\n for i in range(len(lane2)):\n self.rightLane[int(np.floor(lane2[i][1] / self.slideThickness ))] = lane2[i]\n\n else:\n\n for i in range(len(lane1)):\n self.rightLane[int(np.floor(lane1[i][1] / self.slideThickness ))] = lane1[i]\n\n for i in range(len(lane2)):\n self.leftLane[int(np.floor(lane2[i][1] / self.slideThickness ))] = lane2[i]","def curvature(self):\n if self.x[0] == self.x[-1] and self.y[0] == self.y[-1]:\n x_looped=self.x\n y_looped=self.y\n else:\n x_looped=np.append(self.x,self.x[0])\n y_looped=np.append(self.y,self.y[0])\n\n dsx=np.diff(x_looped)\n dsy=np.diff(y_looped)\n ds=np.sqrt(dsx**2+dsy**2)\n Tx=dsx/ds\n Ty=dsy/ds\n ds2=0.5*(np.append(ds[-1],ds[:-1])+ds)\n if self.test:\n print('x_looped', x_looped)\n print('y_looped', y_looped)\n print('dsx', dsx)\n print('dsy', dsy)\n print('ds', ds)\n print('ds2', ds2)\n Hx=np.diff(np.append(Tx[-1],Tx))/ds2\n Hy=np.diff(np.append(Ty[-1],Ty))/ds2\n self._curvature_vector=np.asarray([Hx,Hy]).transpose()\n curvature=np.sqrt(Hx**2+Hy**2)\n if self.test:\n print('curvature', curvature)\n return curvature","def check_point_left(nodeL, nodeR, city):\n A = get_city_points(city)\n B = get_node_points(nodeR)\n C = get_node_points(nodeL)\n slope = _slope(A, B)\n (F, G) = calibrator(A, B, slope)\n sign = math.copysign(1, ((G[0] - F[0]) * (C[1] - F[1]) - (G[1] - F[1]) * (C[0] - F[0])))\n\n if slope == \"horizontal\":\n if sign == -1:\n if A[0] > B[0]:\n return True\n else:\n return False\n else:\n if A[0] < B[0]:\n return True\n else:\n return False\n\n if slope == \"vertical\":\n if sign == -1:\n if A[1] < B[1]:\n return True\n else:\n return False\n else:\n if A[1] > B[1]:\n return True\n else:\n return False\n\n if slope == \"inclined\":\n if sign == -1:\n if A[1] < B[1]:\n return True\n else:\n return False\n else:\n if A[1] > B[1]:\n return True\n else:\n return False\n\n if slope == \"declined\":\n if sign == -1:\n if A[1] < B[1]:\n return True\n else:\n return False\n else:\n if A[1] > B[1]:\n return True\n else:\n return False","def boundaries_and_initialize():\n greenLower = (29, 86, 6) # define the lower and upper boundaries of the \"green\"\n greenUpper = (64, 255, 255)\n pts = [((200,300),(255,255,255), 0)]\n blanks = []\n linecolor = (0,0,0)\n counter = 1\n radius = 11\n return greenLower, greenUpper, pts, linecolor, counter, blanks, radius","def _calc_side(self):\n\n # Calculation of the side of the car with respect to the trajectory\n next_index = self.index + 1\n\n if next_index == len(self.x_trajectory):\n next_index = self.index\n\n trajectory_vector = ((self.x_trajectory[next_index]\n - self.x_trajectory[self.index]),\n (self.y_trajectory[next_index]\n - self.y_trajectory[self.index]))\n\n x_diff = self.x - self.x_trajectory[self.index]\n y_diff = self.y - self.y_trajectory[self.index]\n\n ugv_vector = (x_diff, y_diff)\n\n vector_z = ugv_vector[0] * trajectory_vector[1] \\\n - ugv_vector[1] * trajectory_vector[0]\n\n if vector_z >= 0:\n\n # It is in the right side\n self.sign = 1\n\n else:\n\n # It is in the left side\n self.sign = -1\n\n return self.sign","def getVisualFieldOrigin(self):\r\n\r\n if not hasattr(self, 'finalPatchesMarked'):\r\n raise LookupError('Please mark the final patches first!!')\r\n\r\n if not hasattr(self, 'altPosMapf'):\r\n _ = self._getSignMap()\r\n\r\n try:\r\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\r\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\r\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\r\n\r\n overlap = 0 # number of overlaping pixels\r\n iterNum = 1 # number of iteration\r\n while overlap < 1:\r\n # print 'Iteration number for finding overlapping pixel:', iterNum\r\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\r\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\r\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\r\n totalField = V1 + LM + RL\r\n # plt.imshow(totalField)\r\n overlap = len(np.argwhere(totalField == 3))\r\n iterNum += 1\r\n # print 'Number of overlapping pixels:', overlap\r\n # plt.show()\r\n\r\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\r\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\r\n\r\n except KeyError:\r\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\nSetting origins to 0 ...')\r\n altPosOrigin = 0.\r\n aziPosOrigin = 0.\r\n\r\n return altPosOrigin, aziPosOrigin","def lefton(hedge, point):\r\n\r\n return area2(hedge, point) >= 0","def test_velocity_boundaries(self):\n L_x = self.x_edge[-1]\n np.testing.assert_array_almost_equal(self.v_box(self.t, 0), 0, decimal=4)\n np.testing.assert_array_almost_equal(self.v_box(self.t, L_x), 0, decimal=4)","def detect_boundary(self, x, l_old):\n pass","def measure_curvature(self, warped, leftx, rightx):\n\t\t# Define conversions in x and y from pixels space to meters\n\t\t#xm_per_pix = 3.7/warped.shape[1] # meters per pixel in x dimension\n\t\t#ym_per_pix = 30.0/warped.shape[0] # meters per pixel in y dimension\n\t\txm_per_pix = 3.7/700 # meters per pixel in x dimension\n\t\tym_per_pix = 30.0/720 # meters per pixel in y dimension\n\t\t# Generate some fake data to represent lane-line pixels\n\t\tploty = np.linspace(0, 719, num=720) # to cover same y-range as image\n\t\t# Fit second order polynomials to x, y in world space\n\t\tleft_fit_cr = np.polyfit(ploty * ym_per_pix, leftx * xm_per_pix, 2)\n\t\tright_fit_cr = np.polyfit(ploty * ym_per_pix, rightx * xm_per_pix, 2)\n\t\t# Define y-value where we want radius of curvature\n\t\t# Choose the maximum y-value, corresponding to the bottom of the image\n\t\ty_eval = np.max(ploty)\n\t\t# Calculate radius of fitted curvature\n\t\tleft_curverad = ((1 + (2 * left_fit_cr[0] * y_eval * ym_per_pix + left_fit_cr[1]) ** 2) ** 1.5) / np.absolute(2 * left_fit_cr[0])\n\t\tright_curverad = ((1 + (2 * right_fit_cr[0] * y_eval * ym_per_pix + right_fit_cr[1]) ** 2) ** 1.5) / np.absolute(2 * right_fit_cr[0])\n\t\t# Calculate the lane deviation\n\t\tlane_deviation = self.lane_deviation(warped, xm_per_pix)\n\n\t\treturn left_curverad, right_curverad, lane_deviation","def near_way(self):\r\n\r\n prey_position = np.array(self.prey.position)\r\n actual_position = np.array(self.previous_data[-1])\r\n previous_position = np.array(self.previous_data[-2])\r\n\r\n difference_actual = np.linalg.norm(prey_position - actual_position)\r\n difference_previous = np.linalg.norm(prey_position - previous_position)\r\n\r\n if difference_actual < difference_previous:\r\n return True\r\n else:\r\n return False","def offset(x, y, L):\n length = x.size\n offsetx = np.zeros((length, 2))\n offsety = np.zeros((length, 2))\n dx = np.zeros(length-1)\n dy = np.zeros(length-1)\n dxL = np.zeros(length-1)\n dyL = np.zeros(length-1)\n xl = np.zeros(length) # counterclockwise\n xr = np.zeros(length) # clockwise\n yl = np.zeros(length)\n yr = np.zeros(length)\n xl0 = np.zeros(length)\n xr0 = np.zeros(length)\n yl0 = np.zeros(length)\n yr0 = np.zeros(length) \n for i in range(0, length-1):\n dx[i] = x[i+1]-x[i]\n dy[i] = y[i+1]-y[i]\n for i in range(0, length-1):\n r = np.sqrt(dx[i]**2 + dy[i]**2)\n dxL[i] = dx[i]*L/r\n dyL[i] = dy[i]*L/r\n xl0[i] = -dyL[i] + x[i]\n yl0[i] = dxL[i] + y[i]\n xr0[i] = dyL[i] + x[i]\n yr0[i] = -dxL[i] + y[i]\n xl0[length-1] = xl0[length-2] + dx[length-2]\n yl0[length-1] = yl0[length-2] + dy[length-2]\n xr0[length-1] = xr0[length-2] + dx[length-2]\n yr0[length-1] = yr0[length-2] + dy[length-2]\n xl[0] = xl0[0]\n yl[0] = yl0[0]\n xl[length-1] = xl0[length-1]\n yl[length-1] = yl0[length-1]\n xr[0] = xr0[0]\n yr[0] = yr0[0]\n xr[length-1] = xr0[length-1]\n yr[length-1] = yr0[length-1]\n for i in range(1, length-1):\n a = np.array([[dy[i-1], -dx[i-1]], [dy[i], -dx[i]]])\n bl = np.array([dy[i-1]*xl0[i-1]-dx[i-1]*yl0[i-1], dy[i]*xl0[i]-dx[i]*yl0[i]])\n br = np.array([dy[i-1]*xr0[i-1]-dx[i-1]*yr0[i-1], dy[i]*xr0[i]-dx[i]*yr0[i]])\n theta = (dx[i-1]*dx[i]+dy[i-1]*dy[i])/(dx[i-1]**2+dy[i-1]**2)**0.5/(dx[i]**2+dy[i]**2)**0.5\n if theta > 1 - 1e-10:\n xl[i] = xl0[i]\n yl[i] = yl0[i]\n xr[i] = xr0[i]\n yr[i] = yr0[i]\n else:\n pl = np.linalg.solve(a, bl)\n xl[i] = pl[0]\n yl[i] = pl[1]\n pr = np.linalg.solve(a, br)\n xr[i] = pr[0]\n yr[i] = pr[1]\n offsetx[:, 0], offsetx[:, 1] = xl, xr\n offsety[:, 0], offsety[:, 1] = yl, yr\n return offsetx, offsety","def maybe_rectal(self):\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))","def find_field_angle(self) -> None:\r\n\r\n # Gather required info\r\n size = self.picture.get_size()\r\n \r\n # Make a center box in the field\r\n # Make sure there are no more than 50 plants in this box\r\n smol = 5\r\n while len([i\r\n for i in self.plants\r\n if within(i.get_center(), (smol//2*size[0]//smol,\r\n smol//2*size[1]//smol,\r\n (smol//2+1)*size[0]//smol,\r\n (smol//2+1)*size[1]//smol))]\r\n ) > 50:\r\n \r\n smol += 1\r\n\r\n small_box = (2*size[0]//smol,\r\n 2*size[1]//smol,\r\n 3*size[0]//smol,\r\n 3*size[1]//smol)\r\n\r\n slopes = []\r\n\r\n # iterate throught the centers of all plants in the box \r\n for pivot in [i for i in self.centers if within(i, small_box)]:\r\n\r\n # Get a pivot point within the small_box\r\n pivot = (-1, -1)\r\n while not within(pivot, small_box):\r\n pivot = choice(self.centers)\r\n\r\n # Initialize variables\r\n best_slope = 0\r\n percent_green = 0\r\n\r\n # Go throught all of the plants within the small_box\r\n for i in self.centers:\r\n if within(i, small_box) and i != pivot:\r\n\r\n # Determine how much green a line draw\r\n # from the pivot to the new point hits\r\n try:\r\n slope = (pivot[1] - i[1]) / (pivot[0] - i[0])\r\n except ZeroDivisionError:\r\n continue\r\n PGOL = self.picture.percent_plant_on_line(i, slope)\r\n\r\n # If the green hit is more than the current green,\r\n # replace it\r\n if PGOL > percent_green:\r\n best_slope = slope\r\n percent_green = PGOL\r\n\r\n # Save the best slope\r\n slopes.append(best_slope)\r\n\r\n # Find and set the median of all the best slopes\r\n self.slope = median(slopes)","def _ul_lr(self):\n ulx, xres, xskew, uly, yskew, yres = self.geotransform\n # Index from the end - GDal usually orders bands-first:\n lrx = ulx + (self.array.shape[-2] * xres)\n lry = uly + (self.array.shape[-1] * yres)\n return ulx, uly, lrx, lry","def increase_left_boundary(self):\n self.L = self.L - 1.0\n self.Ne = self.Ne + 1","def detectWallCollision(self):\n if self.right >= GAME_WIDTH or self.left <= 0:\n self._vx = -1.0 * self._vx\n if self.top >= GAME_HEIGHT:\n self._vy = -1.0 * self._vy","def __isFarFromLevel(self, l):\n\n s = np.mean(self.df['high'] - self.df['low'])\n return np.sum([abs(l-x) < s for x in self.levels]) == 0","def check_extent(self):\n if self.lower_left.x > self.upper_right.x:\n dlx = self.lower_left.x\n self.lower_left.x = self.upper_right.x\n self.upper_right.y = dlx\n\n if self.lower_left.y > self.upper_right.y:\n dly = self.lower_left.y\n self.lower_left.y = self.upper_right.y\n self.upper_right.y = dly","def test_non_euclidean_scale_curvature(self):\n\n magic = 77773.333773777773733\n for kdir in (1, -1):\n for mul in (2, 5, 1/3, 1/11, magic, 1/magic):\n for name, dim in (\n ('sphere_s1', 1),\n ('sphere_v2', 2),\n ('sphere_s2', 2),\n ('sphere_v3', 3)\n ):\n s1 = space(fake_curvature=kdir)\n s2 = space(fake_curvature=kdir / mul)\n self.assertTrue(isclose(\n getattr(s1, name)(1) * mul**dim,\n getattr(s2, name)(mul)\n ))","def check(self):\n\n # get values\n ystart, xleft, xright, nx, ny = self.get()\n\n # are they all OK individually?\n ok = self.ystart.ok() and self.xleft.ok() and self.xright.ok() and \\\n self.nx.ok() and self.ny.ok()\n\n # now come cross-value checks:\n\n # is rightmost pixel of lefthand window within range\n if xleft is None or xleft + nx - 1 > 512:\n self.xleft.config(bg=COL_WARN)\n ok = False\n\n # is rightmost pixel of righthand window within range\n if xright is None or xright + nx - 1 > 1024:\n self.xright.config(bg=COL_WARN)\n ok = False\n\n # is top pixel within range\n if ystart is None or ystart + ny - 1 > 1024:\n self.ystart.config(bg=COL_WARN)\n ok = False\n\n if ok:\n # set all OK is everything checks\n self.ystart.config(bg=COL_TEXT_BG)\n self.xleft.config(bg=COL_TEXT_BG)\n self.xright.config(bg=COL_TEXT_BG)\n self.nx.config(bg=COL_TEXT_BG)\n self.ny.config(bg=COL_TEXT_BG)\n \n return ok","def find_reference_radials(azi, vel, debug=False):\n pos_valid = get_valid_rays(vel)\n pos_static = get_static_rays(vel)\n\n # Finding intersects of criteria 1 to 3.\n weight_valid = np.arange(0, len(pos_valid), 1)\n weight_static = np.arange(0, len(pos_static), 1)\n\n total_weight = np.zeros(len(pos_valid)) + np.NaN\n for cnt, (one_valid, one_valid_weight) in enumerate(zip(pos_valid, weight_valid)):\n try:\n one_static_weight = weight_static[one_valid == pos_static][0]\n except IndexError:\n one_static_weight = 9999\n\n total_weight[cnt] = one_static_weight + one_valid_weight\n\n pos1 = pos_valid[np.argmin(total_weight)]\n\n# # Finding the 2nd radial of reference\n# pos2 = pos1 + len(azi) // 2\n# if pos2 >= len(azi):\n# pos2 -= len(azi)\n\n try:\n ref2_range_min, ref2_range_max = get_opposite_azimuth(azi[pos1])\n if ref2_range_min < ref2_range_max:\n goodpos = np.where((azi >= ref2_range_min) & (azi <= ref2_range_max))[0]\n else:\n goodpos = np.where((azi >= ref2_range_min) | (azi <= ref2_range_max))[0]\n\n rslt = [(a, total_weight[a == pos_valid][0]) for a in goodpos if a in pos_valid]\n opposite_pos, opposite_weight = zip(*rslt)\n pos2 = opposite_pos[np.argmin(opposite_weight)]\n except Exception:\n pos2 = pos1 + len(azi) // 2\n if pos2 > len(azi):\n pos2 -= len(azi)\n if debug:\n print(f\"References are azimuths {azi[pos1]} and {azi[pos2]}, i.e. azimuthal positions {pos1} and {pos2}.\")\n\n return pos1, pos2","def _GetHorizonAnglesLegacy(its_elev, height_cbsd, height_rx, refractivity):\n num_points = int(its_elev[0])\n step = its_elev[1]\n dist = num_points * step\n\n # Find the refractivity at the average terrain height\n start_avg = int(3.0 + 0.1 * num_points)\n end_avg = num_points - start_avg + 6\n zsys = np.mean(its_elev[start_avg-1:end_avg])\n refractivity *= np.exp(-zsys/9460.0)\n\n # Find the ray down-curvature per meter\n gma = 157e-9\n gme = gma*(1.0 - 0.04665 * np.exp(refractivity/179.3))\n\n alt_cbsd = its_elev[2] + height_cbsd\n alt_rx = its_elev[num_points+2] + height_rx\n qc = 0.5 * gme\n q = qc * dist\n # theta0 and theta1 the slopes, dl0 and dl1 the horizon distances\n theta1 = (alt_rx - alt_cbsd) / dist\n theta0 = theta1 - q\n theta1 = -theta1 - q\n dl0 = dist\n dl1 = dist\n\n if num_points >= 2:\n sa = 0.0\n sb = dist\n wq = True\n for i in range(1, num_points):\n sa += step\n sb -= step\n q = its_elev[i+2] - (qc*sa + theta0) * sa - alt_cbsd\n if q > 0.0:\n theta0 += q/sa\n dl0 = sa\n wq = False\n if not wq:\n q = its_elev[i+2] - (qc*sb + theta1) * sb - alt_rx\n if q > 0.0:\n theta1 += q/sb\n dl1 = sb\n\n return (np.arctan(theta0) * 180/np.pi,\n np.arctan(theta1) * 180/np.pi,\n dl0,\n dl1)","def box_valid(self):\n return ((self.lt.x >= 0)\n and (self.lt.y >= 0)\n and (self.rb.x >= self.lt.x)\n and (self.rb.y >= self.lt.y))","def _get_valid_index(lons_side1, lons_side2, lons_side3, lons_side4,\n lats_side1, lats_side2, lats_side3, lats_side4,\n lons, lats, radius_of_influence):\n\n # Coarse reduction of data based on extrema analysis of the boundary\n # lon lat values of the target grid\n illegal_lons = (((lons_side1 < -180) | (lons_side1 > 180)).any() or\n ((lons_side2 < -180) | (lons_side2 > 180)).any() or\n ((lons_side3 < -180) | (lons_side3 > 180)).any() or\n ((lons_side4 < -180) | (lons_side4 > 180)).any())\n\n illegal_lats = (((lats_side1 < -90) | (lats_side1 > 90)).any() or\n ((lats_side2 < -90) | (lats_side2 > 90)).any() or\n ((lats_side3 < -90) | (lats_side3 > 90)).any() or\n ((lats_side4 < -90) | (lats_side4 > 90)).any())\n\n if illegal_lons or illegal_lats:\n # Grid boundaries are not safe to operate on\n return np.ones(lons.size, dtype=np.bool)\n\n # Find sum angle sum of grid boundary\n angle_sum = 0\n for side in (lons_side1, lons_side2, lons_side3, lons_side4):\n prev = None\n side_sum = 0\n for lon in side:\n if prev:\n delta = lon - prev\n if abs(delta) > 180:\n delta = (abs(delta) - 360) * (delta // abs(delta))\n angle_sum += delta\n side_sum += delta\n prev = lon\n\n # Buffer min and max lon and lat of interest with radius of interest\n lat_min = min(lats_side1.min(), lats_side2.min(), lats_side3.min(),\n lats_side4.min())\n lat_min_buffered = lat_min - float(radius_of_influence) / R\n lat_max = max(lats_side1.max(), lats_side2.max(), lats_side3.max(),\n lats_side4.max())\n lat_max_buffered = lat_max + float(radius_of_influence) / R\n\n max_angle_s2 = max(abs(lats_side2.max()), abs(lats_side2.min()))\n max_angle_s4 = max(abs(lats_side4.max()), abs(lats_side4.min()))\n lon_min_buffered = (lons_side4.min() -\n float(radius_of_influence) /\n (np.sin(np.radians(max_angle_s4)) * R))\n\n lon_max_buffered = (lons_side2.max() +\n float(radius_of_influence) /\n (np.sin(np.radians(max_angle_s2)) * R))\n\n # From the winding number theorem follows:\n # angle_sum possiblilities:\n # -360: area covers north pole\n # 360: area covers south pole\n # 0: area covers no poles\n # else: area covers both poles\n if round(angle_sum) == -360:\n # Covers NP\n valid_index = (lats >= lat_min_buffered)\n elif round(angle_sum) == 360:\n # Covers SP\n valid_index = (lats <= lat_max_buffered)\n elif round(angle_sum) == 0:\n # Covers no poles\n valid_lats = (lats >= lat_min_buffered) * (lats <= lat_max_buffered)\n\n if lons_side2.min() > lons_side4.max():\n # No date line crossing\n valid_lons = (lons >= lon_min_buffered) * \\\n (lons <= lon_max_buffered)\n else:\n # Date line crossing\n seg1 = (lons >= lon_min_buffered) * (lons <= 180)\n seg2 = (lons <= lon_max_buffered) * (lons >= -180)\n valid_lons = seg1 + seg2\n\n valid_index = valid_lats * valid_lons\n else:\n # Covers both poles don't reduce\n valid_index = np.ones(lons.size, dtype=np.bool)\n\n return valid_index","def nodalLaplacian(self):\n if getattr(self, '_nodalLaplacian', None) is None:\n print('Warning: Laplacian has not been tested rigorously.')\n # The number of cell centers in each direction\n n = self.vnC\n # Compute divergence operator on faces\n if(self.dim == 1):\n D1 = sdiag(1./self.hx) * ddx(self.nCx)\n L = - D1.T*D1\n elif(self.dim == 2):\n D1 = sdiag(1./self.hx) * ddx(n[0])\n D2 = sdiag(1./self.hy) * ddx(n[1])\n L1 = sp.kron(speye(n[1]+1), - D1.T * D1)\n L2 = sp.kron(- D2.T * D2, speye(n[0]+1))\n L = L1 + L2\n elif(self.dim == 3):\n D1 = sdiag(1./self.hx) * ddx(n[0])\n D2 = sdiag(1./self.hy) * ddx(n[1])\n D3 = sdiag(1./self.hz) * ddx(n[2])\n L1 = kron3(speye(n[2]+1), speye(n[1]+1), - D1.T * D1)\n L2 = kron3(speye(n[2]+1), - D2.T * D2, speye(n[0]+1))\n L3 = kron3(- D3.T * D3, speye(n[1]+1), speye(n[0]+1))\n L = L1 + L2 + L3\n self._nodalLaplacian = L\n return self._nodalLaplacian","def R_will_change_direction(point0, point1, point2):\n\n x0, y0 = point0[0], point0[1]\n x1, y1 = point1[0], point1[1]\n x2, y2 = point2[0], point2[1]\n\n try:\n m1 = (x1 - x2) / (y2 - y1)\n m2 = (y2 - y1) / (x2 - x1)\n x3 = ((m2 * x1) - (m1 * x0) - y1 + y0) / (m2 - m1)\n y3 = m1 * (x3 - x0) + y0\n except ZeroDivisionError:\n (x3, y3) = (x0, y1) if y1 == y2 else (x1, y0)\n\n return ((min(x1, x2) <= x3 <= max(x1, x2)) and (min(y1, y2) <= y3 <= max(y1, y2))), (x3, y3)","def isOutsideBorder(self):\n if (self.posX < -self.myGalaxy.worldWidth or self.posX > self.myGalaxy.worldWidth or\n self.posY < -self.myGalaxy.worldHeight or self.posY > self.myGalaxy.worldHeight):\n return 1\n return 0","def In_northIsland(lon, lat):\n centre_lat = -37.651034\n centre_lon = 175.435162\n\n L_lat = -34.104810\n L_lon = 172.823488\n\n W_lat = -38.888624\n W_lon = 172.315141\n\n theta = -329.0\n\n x0 = centre_lon\n y0 = centre_lat\n x = lon\n y = lat\n\n xp = np.cos(theta * np.pi / 180.0) * (x - x0) - np.sin(theta * np.pi / 180.0) * (\n y - y0\n )\n yp = np.sin(theta * np.pi / 180.0) * (x - x0) + np.cos(theta * np.pi / 180.0) * (\n y - y0\n )\n\n xp_L = np.cos(theta * np.pi / 180.0) * (L_lon - x0) - np.sin(\n theta * np.pi / 180.0\n ) * (L_lat - y0)\n yp_L = np.sin(theta * np.pi / 180.0) * (L_lon - x0) + np.cos(\n theta * np.pi / 180.0\n ) * (L_lat - y0)\n L = np.sqrt(xp_L**2 + yp_L**2)\n\n xp_W = np.cos(theta * np.pi / 180.0) * (W_lon - x0) - np.sin(\n theta * np.pi / 180.0\n ) * (W_lat - y0)\n yp_W = np.sin(theta * np.pi / 180.0) * (W_lon - x0) + np.cos(\n theta * np.pi / 180.0\n ) * (W_lat - y0)\n W = np.sqrt(xp_W**2 + yp_W**2)\n\n if np.abs(xp) <= L and np.abs(yp) <= W:\n within_southIsland = True\n else:\n within_southIsland = False\n\n return within_southIsland","def corner_init_check():\r\n \"\"\"Rule One\"\"\"\r\n z = shape-1\r\n if example[0, 0] == example[0, 1] and example[0, 0] == example[1, 0] and example[0, 0] != 0: # NE\r\n example[0, 0] = 0\r\n shade_neighbours(0, 0)\r\n print(\"RULE 1 NW\")\r\n if example[0, z] == example[0, z-1] and example[0, z] == example[1, z] and example[0, z] != 0: # NW\r\n example[0, z] = 0\r\n shade_neighbours(0, z)\r\n print(\"RULE 1 NE\")\r\n if example[z, z] == example[z, z-1] and example[z, z] == example[z-1, z] and example[z, z] != 0: # SE\r\n example[z, z] = 0\r\n shade_neighbours(z, z)\r\n print(\"RULE 1 SE\")\r\n if example[z, 0] == example[z, 1] and example[z, 0] == example[z-1, 0] and example[z, 0] != 0: # SW\r\n example[z, 0] = 0\r\n shade_neighbours(z, 0)\r\n print(\"RuLE 1 SW\")\r\n\r\n \"\"\"Rule Two\"\"\"\r\n if (example[0, 0] == example[0, 1] or example[0, 0] == example[1, 0]) \\\r\n and (example[1, 1] == example[0, 1] or example[1, 1] == example[1, 0])\\\r\n and (example[0, 0] != example[1, 1]): # NE\r\n example[0, 0] = 0\r\n example[1, 1] = 0\r\n shade_neighbours(1, 1)\r\n print(\"RULE 2 NW\")\r\n if (example[0, z] == example[0, z-1] or example[0, z] == example[1, z]) \\\r\n and (example[1, z-1] == example[0, z-1] or example[1, z-1] == example[1, z]) \\\r\n and (example[0, z] != example[1, z-1]): # NW\r\n example[0, z] = 0\r\n example[1, z-1] = 0\r\n shade_neighbours(1, z - 1)\r\n print(\"RULE 2 NE\")\r\n if (example[z, z] == example[z, z-1] or example[z, z] == example[z-1, z]) \\\r\n and (example[z-1, z-1] == example[z-1, z] or example[z-1, z-1] == example[z, z-1]) \\\r\n and (example[z, z] != example[z-1, z-1]): # SE\r\n example[z, z] = 0\r\n example[z-1, z-1] = 0\r\n shade_neighbours(z - 1, z - 1)\r\n print(\"RULE 2 SE\")\r\n if (example[z, 0] == example[z, 1] or example[z, 0] == example[z-1, 0]) \\\r\n and (example[z-1, 1] == example[z, 1] or example[z-1, 1] == example[z-1, 0]) \\\r\n and (example[z, 0] != example[z-1, 1]): # SW\r\n example[z, 0] = 0\r\n example[z-1, 1] = 0\r\n shade_neighbours(z - 1, 1)\r\n print(\"RULE 2 SW\")\r\n conflict_check()","def computeNormalAndCurvature():\n radius = 50\n for i,j in pts:\n nb_pts = ti.cast(0, ti.f32)\n accu_0 = ti.cast(0, ti.f32)\n accu_1 = ti.cast(0, ti.f32)\n accu_2 = ti.cast(0, ti.f32)\n accu_3 = ti.cast(0, ti.f32)\n accu_4 = ti.cast(0, ti.f32)\n accu_5 = ti.cast(0, ti.f32)\n accu_6 = ti.cast(0, ti.f32)\n accu_7 = ti.cast(0, ti.f32)\n accu_8 = ti.cast(0, ti.f32)\n z = 0\n for x in range(i-radius, i+radius):\n for y in range(j-radius, j+radius):\n if ti.is_active(block1, [x,y]):\n accu_0 += x * x\n accu_1 += x * y\n accu_2 += x * z\n accu_3 += y * y\n accu_4 += y * z\n accu_5 += z * z\n accu_6 += x\n accu_7 += y\n accu_8 += z\n nb_pts += 1\n accu_0 /= nb_pts\n accu_1 /= nb_pts\n accu_2 /= nb_pts\n accu_3 /= nb_pts\n accu_4 /= nb_pts\n accu_5 /= nb_pts\n accu_6 /= nb_pts\n accu_7 /= nb_pts\n accu_8 /= nb_pts\n cov_mat_0 = accu_0 - accu_6 * accu_6\n cov_mat_1 = accu_1 - accu_6 * accu_7\n cov_mat_2 = accu_2 - accu_6 * accu_8\n cov_mat_4 = accu_3 - accu_7 * accu_7\n cov_mat_5 = accu_4 - accu_7 * accu_8\n cov_mat_8 = accu_5 - accu_8 * accu_8\n cov_mat_3 = cov_mat_1\n cov_mat_6 = cov_mat_2\n cov_mat_7 = cov_mat_5\n\n # Compute eigen value and eigen vector\n # Make sure in [-1, 1]\n scale = ti.max(1.0, ti.abs(cov_mat_0))\n scale = ti.max(scale, ti.abs(cov_mat_1))\n scale = ti.max(scale, ti.abs(cov_mat_2))\n scale = ti.max(scale, ti.abs(cov_mat_3))\n scale = ti.max(scale, ti.abs(cov_mat_4))\n scale = ti.max(scale, ti.abs(cov_mat_5))\n scale = ti.max(scale, ti.abs(cov_mat_6))\n scale = ti.max(scale, ti.abs(cov_mat_7))\n scale = ti.max(scale, ti.abs(cov_mat_8))\n if scale > 1.0:\n cov_mat_0 /= scale\n cov_mat_1 /= scale\n cov_mat_2 /= scale\n cov_mat_3 /= scale\n cov_mat_4 /= scale\n cov_mat_5 /= scale\n cov_mat_6 /= scale\n cov_mat_7 /= scale\n cov_mat_8 /= scale\n \n # Compute roots\n eigen_val_0 = ti.cast(0, ti.f32)\n eigen_val_1 = ti.cast(0, ti.f32)\n eigen_val_2 = ti.cast(0, ti.f32)\n \n c0 = cov_mat_0 * cov_mat_4 * cov_mat_8 \\\n + 2 * cov_mat_3 * cov_mat_6 * cov_mat_7 \\\n - cov_mat_0 * cov_mat_7 * cov_mat_7 \\\n - cov_mat_4 * cov_mat_6 * cov_mat_6 \\\n - cov_mat_8 * cov_mat_3 * cov_mat_3\n c1 = cov_mat_0 * cov_mat_4 \\\n - cov_mat_3 * cov_mat_3 \\\n + cov_mat_0 * cov_mat_8 \\\n - cov_mat_6 * cov_mat_6 \\\n + cov_mat_4 * cov_mat_8 \\\n - cov_mat_7 * cov_mat_7\n c2 = cov_mat_0 + cov_mat_4 + cov_mat_8\n \n if ti.abs(c0) < 0.00001:\n eigen_val_0 = 0\n d = c2 * c2 - 4.0 * c1\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\n d = 0.0\n sd = ti.sqrt(d)\n eigen_val_2 = 0.5 * (c2 + sd)\n eigen_val_1 = 0.5 * (c2 - sd)\n else:\n s_inv3 = ti.cast(1.0 / 3.0, ti.f32)\n s_sqrt3 = ti.sqrt(3.0)\n c2_over_3 = c2 * s_inv3\n a_over_3 = (c1 - c2 * c2_over_3) * s_inv3\n if a_over_3 > 0:\n a_over_3 = 0\n \n half_b = 0.5 * (c0 + c2_over_3 * (2 * c2_over_3 * c2_over_3 - c1))\n q = half_b * half_b + a_over_3 * a_over_3 * a_over_3\n if q > 0:\n q = 0\n \n rho = ti.sqrt(-a_over_3)\n theta = ti.atan2(ti.sqrt(-q), half_b) * s_inv3\n cos_theta = ti.cos(theta)\n sin_theta = ti.sin(theta)\n eigen_val_0 = c2_over_3 + 2 * rho * cos_theta\n eigen_val_1 = c2_over_3 - rho * (cos_theta + s_sqrt3 * sin_theta)\n eigen_val_2 = c2_over_3 - rho * (cos_theta - s_sqrt3 * sin_theta)\n temp_swap = ti.cast(0, ti.f32)\n \n # Sort in increasing order.\n if eigen_val_0 >= eigen_val_1:\n temp_swap = eigen_val_1\n eigen_val_1 = eigen_val_0\n eigen_val_0 = temp_swap\n if eigen_val_1 >= eigen_val_2:\n temp_swap = eigen_val_2\n eigen_val_2 = eigen_val_1\n eigen_val_1 = temp_swap\n if eigen_val_0 >= eigen_val_1:\n temp_swap = eigen_val_1\n eigen_val_1 = eigen_val_0\n eigen_val_0 = temp_swap\n \n if eigen_val_0 <= 0:\n eigen_val_0 = 0\n d = c2 * c2 - 4.0 * c1\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\n d = 0.0\n sd = ti.sqrt(d)\n eigen_val_2 = 0.5 * (c2 + sd)\n eigen_val_1 = 0.5 * (c2 - sd)\n # end of compute roots\n\n eigen_value = eigen_val_1 * scale # eigen value for 2D SDF\n # eigen value for 3D SDF\n #eigen_value = eigen_val_0 * scale\n\n #print(\"eigen_val_0 \", eigen_val_0)\n #print(\"eigen_val_1 \", eigen_val_1)\n #print(\"eigen_val_2 \", eigen_val_2)\n \n # TODO\n #scaledMat.diagonal ().array () -= eigenvalues (0)\n #eigenvector = detail::getLargest3x3Eigenvector<Vector> (scaledMat).vector;\n\n # Compute normal vector (TODO)\n #visual_norm[i,j][0] = eigen_val_0 #eigen_vector[0]\n #visual_norm[i,j][1] = eigen_val_1 #eigen_vector[1]\n #visual_norm[i,j][2] = eigen_val_2 #eigen_vector[2]\n\n # Compute the curvature surface change\n eig_sum = cov_mat_0 + cov_mat_1 + cov_mat_2\n visual_curv[i,j][0] = 0\n if eig_sum != 0:\n visual_curv[i,j][0] = eigen_val_1 # true curvature is: ti.abs(eigen_value / eig_sum)","def _cal_meaningful_corners(self):\n corners = np.where(self._free_of_clash)\n corners = np.array(corners, dtype=int)\n corners = corners.transpose()\n return corners","def in_view(self, points):\n # Need to change this to view in 3D ??\n pos = self._pos\n dir = self._dir\n cpoints = points - pos\n dists = np.sqrt(np.sum(cpoints**2, axis=0))\n\n # Taking dot product for cosine angle\n cosangles = dir.T.dot(cpoints) / dists\n cosangles = cosangles[0, :]\n\n # The cos angle is negative only when landmark lies behind the robot's heading direction. \n # Max distance landmarks can be retained. There is no argument or counter-argument yet for in/ex-clusion\n in_view_pts = (cosangles > np.cos(self._maxangle)) & (dists <= self._maxdist)\n \n if len(in_view_pts.shape) > 1:\n import pdb;pdb.set_trace()\n return in_view_pts","def light_source_directions():\n L = np.array([[-0.06059872, -0.44839055, 0.8917812],\n [-0.05939919, -0.33739538, 0.93948714],\n [-0.05710194, -0.21230722, 0.97553319],\n [-0.05360061, -0.07800089, 0.99551134],\n [-0.04919816, 0.05869781, 0.99706274],\n [-0.04399823, 0.19019233, 0.98076044],\n [-0.03839991, 0.31049925, 0.9497977],\n [-0.03280081, 0.41611025, 0.90872238],\n [-0.18449839, -0.43989616, 0.87889232],\n [-0.18870114, -0.32950199, 0.92510557],\n [-0.1901994, -0.20549935, 0.95999698],\n [-0.18849605, -0.07269848, 0.97937948],\n [-0.18329657, 0.06229884, 0.98108166],\n [-0.17500445, 0.19220488, 0.96562453],\n [-0.16449474, 0.31129005, 0.93597008],\n [-0.15270716, 0.4160195, 0.89644202],\n [-0.30139786, -0.42509698, 0.85349393],\n [-0.31020115, -0.31660118, 0.89640333],\n [-0.31489186, -0.19549495, 0.92877599],\n [-0.31450962, -0.06640203, 0.94692897],\n [-0.30880699, 0.06470146, 0.94892147],\n [-0.2981084, 0.19100538, 0.93522635],\n [-0.28359251, 0.30729189, 0.90837601],\n [-0.26670649, 0.41020998, 0.87212122],\n [-0.40709586, -0.40559588, 0.81839168],\n [-0.41919869, -0.29999906, 0.85689732],\n [-0.42618633, -0.18329412, 0.88587159],\n [-0.42691512, -0.05950211, 0.90233197],\n [-0.42090385, 0.0659006, 0.90470827],\n [-0.40860354, 0.18720162, 0.89330773],\n [-0.39141794, 0.29941372, 0.87013988],\n [-0.3707838, 0.39958255, 0.83836338],\n [-0.499596, -0.38319693, 0.77689378],\n [-0.51360334, -0.28130183, 0.81060526],\n [-0.52190667, -0.16990217, 0.83591069],\n [-0.52326874, -0.05249686, 0.85054918],\n [-0.51720021, 0.06620003, 0.85330035],\n [-0.50428312, 0.18139393, 0.84427174],\n [-0.48561334, 0.28870793, 0.82512267],\n [-0.46289771, 0.38549809, 0.79819605],\n [-0.57853599, -0.35932235, 0.73224555],\n [-0.59329349, -0.26189713, 0.76119165],\n [-0.60202327, -0.15630604, 0.78303027],\n [-0.6037003, -0.04570002, 0.7959004],\n [-0.59781529, 0.06590169, 0.79892043],\n [-0.58486953, 0.17439091, 0.79215873],\n [-0.56588359, 0.27639198, 0.77677747],\n [-0.54241965, 0.36921337, 0.75462733],\n [0.05220076, -0.43870637, 0.89711304],\n [0.05199786, -0.33138635, 0.9420612],\n [0.05109826, -0.20999284, 0.97636672],\n [0.04919919, -0.07869871, 0.99568366],\n [0.04640163, 0.05630197, 0.99733494],\n [0.04279892, 0.18779527, 0.98127529],\n [0.03870043, 0.30950341, 0.95011048],\n [0.03440055, 0.41730662, 0.90811441],\n [0.17290651, -0.43181626, 0.88523333],\n [0.17839998, -0.32509996, 0.92869988],\n [0.18160174, -0.20480196, 0.96180921],\n [0.18200745, -0.07490306, 0.98044012],\n [0.17919505, 0.05849838, 0.98207285],\n [0.17329685, 0.18839658, 0.96668244],\n [0.1649036, 0.30880674, 0.93672045],\n [0.1549931, 0.41578148, 0.89616009],\n [0.28720483, -0.41910705, 0.8613145],\n [0.29740177, -0.31410186, 0.90160535],\n [0.30420604, -0.1965039, 0.9321185],\n [0.30640529, -0.07010121, 0.94931639],\n [0.30361153, 0.05950226, 0.95093613],\n [0.29588748, 0.18589214, 0.93696036],\n [0.28409783, 0.30349768, 0.90949304],\n [0.26939905, 0.40849857, 0.87209694],\n [0.39120402, -0.40190413, 0.8279085],\n [0.40481085, -0.29960803, 0.86392315],\n [0.41411685, -0.18590756, 0.89103626],\n [0.41769724, -0.06449957, 0.906294],\n [0.41498764, 0.05959822, 0.90787296],\n [0.40607977, 0.18089099, 0.89575537],\n [0.39179226, 0.29439419, 0.87168279],\n [0.37379609, 0.39649585, 0.83849122],\n [0.48278794, -0.38169046, 0.78818031],\n [0.49848546, -0.28279175, 0.8194761],\n [0.50918069, -0.1740934, 0.84286803],\n [0.51360856, -0.05870098, 0.85601427],\n [0.51097962, 0.05899765, 0.8575658],\n [0.50151639, 0.17420569, 0.84742769],\n [0.48600297, 0.28260173, 0.82700506],\n [0.46600106, 0.38110087, 0.79850181],\n [0.56150442, -0.35990283, 0.74510586],\n [0.57807114, -0.26498677, 0.77176147],\n [0.58933134, -0.1617086, 0.7915421],\n [0.59407609, -0.05289787, 0.80266769],\n [0.59157958, 0.057798, 0.80417224],\n [0.58198189, 0.16649482, 0.79597523],\n [0.56620006, 0.26940003, 0.77900008],\n [0.54551481, 0.36380988, 0.7550205]], dtype=float)\n return L","def _move_ligand_to_lower_corner(self):\n spacing = self._grid[\"spacing\"]\n lower_ligand_corner = np.array([self._crd[:,i].min() for i in range(3)], dtype=float) - 1.5*spacing\n upper_ligand_corner = np.array([self._crd[:,i].max() for i in range(3)], dtype=float) + 1.5*spacing\n #\n ligand_box_lenghts = upper_ligand_corner - lower_ligand_corner\n if np.any(ligand_box_lenghts < 0):\n raise RuntimeError(\"One of the ligand box lenghts are negative\")\n\n max_grid_indices = np.ceil(ligand_box_lenghts / spacing)\n self._max_grid_indices = self._grid[\"counts\"] - np.array(max_grid_indices, dtype=int)\n if np.any(self._max_grid_indices <= 1):\n raise RuntimeError(\"At least one of the max grid indices is <= one\")\n \n displacement = self._origin_crd - lower_ligand_corner\n for atom_ind in range(len(self._crd)):\n self._crd[atom_ind] += displacement\n \n self._initial_com = self._get_molecule_center_of_mass()\n return None","def check_point_right(nodeL, nodeR, city):\n A = get_city_points(city)\n B = get_node_points(nodeL)\n C = get_node_points(nodeR)\n slope = _slope(A, B)\n (F, G) = calibrator(A, B, slope)\n sign = math.copysign(1, ((G[0] - F[0]) * (C[1] - F[1]) - (G[1] - F[1]) * (C[0] - F[0])))\n\n if slope == \"horizontal\":\n if sign == 1:\n if A[0] > B[0]:\n return True\n else:\n return False\n else:\n if A[0] < B[0]:\n return True\n else:\n return False\n\n if slope == \"vertical\":\n if sign == 1:\n if A[1] < B[1]:\n return True\n else:\n return False\n else:\n if A[1] > B[1]:\n return True\n else:\n return False\n\n if slope == \"inclined\":\n if sign == 1:\n if A[1] < B[1]:\n return True\n else:\n return False\n else:\n if A[1] > B[1]:\n return True\n else:\n return False\n\n if slope == \"declined\":\n if sign == 1:\n if A[1] < B[1]:\n return True\n else:\n return False\n else:\n if A[1] > B[1]:\n return True\n else:\n return False","def calculate_gate(self,offset):\n (rx,ry,_) = self.robot.world.particle_filter.pose\n dx = self.object.x\n dy = self.object.y\n dtheta = self.object.theta\n pt1x = dx + offset * cos(dtheta)\n pt1y = dy + offset * sin(dtheta)\n pt2x = dx + offset * cos(dtheta+pi)\n pt2y = dy + offset * sin(dtheta+pi)\n dist1sq = (pt1x-rx)**2 + (pt1y-ry)**2\n dist2sq = (pt2x-rx)**2 + (pt2y-ry)**2\n if dist1sq < dist2sq:\n return (pt1x, pt1y)\n else:\n return (pt2x, pt2y)","def is_rectal(self):\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\n or bool(self.depth and 4 <= self.depth <= 16)","def test_outside_plus_inside(self):\n for region, bounds in load_region_bounds_dict().items():\n lon_bounds, lat_bounds = bounds\n for key in ['data01', 'ds_shift_lon', 'ds_rev_both', 'ds_irr_both']:\n outside_data = climapy.xr_mask_bounds(data_dict[key],\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\n select_how='outside')['PRECL']\n inside_data = climapy.xr_mask_bounds(data_dict[key],\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\n select_how='inside')['PRECL']\n outside_plus_inside = (np.nan_to_num(outside_data.values) +\n np.nan_to_num(inside_data.values))\n diff_from_input = outside_plus_inside - data_dict[key]['PRECL'].values\n assert np.abs(diff_from_input).max() == 0","def find_current_points_r(grad_mag, x_mean_scaled, normals_length, display_normals=False, img=None):\n if img is None:\n img = grad_mag\n\n # Norm Calculation\n normals = np.zeros((no_points, 2))\n for i in range(0, no_points):\n # the first and the last points vectors should\n # be calculated using one neighbor\n if i == 0:\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i]\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i + no_points]\n elif i == no_points - 1:\n ux = x_mean_scaled[i] - x_mean_scaled[i - 1]\n uy = x_mean_scaled[i + no_points] - x_mean_scaled[i + no_points - 1]\n else:\n # points that have two neighbors\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i - 1]\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i - 1 + no_points]\n # nx, ny for each point\n normals[i, 0] = -uy / sqrt(ux * ux + uy * uy)\n normals[i, 1] = ux / sqrt(ux * ux + uy * uy)\n\n # PLOT normals\n if display_normals:\n display_normals(normals, x_mean_scaled, img, normals_length)\n\n # finding correct positions on the model, Y\n Y = np.zeros(x_mean_scaled.shape)\n\n for i in range(0, no_points):\n # landmark point coordinates\n px = float(x_mean_scaled[i])\n py = float(x_mean_scaled[i + no_points])\n nx, ny = normals[i, :]\n max_y, max_x = grad_mag.shape\n check_pixels = []\n\n for t in (-normals_length, normals_length):\n lx = int(px + t * nx)\n ly = int(py + t * ny)\n\n # check boundaries\n if lx >= max_x:\n lx = max_x - 1\n elif lx < 0:\n lx = 0\n\n if ly >= max_y:\n ly = max_y - 1\n elif ly < 0:\n ly = 0\n\n check_pixels.append((ly, lx))\n\n pf_line = profile_line(grad_mag, check_pixels[1], check_pixels[0], linewidth=3)\n pf_line_coors = _line_profile_coordinates(check_pixels[1], check_pixels[0], linewidth=1)\n\n mag_argmax = np.argmax(pf_line)\n Y[i] = int(pf_line_coors[1, mag_argmax, :])\n Y[i + no_points] = int(pf_line_coors[0, mag_argmax, :])\n\n return Y","def _isLeft(P0, P1, P2):\n return (P1.x - P0.x)*(P2.y - P0.y) - (P2.x - P0.x)*(P1.y - P0.y)","def find_lane(self, warped_img):\n if not self.detected:\n # Use sliding window if lanes are not detected on the previous frame\n leftx, lefty, rightx, righty, out_img = leftx, lefty, rightx, righty, out_img = find_lane_sliding_window(warped_img)\n left_fit, right_fit, left_fitx, right_fitx, ploty = fit_poly(warped_img.shape, leftx, lefty, rightx, righty)\n curvature, distance = curvature_and_position(ploty, left_fit, right_fit, warped_img.shape[1])\n self.last_left_fit = left_fit\n self.last_right_fit = right_fit\n self.last_ploty = ploty\n self.detected = True\n return left_fitx, right_fitx, ploty, curvature, distance\n \n else:\n try:\n leftx, lefty, rightx, righty, out_img = find_lane_from_prior(warped_img, self.last_left_fit, self.last_right_fit, self.ploty)\n left_fit, right_fit, left_fitx, right_fitx, ploty = fit_poly(warped_img.shape, leftx, lefty, rightx, righty)\n curvature, distance = curvature_and_position(ploty, left_fit, right_fit, warped_img.shape[1])\n \n # If the distance doesn't make sense, use sliding window to search again\n if abs(distance) > self.tol_dist:\n self.detected = False\n return self.find_lane(warped_img)\n else:\n self.last_left_fit = left_fit\n self.last_right_fit = right_fit\n self.last_ploty = ploty\n self.detected = True\n return left_fitx, right_fitx, ploty, curvature, distance\n except:\n # Exception raised by fitpoly when left/right is empty\n self.detected = False\n return self.find_lane(warped_img)","def le(self, x, y):","def left_or_right(self):\n #traversal\n left_total = 0\n left_count = 0\n right_total = 0\n right_count = 0\n self.scan()\n for ang, dist in self.scan_data.items():\n if ang < self.MIDPOINT:\n right_total += dist\n right_count += 1\n print(\"Angle: %d // dist: %d // right_count: %d\" % (ang, dist, right_count))\n else:\n left_total += dist\n left_count += 1\n left_avg = left_total / left_count\n right_avg = right_total / right_count\n if left_avg > right_avg:\n self.turn_by_deg(-45)\n else:\n self.turn_by_deg(45)\n # if robot is facing the wrong way it will turn it around\n self.exit_bias()","def lla(self):\n return self._lla_shape","def func_curvature(self):\n return u.Curvature.CONVEX","def laplacian(self, point):\n n_vertices, n_faces = point.shape[-2], self.faces.shape[0]\n vertex_0, vertex_1, vertex_2 = self._vertices(point)\n len_edge_12 = gs.linalg.norm((vertex_1 - vertex_2), axis=-1)\n len_edge_02 = gs.linalg.norm((vertex_0 - vertex_2), axis=-1)\n len_edge_01 = gs.linalg.norm((vertex_0 - vertex_1), axis=-1)\n\n half_perimeter = 0.5 * (len_edge_12 + len_edge_02 + len_edge_01)\n area = gs.sqrt(\n (\n half_perimeter\n * (half_perimeter - len_edge_12)\n * (half_perimeter - len_edge_02)\n * (half_perimeter - len_edge_01)\n ).clip(min=1e-6)\n )\n sq_len_edge_12, sq_len_edge_02, sq_len_edge_01 = (\n len_edge_12 * len_edge_12,\n len_edge_02 * len_edge_02,\n len_edge_01 * len_edge_01,\n )\n cot_12 = (sq_len_edge_02 + sq_len_edge_01 - sq_len_edge_12) / area\n cot_02 = (sq_len_edge_12 + sq_len_edge_01 - sq_len_edge_02) / area\n cot_01 = (sq_len_edge_12 + sq_len_edge_02 - sq_len_edge_01) / area\n cot = gs.stack([cot_12, cot_02, cot_01], axis=1)\n cot /= 2.0\n id_vertices_120 = self.faces[:, [1, 2, 0]]\n id_vertices_201 = self.faces[:, [2, 0, 1]]\n id_vertices = gs.reshape(\n gs.stack([id_vertices_120, id_vertices_201], axis=0), (2, n_faces * 3)\n )\n\n def _laplacian(tangent_vec):\n \"\"\"Evaluate the mesh Laplacian operator.\n\n The operator is evaluated at a tangent vector at point to the\n manifold of DiscreteSurfaces. In other words, the operator is\n evaluated at a vector field defined on the surface point.\n\n Parameters\n ----------\n tangent_vec : array-like, shape=[..., n_vertices, 3]\n Tangent vector to the manifold at the base point that is the\n triangulated surface. This tangent vector is a vector field\n on the triangulated surface.\n\n Returns\n -------\n laplacian_at_tangent_vec: array-like, shape=[..., n_vertices, 3]\n Mesh Laplacian operator of the triangulated surface applied\n to one its tangent vector tangent_vec.\n \"\"\"\n to_squeeze = False\n if tangent_vec.ndim == 2:\n tangent_vec = gs.expand_dims(tangent_vec, axis=0)\n to_squeeze = True\n n_tangent_vecs = len(tangent_vec)\n tangent_vec_diff = (\n tangent_vec[:, id_vertices[0]] - tangent_vec[:, id_vertices[1]]\n )\n values = gs.einsum(\n \"bd,nbd->nbd\", gs.stack([gs.flatten(cot)] * 3, axis=1), tangent_vec_diff\n )\n\n laplacian_at_tangent_vec = gs.zeros((n_tangent_vecs, n_vertices, 3))\n\n id_vertices_201_repeated = gs.tile(id_vertices[1, :], (n_tangent_vecs, 1))\n\n for i_dim in range(3):\n laplacian_at_tangent_vec[:, :, i_dim] = gs.scatter_add(\n input=laplacian_at_tangent_vec[:, :, i_dim],\n dim=1,\n index=id_vertices_201_repeated,\n src=values[:, :, i_dim],\n )\n return (\n gs.squeeze(laplacian_at_tangent_vec, axis=0)\n if to_squeeze\n else laplacian_at_tangent_vec\n )\n\n return _laplacian","def is_on(self, obj1_loc, obj1_dims, obj2_loc, obj2_dims):\n VERT_MEASUREMENT_TOLERANCE = self.VERT_MEASUREMENT_TOLERANCE\n result = None\n obj1_x = obj1_loc[0]\n obj1_y = obj1_loc[1]\n obj1_zmin = obj1_loc[2] - (.5 * obj1_dims[2])\n obj2_xmin, obj2_xmax, obj2_ymin, obj2_ymax, obj2_zmin, obj2_zmax = self.get_corners(obj2_loc, obj2_dims)\n if obj1_x >= obj2_xmin and obj1_x <= obj2_xmax:\n if obj1_y >= obj2_ymin and obj1_y <= obj2_ymax:\n if obj1_zmin >= obj2_zmax-VERT_MEASUREMENT_TOLERANCE and obj1_zmin <= obj2_zmax+VERT_MEASUREMENT_TOLERANCE:\n result = 'on'\n return result","def lombs(x, y):\n # Calculate curvature. \n curv = curvature(x, y)\n steps = np.sqrt(np.diff(x, axis=0)**2 + np.diff(y, axis=0)**2)[:-1]\n arc = np.cumsum(steps)\n # Calculate LS.\n ls_f, ls_p = LombScargle(arc, curv).autopower()\n return ls_f, ls_p","def curvature_and_position(ploty, left_fit, right_fit, img_w):\n # Define y-value of interest\n # We'll choose the maximum y-value, corresponding to the bottom of the image\n y_eval = np.max(ploty)\n\n # Define some constants\n ym_per_pix = 30/720 # meters per pixel in y dimension\n xm_per_pix = 3.7/700 # meters per pixel in x dimension\n \n # Compute curvature\n left_fit[0] = left_fit[0]*xm_per_pix/(ym_per_pix**2)\n left_fit[1] = left_fit[1]*xm_per_pix/ym_per_pix\n right_fit[0] = right_fit[0]*xm_per_pix/(ym_per_pix**2)\n right_fit[1] = right_fit[1]*xm_per_pix/ym_per_pix\n left_curverad = np.power(1+(2*left_fit[0]*y_eval+left_fit[1])**2, 3/2)/np.abs(2*left_fit[0])\n right_curverad = np.power(1+(2*right_fit[0]*y_eval+right_fit[1])**2, 3/2)/np.abs(2*right_fit[0])\n aver_curverad = 0.5*(left_curverad + right_curverad)\n\n # Compute the relative position\n x_left = left_fit[0]*y_eval**2+left_fit[1]*y_eval+left_fit[2]\n x_right = right_fit[0]*y_eval**2+right_fit[1]*y_eval+right_fit[2]\n\n car_pos = img_w // 2\n center_line = (x_left + x_right) // 2\n \n distance = (car_pos - center_line)*xm_per_pix\n \n # Return the left/right curvature and the distance to the center line (right is positive)\n return aver_curverad, distance","def L(Rd: np.array, Re: np.array):\n nd = Rd[:, 0]\n sd = Rd[:, 1]\n ad = Rd[:, 2]\n\n ne = Re[:, 0]\n se = Re[:, 1]\n ae = Re[:, 2]\n\n ll = -0.5 * (\n np.dot(skew(nd), skew(ne))\n + np.dot(skew(sd), skew(se))\n + np.dot(skew(ad), skew(ae))\n )\n\n llinv = np.linalg.pinv(ll)\n\n return ll, llinv","def lorentz_func(x, center, width):\n return 1/np.pi*width/2 *1/((x-center)**2+(x/width)**2)","def _check_aliens_leftmost_edge(self):\n screen_rect = self.screen.get_rect()\n for alien in self.aliens.sprites():\n if alien.rect.left <= screen_rect.left:\n self._sideways_ship_hit()\n break","def _calibrate_landmarks(self, bboxes, landmarks, align=False):\n\n x1, y1, x2, y2 = [bboxes[:, i] for i in range(4)]\n w = x2 - x1 + 1.0\n h = y2 - y1 + 1.0\n w = torch.unsqueeze(w, 1)\n h = torch.unsqueeze(h, 1)\n\n translation = torch.cat([w]*5 + [h]* 5, 1).float() * landmarks\n if align:\n landmarks = torch.ceil(translation).int()\n else:\n landmarks = torch.stack([bboxes[:, 0]] * 5 + [bboxes[:, 1]] * 5, 1) + torch.round(translation).int()\n return landmarks","def checkPointInLampsReach(self, p):\n v1 = XYPoint(self.Lime.x - self.Red.x, self.Lime.y - self.Red.y)\n v2 = XYPoint(self.Blue.x - self.Red.x, self.Blue.y - self.Red.y)\n\n q = XYPoint(p.x - self.Red.x, p.y - self.Red.y)\n s = self.crossProduct(q, v2) / self.crossProduct(v1, v2)\n t = self.crossProduct(v1, q) / self.crossProduct(v1, v2)\n\n return (s >= 0.0) and (t >= 0.0) and (s + t <= 1.0)","def rad_field_initial_condition(self):\n\n # revert in viewing direct\n angle, _ = f.convert_direction(self.receiver_elevation, self.receiver_azimuth)\n # Looking at the sky\n if angle < 90:\n I_init = (\n self.sun_intensity\n * f.delta_func(self.sun_elevation - self.receiver_elevation)\n * f.delta_func(self.sun_azimuth - self.receiver_azimuth)\n )\n\n # Looking at the ground\n elif angle > 90:\n I_ground = RT_model_1D.calc_direct_beam_intensity(self, 0)\n\n I_lambert = (\n I_ground\n * self.ground_albedo\n * np.cos(np.deg2rad((self.sun_elevation + 180) % 360))\n )\n\n I_specular = (\n I_ground\n * self.ground_albedo\n * f.delta_func(self.sun_elevation + self.receiver_elevation - 180)\n * f.delta_func(self.sun_azimuth - self.receiver_azimuth)\n )\n\n I_init = (\n 1 - self.reflection_type\n ) * I_lambert + self.reflection_type * I_specular\n\n else:\n I_init = np.empty(self.stokes_dim)\n I_init.fill(np.nan)\n\n return I_init","def find_lower_tangent(l_x_as, l_y_as, r_x_as, r_y_as, r_yp_as):\n # logg = logging.getLogger(f\"c.{__name__}.find_lower_tangent\")\n # logg.debug(f\"Start find_lower_tangent\")\n\n # compute the second derivative\n r_ypp = r_yp_as[1:] - r_yp_as[:-1]\n mean_r_ypp = np.mean(r_ypp)\n\n # logg.debug(f\"r_yp_as: {r_yp_as}\")\n # logg.debug(f\"r_ypp: {r_ypp}\")\n\n if mean_r_ypp >= 0:\n # logg.debug(f\"ypp positive\")\n range_xid = range(r_x_as.shape[0])\n else:\n # logg.debug(f\"ypp negative\")\n range_xid = range(r_x_as.shape[0])[::-1]\n\n tangent_start = timer()\n for xid in range_xid:\n # point tangent to the *right* segment\n tang_op = OrientedPoint(r_x_as[xid], r_y_as[xid], slope2deg(r_yp_as[xid]))\n tang_coeff = tang_op.to_ab_line()\n\n # sample it on the *left* segment sample\n l_tang_y_as = poly_model(l_x_as, tang_coeff, flip_coeff=True)\n # ax.plot(l_x_as, l_tang_y_as, color=\"b\", ls=\"-\", marker=\"\")\n # ax.plot(l_x_as, l_tang_y_as, color=\"b\", ls=\"\", marker=\".\")\n\n # find if the left segment has some points lower than the tangent\n lower = l_y_as < l_tang_y_as\n # logg.debug(f\"lower: {lower} {np.sum(lower)}\")\n if np.sum(lower) == 0:\n # logg.debug(f\"Breaking at xid: {xid}\")\n break\n\n tangent_end = timer()\n tangent_time = tangent_end - tangent_start\n # logg.debug(f\"Time to find tangent: {tangent_end - tangent_start:.6f}\")\n\n # find distance from left segment to tangent\n dist_left_tangent = l_y_as - l_tang_y_as\n min_dist_left_tangent = np.min(dist_left_tangent)\n argmin_dist_left_tangent = np.argmin(dist_left_tangent)\n recap = f\"min_dist_left_tangent: {min_dist_left_tangent:.6f}\"\n recap += \" argmin_dist_left_tangent: {argmin_dist_left_tangent}\"\n # logg.debug(recap)\n\n if min_dist_left_tangent < 0:\n # logg.debug(f\"Tangent not found\")\n return -1, -1, None, tangent_time\n\n l_xid = argmin_dist_left_tangent\n r_xid = xid\n\n return l_xid, r_xid, l_tang_y_as, tangent_time","def findslopes(img):\n img = img.astype(np.float32)\n DY = np.array([[-1,-1,-1],[0, 0, 0],[1, 1, 1]]) * 1/6\n DX = DY.transpose()\n gradx = cv2.filter2D(src=img, ddepth=-1, kernel=DX)\n grady = cv2.filter2D(src=img, ddepth=-1, kernel=DY)\n\n D2Y = np.array([[0.5, 1, 0.5], [-1, -2, -1], [0.5, 1, 0.5]]) * 0.5\n D2X = D2Y.transpose()\n DXY = np.array([[-1, 0, 1], [0, 0, 0], [1, 0, -1]]) * 1/4\n grad2x = cv2.filter2D(src=img, ddepth=-1, kernel=D2X)\n grad2y = cv2.filter2D(src=img, ddepth=-1, kernel=D2Y)\n gradxy = cv2.filter2D(src=img, ddepth=-1, kernel=DXY)\n\n slopes = gradx**2 + grady**2\n slopes2 = grad2x**2 + grad2y**2 + 2 * gradxy**2\n\n return (slopes, gradx, grady, slopes2, grad2x, grad2y, gradxy)","def getNewVal(on, val, pos, corners):\n\n (x, y) = pos\n\n # corner lights are always on\n if (x, y) in corners:\n return 1\n\n if val == 0:\n if on == 3:\n return 1\n\n elif val == 1:\n if not (on == 2 or on == 3):\n return 0\n\n return val","def has_compatible_ligands(self, identity):\n return ((len(self.bad_coords[identity]) == 0) and\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))","def reset_boundaries(self):\n self.L = - np.random.uniform(0.0,1.0)\n self.R = self.L + 1.0\n self.Ne = 0.0\n self.Nc = 0.0","def get_laser_points_in_region(\r\n self, image: np.ndarray, region: Rectangle, is_obj: bool = False,\r\n ) -> Optional[np.ndarray]:\r\n top_left = region.top_left\r\n bottom_right = region.bottom_right\r\n region_image = image[top_left.y : bottom_right.y, top_left.x : bottom_right.x]\r\n image_inv = cv.cvtColor(~region_image, cv.COLOR_BGR2HSV)\r\n lower_red = self.lower_red_obj if is_obj else self.lower_red_planes\r\n red_mask = cv.inRange(image_inv, lower_red, self.upper_red)\r\n laser_points = cv.findNonZero(red_mask)\r\n if laser_points is None or (not is_obj and len(laser_points) < 30):\r\n return None\r\n return laser_points","def find_current_points(grad_mag, x_mean_scaled, normals_length, display_normals = False, img = None):\n if img is None:\n img = grad_mag\n\n # Norm Calculation\n normals = np.zeros((no_points, 2))\n for i in range(0, no_points):\n # the first and the last points vectors should\n # be calculated using one neighbor\n if i == 0:\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i]\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i + no_points]\n elif i == no_points - 1:\n ux = x_mean_scaled[i] - x_mean_scaled[i - 1]\n uy = x_mean_scaled[i + no_points] - x_mean_scaled[i + no_points - 1]\n else:\n # points that have two neighbors\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i - 1]\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i - 1 + no_points]\n # nx, ny for each point\n normals[i, 0] = -uy / sqrt(ux * ux + uy * uy)\n normals[i, 1] = ux / sqrt(ux * ux + uy * uy)\n\n # PLOT normals\n if display_normals:\n display_normals(normals, x_mean_scaled, img, normals_length)\n\n # finding correct positions on the model, Y\n Y = np.zeros(x_mean_scaled.shape)\n\n for i in range(0, no_points):\n # landmark point coordinates\n px = float(x_mean_scaled[i])\n py = float(x_mean_scaled[i + no_points])\n nx, ny = normals[i, :]\n max_y, max_x = grad_mag.shape\n check_pixels = []\n for t in range(-normals_length, +normals_length):\n lx = px + t * nx\n ly = py + t * ny\n # check boundaries\n if lx >= max_x:\n lx = max_x - 1\n elif lx < 0:\n lx = 0\n\n if ly >= max_y:\n ly = max_y - 1\n elif ly < 0:\n ly = 0\n\n check_pixels.append((lx, ly))\n\n check_pixels = np.array(check_pixels, dtype=int)\n\n grad_values = grad_mag[check_pixels[:, 1], check_pixels[:, 0]]\n mag_argmax = np.argmax(grad_values)\n Y[i] = check_pixels[mag_argmax, 0]\n Y[i + no_points] = check_pixels[mag_argmax, 1]\n\n return Y","def is_valid(self):\n if len(self.exterior) < 3:\n return False\n return self.to_shapely_polygon().is_valid","def checkDiagonals( self ):\n\n centerVal = self.__grid[4]\n\n diag1 = str(centerVal).lower() + str(self.__grid[0]).lower() \\\n + str(self.__grid[8]).lower()\n diag2 = str(centerVal).lower() + str(self.__grid[2]).lower() \\\n + str(self.__grid[6]).lower()\n\n if isinstance(centerVal, int):\n return None\n\n elif 'xx' in diag1: \n return ('X', diag1)\n\n elif 'xx' in diag2:\n return ('X', diag2)\n\n elif 'oo' in diag1:\n return ('O', diag1)\n\n elif 'oo' in diag2:\n return ('O', diag2)\n\n else:\n return None","def checkEdges( self ):\n\t\tx, y = self.position.xy\n\t\tvx, vy = self.velocity.xy\n\t\t\n\t\t#if particle hit left or right wall\n\t\tif abs( x ) > WINDOW_X - self.r:\n\t\t\t#change vertical speed\n\t\t\tvx *= -1\n\t\t\t\n\t\t#if particle hit top or bottom wall\n\t\tif abs( y ) > WINDOW_Y - self.r:\n\t\t\t#change horizontal speed\n\t\t\tvy *= -1\n\t\t\n\t\t#enter new velocity\n\t\tself.velocity.xy = (vx, vy)","def fun(x0, x1, y0, y1, xx, yy): \n\n # Look for point of intersection between interpolated curve between nodes in x, y\n # and the normal to the face between nodes (x0, y0) and (x1, y1)\n # Transform coordinate axes\n # Center of face is xs, ys\n xs = (x0 + x1)/2.\n ys = (y0 + y1)/2.\n\n if abs(y1 - y0) > abs(x1 - x0):\n theta = arctan((x1 - x0)/(y1 - y0))\n theta2 = arctan((xx - xs)/(yy - ys))\n dy = (yy - ys)/cos(theta2)\n xn = copy(xx)\n yn = copy(yy)\n xn = dy*sin(theta2 - theta)\n yn = dy*cos(theta2 - theta)\n w = barycentric_weight(yn)\n y2 = - yn\n f = zeros(len(y2), float)\n ss = sum(w/y2)\n f[:] = w/y2/ss\n dy = dot(f, xn)\n xny = xs + dy*sin(theta + pi/2.)\n yny = ys + dy*cos(theta + pi/2.)\n\n else: \n theta = arctan((y1 - y0)/(x1 - x0))\n theta2 = arctan((yy - ys)/(xx - xs))\n dx = (xx - xs)/cos(theta)\n xn = copy(xx)\n yn = copy(yy)\n xn = dx*cos(theta2 - theta)\n yn = dx*sin(theta2 - theta)\n w = barycentric_weight(xn)\n x2 = - xn\n f = zeros(len(x2), float)\n ss = sum(w/x2)\n f[:] = w/x2/ss\n dy = dot(f, yn)\n xny = xs + dy*cos(theta + pi/2.)\n yny = ys + dy*sin(theta + pi/2.)\n \n return xny, yny","def PointIsLeft(vi, vf, point):\n DetPIL = (point[0] - vi[0])*(vf[1] - vi[1]) - (point[1] - vi[1])*(vf[0] - vi[0])\n if DetPIL < 0 :\n return True\n elif DetPIL > 0 :\n return False\n else :\n return None","def boundaries_prev(*args):\n return _ida_hexrays.boundaries_prev(*args)","def calc_curvature(self, windows: List[Window]):\n x, y = zip(*[window.pos_xy() for window in windows])\n x = np.array(x)\n y = np.array(y)\n fit_cr = np.polyfit(y * camera.y_m_per_pix, x * camera.x_m_per_pix, 2)\n y_eval = np.max(y)\n return ((1 + (2 * fit_cr[0] * y_eval * camera.y_m_per_pix + fit_cr[1]) ** 2) ** 1.5) / np.absolute(\n 2 * fit_cr[0])","def _add_boundaries(self):\n logger.info(\"add_boundaries: start of method\")\n\n import scipy.spatial as sptl\n import scipy.sparse as sprs\n Lx = self._Lx\n Ly = self._Ly\n Lz = self._Lz\n Np = self.num_pores()\n btype = self._btype\n boffset = 0.05\n\n #Translate internal pores to each face of domain\n poffset = np.zeros((7,3))\n poffset[[2,5],0] = [-Lx, Lx]\n poffset[[3,4],1] = [-Ly, Ly]\n poffset[[1,6],2] = [-Lz, Lz]\n pcoords = pcoords0 = self['pore.coords']\n for i in np.r_[1:7]:\n pcoords = np.concatenate((pcoords,pcoords0 + poffset[i,:]),axis=0)\n\n #Use some twisted logic to get bval list of + for boundary and - for periodic faces\n bval = [0, 1, 2, 3, 4, 5, 6]*(np.array([0, btype[2], btype[0], btype[1], btype[1], btype[0], btype[2]])*-2+1)\n ptype = np.zeros((Np,),dtype=int)\n for i in np.r_[1:7]:\n ptype = np.concatenate((ptype,np.ones((Np,),dtype=int)*bval[i]),axis=0)\n\n #pnum contains the internal ID number of the boundary pores (for connecting periodic points)\n pnum = self.pores()\n pnum = np.tile(pnum,7)\n\n Tri = sptl.Delaunay(pcoords)\n adjmat = sprs.lil_matrix((np.shape(pcoords)[0],np.shape(pcoords)[0]),dtype=int)\n for i in np.arange(0,np.shape(Tri.simplices)[0]):\n #Keep only simplices that are fully in real domain\n adjmat[Tri.simplices[i],Tri.simplices[i]] = 1\n adjmat = sprs.triu(adjmat,k=1,format=\"lil\")\n for i in np.arange(0,Np):\n #Add periodic throats to the netowrk (if any)\n tpore2 = pnum[adjmat.rows[i]][ptype[adjmat.rows[i]]<0]\n tpore1 = np.ones_like(tpore2,dtype=int)*i\n conns = self['throat.conns']\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\n #Add boundary pores and throats to the network\n newporetyps = np.unique(ptype[adjmat.rows[i]][ptype[adjmat.rows[i]]>0])\n newporenums = np.r_[self.num_pores():self.num_pores()+np.size(newporetyps)]\n tpore2 = newporenums\n tpore1 = np.ones_like(tpore2,dtype=int)*i\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\n self['throat.conns'] = conns\n bcoords = np.zeros((7,3),dtype=float)\n coords = self['pore.coords']\n bcoords[1,:] = [coords[i,0], coords[i,1], 0-Lz*boffset]\n bcoords[2,:] = [0-Lx*boffset, coords[i,1], coords[i,2]]\n bcoords[3,:] = [coords[i,0], -Ly*boffset, coords[i,2]]\n bcoords[4,:] = [coords[i,0], Ly+Ly*boffset, coords[i,2]]\n bcoords[5,:] = [Lx+Lx*boffset, coords[i,1], coords[i,2]]\n bcoords[6,:] = [coords[i,0], coords[i,1], Lz+Lz*boffset]\n newporecoords = bcoords[newporetyps,:]\n coords = np.concatenate((coords,newporecoords),axis=0)\n self['pore.coords'] = coords\n #Reset number of pores and throats (easier than tracking it)\n nums = np.r_[0:np.shape(coords)[0]]\n self['pore.numbering'] = nums\n self['pore.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\n nums = np.r_[0:np.shape(conns)[0]]\n self['throat.numbering'] = nums\n self['throat.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\n logger.debug(\"add_boundaries: end of method\")","def is_left(self):\n if self.pupils_located:\n return self.horizontal_ratio() >= 0.65","def is_center(self):\n if self.pupils_located:\n return self.is_right() is not True and self.is_left() is not True","def calculate_celestial_pole(native_reference_x, native_reference_cos_lat,\n native_reference_sin_lat,\n reference_x, reference_y,\n reference_cos_lat, reference_sin_lat,\n native_pole_x, native_pole_y,\n select_solution): # pragma: no cover\n right_angle = np.pi / 2\n d_phi = native_pole_x - native_reference_x\n sin_d_phi = np.sin(d_phi)\n cos_d_phi = np.cos(d_phi)\n delta_p1 = np.arctan2(\n native_reference_sin_lat, native_reference_cos_lat * cos_d_phi)\n cs = native_reference_cos_lat * sin_d_phi\n\n delta_p2 = acos(reference_sin_lat / np.sqrt(1 - (cs ** 2)))\n celestial_y = 0.0\n\n delta_n = delta_p1 + delta_p2\n delta_s = delta_p1 - delta_p2\n if delta_n > delta_s:\n temp = delta_s\n delta_s = delta_n\n delta_n = temp\n\n solutions = 0\n if np.abs(delta_n) <= right_angle:\n celestial_y = delta_n\n solutions += 1\n\n if np.abs(delta_s) <= right_angle:\n solutions += 1\n if solutions == 1:\n celestial_y = delta_s\n elif select_solution == -1:\n celestial_y = delta_s\n elif select_solution == 0:\n if np.abs(delta_s - native_pole_y) < np.abs(\n delta_n - native_pole_y):\n celestial_y = delta_s\n\n if solutions == 0: # pragma: no cover (shouldn't happen)\n return np.nan, np.nan\n\n if equal_angles(np.abs(reference_y), right_angle):\n celestial_x = reference_x\n elif equal_angles(np.abs(celestial_y), right_angle):\n celestial_x = reference_x\n if celestial_y > 0:\n celestial_x += native_pole_x - native_reference_x - np.pi\n else:\n celestial_x += native_reference_x - native_pole_x\n else:\n cl = np.cos(celestial_y)\n sl = np.sin(celestial_y)\n\n sin_d_lon = sin_d_phi * native_reference_cos_lat / reference_cos_lat\n cos_d_lon = native_reference_sin_lat - (sl * reference_sin_lat)\n cos_d_lon /= cl * reference_cos_lat\n celestial_x = reference_x - np.arctan2(sin_d_lon, cos_d_lon)\n\n return celestial_x, celestial_y","def isCollinear(a,b,c):\r\n #return slope(a, b) == slope(b, c) == slope(c, a) #DOES NOT WORK\r\n #return (b[0] - a[0]) * (c[1] - a[1]) == (c[0] - a[0]) * (b[1] - a[1]) \r\n #return distance(a,b) + distance(b,c) == distance(a,c)\r\n x1 = a[0]\r\n y1 = a[1]\r\n x2 = b[0]\r\n y2 = b[1]\r\n x3 = c[0]\r\n y3 = c[1] \r\n if (x1*(y2 - y3)) + (x2*(y3 - y1)) + (x3*(y1-y2)) == 0: \r\n return True\r\n else:\r\n return False","def test_lineclip():\n # %% LOWER to UPPER test\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\n 0, 0, 4, 6)\n\n assert [x1, y1, x2, y2] == approx([2, 3, 3.3333333333333, 5])\n # %% no intersection test\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\n 0, 0.1, 0, 0.1)\n\n assert x1 is None and y1 is None and x2 is None and y2 is None\n # %% left to right test\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\n 0, 4, 5, 4)\n\n assert [x1, y1, x2, y2] == [1, 4, 4, 4]","def walled_in(x: int, y: int) -> bool:\r\n threshold = 2\r\n level = 0\r\n if wall_check(x, y, True):\r\n threshold = 1\r\n if not wall_check(x-1, y+1, False):\r\n if example[x-1, y+1] == 0:\r\n if mark_traveller(x-1, y+1, \"SW\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n if not wall_check(x - 1, y - 1, False):\r\n if example[x - 1, y - 1] == 0:\r\n if mark_traveller(x - 1, y - 1, \"SE\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n if not wall_check(x + 1, y - 1, False):\r\n if example[x + 1, y - 1] == 0:\r\n if mark_traveller(x + 1, y - 1, \"NE\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n if not wall_check(x + 1, y + 1, False):\r\n if example[x + 1, y + 1] == 0:\r\n if mark_traveller(x + 1, y + 1, \"NW\"):\r\n level += 1\r\n if level >= threshold:\r\n return True\r\n return False","def state(self):\r\n\r\n #Mark in wich direction is the prey\r\n prescence_prey_right = 1 if (self.prey.position[0] > self.body[0].position[0]) else 0\r\n prescence_prey_left = 1 if (self.prey.position[0] < self.body[0].position[0]) else 0\r\n prescence_prey_up = 1 if (self.prey.position[1] < self.body[0].position[1]) else 0\r\n prescence_prey_down = 1 if (self.prey.position[1] > self.body[0].position[1]) else 0\r\n #Direction where is moving\r\n actual_direction_right = 1 if (self.velocities[0] == 1) else 0\r\n actual_direction_left = 1 if (self.velocities[0] == -1) else 0\r\n actual_direction_up = 1 if (self.velocities[1] == -1) else 0\r\n actual_direction_down = 1 if (self.velocities[1] == 1) else 0\r\n #Mark if is an obstacle\r\n obstacles = np.ravel(self.obstacles())\r\n \r\n return (np.concatenate((\r\n [prescence_prey_right,\r\n prescence_prey_left,\r\n prescence_prey_up,\r\n prescence_prey_down,\r\n actual_direction_right,\r\n actual_direction_left,\r\n actual_direction_up,\r\n actual_direction_down],\r\n obstacles\r\n )))","def test_init_attr(self):\n \n for k in (0, -1, 1):\n s = space(curvature=k)\n self.assertTrue(isclose(\n s.curvature,\n k\n ))\n \n for k in (1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\n s = space(curvature=k)\n self.assertTrue(s.curvature == k)\n\n for fk in (0, -1, 1, 1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\n s = space(fake_curvature=fk)\n self.assertTrue(isclose(\n s.curvature,\n fk * abs(fk)\n ))\n\n for r in (1, 2, 1j, 2j, float('inf')):\n s = space(radius=r)\n self.assertTrue(s.curvature == 1/r**2)","def compute_refl(self, step, borders,obstacle):\n\n r = self.radius\n v = self.velocity\n x = self.position\n projx = step*abs(np.dot(v,np.array([1.,0.])))\n projy = step*abs(np.dot(v,np.array([0.,1.])))\n\n a = pygame.Rect(0,0,borders[3][0],borders[3][0])\n b = pygame.Rect(0,borders[0][1]+borders[0][3],borders[3][0],borders[3][1]+borders[3][3])\n c = pygame.Rect(borders[2][0]+borders[2][2],0,borders[3][0],borders[3][0])\n d = pygame.Rect(borders[3][0]+borders[3][2],borders[1][1]+borders[1][3],borders[3][0],borders[3][0])\n\n if(a.collidepoint(*self.position) or b.collidepoint(*self.position) or c.collidepoint(*self.position) or d.collidepoint(*self.position)):\n self.vafter *= 0\n self.delete = True\n\n\n\n\n else:\n if (abs(x[0])-r -borders[0][0]-borders[0][2] < projx ) or (abs(borders[1][0]- x[0])-r < projx):\n self.vafter[0] *= -1\n\n if abs(x[1])-r -(borders[2][1]+borders[2][3]) < projy or abs(borders[3][1]-x[1])-r < projy:\n self.vafter[1] *= -1.\n\n if obstacle != None:\n obs = pygame.Rect(*obstacle)\n if obs.collidepoint(x[0] + r,x[1]):\n self.vafter[0] = -20\n if obs.collidepoint(x[0] - r,x[1]):\n self.vafter[0] = 20\n if obs.collidepoint(x[0],x[1]- r):\n self.vafter[1] = 20\n if obs.collidepoint(x[0], x[1]+ r):\n self.vafter[1] = -20","def shield_left(nodeL, new_city, points, angle0=-1):\n item1 = get_node_points(nodeL)\n item2 = get_city_points(new_city)\n\n a = distance_between_points(item1, points)\n b = distance_between_points(points, item2)\n c = dic_list[nodeL.value - 1].get(nodeL.value).get(new_city)\n\n if (b == 0) | (check_point_left(nodeL, nodeL.right, new_city) == True):\n return nodeL\n angle1 = angle(a, b, c)\n\n if (angle1 < angle0) & (check_points(item2, item1, points, get_node_points(nodeL.right)) == False):\n return nodeL.right\n else:\n nodeL = nodeL.left\n same_side = check_points(item1, get_node_points(nodeL.right), points, item2)\n if same_side == True:\n return shield_left(nodeL, new_city, points, angle1)\n else:\n return nodeL.right","def in_ellipse(x,y,a,b):\n return ellipse(x,y,a,b) <= 1","def check_limits(self):\n\n #Find the relative position of each leg vs. its \"zero\" position\n relpos = self.fixed_plate - self.fixed_plate_zero\n\n for leg in range(3):\n #Check that the leg is within allowable \"safe zone\"\n #Use the position of the leg (relative to 0) to find the index in the \"safe zone\" matrix\n i_x = nearest_index(self.leg_safe_xaxis, relpos[COORD_X, leg])\n i_z = nearest_index(self.leg_safe_zaxis, relpos[COORD_Z, leg])\n #Look up in the safe zone.\n self.leg_fault[leg] = (not self.leg_safe_zone[leg, i_x, i_z])\n\n if (not all(np.isreal(self.fixed_plate[:, leg]))) or any(np.isnan(self.fixed_plate[:, leg])):\n #A complex or NaN value = the angle found for the leg was invalid, meaning that the\n #leg would have to be longer to reach the desired position.\n self.leg_fault[leg] = True","def calc_separation_alt_az(self, body):\n self.body.compute(self.site)\n body.body.compute(self.site)\n\n delta_az = float(self.body.az) - float(target.az)\n delta_alt = float(self.body.alt) - float(target.alt)\n return (delta_alt, delta_az)","def check_right(nodeL, nodeR, city):\n A = get_node_points(nodeL)\n B = get_node_points(nodeR)\n C = get_city_points(city)\n slope = _slope(A, B)\n (F, G) = calibrator(A, B, slope)\n sign = math.copysign(1, ((G[0] - F[0]) * (C[1] - F[1]) - (G[1] - F[1]) * (C[0] - F[0])))\n\n if slope == \"horizontal\":\n if sign == -1:\n if A[0] > B[0]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)\n else:\n if A[0] < B[0]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)\n\n if slope == \"vertical\":\n if sign == -1:\n if A[1] < B[1]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)\n else:\n if A[1] > B[1]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)\n\n if slope == \"inclined\":\n if sign == -1:\n if A[1] < B[1]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)\n else:\n if A[1] > B[1]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)\n\n if slope == \"declined\":\n if sign == -1:\n if A[1] < B[1]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)\n else:\n if A[1] > B[1]:\n return (nodeR, nodeL)\n else:\n return (nodeL, nodeR)","def corners(self):\n try:\n # Try to just set normal CoordinateDefinition corners\n # (Which doesn't work with bad vals in corners)\n return super(CoordinateDefinition, self).corners\n except ValueError:\n #print ' Corners failed on CoordinateDefinition, try falsecorners'\n pass\n\n lons, lats = self.get_lonlats()\n\n #Determine which rows and columns contain good data\n rows = lons.any(axis=1)\n cols = lons.any(axis=0)\n\n #Get the minimum and maximum row and column that contain good data\n good_row_inds = np.where(~rows.mask)[0]\n min_row = good_row_inds.min()\n max_row = good_row_inds.max()\n\n good_col_inds = np.where(~cols.mask)[0]\n min_col = good_col_inds.min()\n max_col = good_col_inds.max()\n\n log.info(' USING FALSE CORNERS!! setting corners. min row/col: '+\\\n str(min_row)+' '+str(min_col)+' '+\\\n 'max row/col: '+str(max_row)+' '+str(max_col)+' '+\\\n 'shape: '+str(lons.shape))\n\n\n #from .spherical import SCoordinate as Coordinate\n #from .spherical import Arc\n from pyresample.spherical_geometry import Coordinate, Arc\n #Calculate the eight possible corners and produce arcs for each pair\n #Corners for top side\n # Right side was failing with Divide by Zero error for NCC data because there was \n # a single good point in the max_col. Keep incrementing or decrementing until good.min \n # doesn't equal good.max \n good = np.where(~lons[min_row,:].mask)[0]\n tries = 0\n while (tries < 20 and good.min() == good.max()):\n #print 'good.min() can\\'t equal good.max() for top side, incrementing min_row! Would have failed with ZeroDivisionError before!'\n min_row += 1\n tries += 1\n good = np.where(~lons[min_row,:].mask)[0]\n top_corners = [Coordinate(*self.get_lonlat(min_row, good.min())),\n Coordinate(*self.get_lonlat(min_row, good.max()))]\n top_arc = Arc(top_corners[0], top_corners[1])\n\n #Corners for bottom side\n good = np.where(~lons[max_row,:].mask)[0]\n tries = 0\n while (tries < 20 and good.min() == good.max()):\n #print 'good.min() can\\'t equal good.max() for bottom side, decrementing max_row! Would have failed with ZeroDivisionError before!'\n max_row -= 1\n tries += 1\n good = np.where(~lons[max_row,:].mask)[0]\n bot_corners = [Coordinate(*self.get_lonlat(max_row, good.min())),\n Coordinate(*self.get_lonlat(max_row, good.max()))]\n bot_arc = Arc(bot_corners[0], bot_corners[1])\n\n #Corners for left side\n good = np.where(~lons[:,min_col].mask)[0]\n tries = 0\n while (tries < 20 and good.min() == good.max()):\n #print 'good.min() can\\'t equal good.max() for left side, incrementing min_col! Would have failed with ZeroDivisionError before!'\n min_col += 1\n tries += 1\n good = np.where(~lons[:,min_col].mask)[0]\n left_corners = [Coordinate(*self.get_lonlat(good.min(),min_col)),\n Coordinate(*self.get_lonlat(good.max(),min_col))]\n left_arc = Arc(left_corners[0], left_corners[1])\n\n #Corners for right side\n good = np.where(~lons[:,max_col].mask)[0]\n tries = 0\n while (tries < 20 and good.min() == good.max()):\n #print 'good.min() can\\'t equal good.max() for right side, decrementing max_col! Would have failed with ZeroDivisionError before!'\n max_col -= 1\n tries += 1\n good = np.where(~lons[:,max_col].mask)[0]\n right_corners = [Coordinate(*self.get_lonlat(good.min(),max_col)),\n Coordinate(*self.get_lonlat(good.max(),max_col))]\n right_arc = Arc(right_corners[0], right_corners[1])\n\n #Calculate the four false corners\n _corners = []\n #Top left false corner\n top_intersections = top_arc.intersections(left_arc)\n dists = [inter.distance(top_corners[0]) for inter in top_intersections]\n if dists[0] < dists[1]:\n _corners.append(top_intersections[0])\n else:\n _corners.append(top_intersections[1])\n #Top right false corner\n top_intersections = top_arc.intersections(right_arc)\n dists = [inter.distance(top_corners[1]) for inter in top_intersections]\n if dists[0] < dists[1]:\n _corners.append(top_intersections[0])\n else:\n _corners.append(top_intersections[1])\n #Bottom right false corner\n bot_intersections = bot_arc.intersections(right_arc)\n dists = [inter.distance(bot_corners[1]) for inter in bot_intersections]\n if dists[0] < dists[1]:\n _corners.append(bot_intersections[0])\n else:\n _corners.append(bot_intersections[1])\n #Bottom left false corner\n bot_intersections = bot_arc.intersections(left_arc)\n dists = [inter.distance(bot_corners[0]) for inter in bot_intersections]\n if dists[0] < dists[1]:\n _corners.append(bot_intersections[0])\n else:\n _corners.append(bot_intersections[1])\n return _corners","def can_left_arc(c, correct_arcs):\n try:\n return Arc(c.buffer[0], c.sentence[c.stack[-1]].deprel, c.stack[-1]) in correct_arcs\n except IndexError:\n return False","def compute_corners(landmarks, mode):\n right_to_left_eye = landmarks[:, :2] - landmarks[:, 2:4]\n middle_eye = (landmarks[:, :2] + landmarks[:, 2:4]) / 2\n eye_to_mouth = landmarks[:, 4:6] - middle_eye\n centers = middle_eye\n\n if np.linalg.norm(right_to_left_eye) > np.linalg.norm(eye_to_mouth):\n vec_right = right_to_left_eye\n vec_down = np.fliplr(vec_right).copy()\n vec_down[:, 0] *= -1.\n else:\n vec_down = eye_to_mouth\n vec_right = np.fliplr(vec_down).copy()\n vec_right[:, 1] *= -1.\n\n if mode == 'face':\n scale = 1.8\n elif mode == 'eyes':\n vec_down *= 0.33\n scale = 1.\n else:\n raise NotImplementedError()\n\n diag = scale * (vec_right + vec_down)\n top_left = centers - diag\n top_right = top_left + 2 * scale * vec_right\n bottom_left = top_left + 2 * scale * vec_down\n bottom_right = centers + diag\n\n return top_left, top_right, bottom_left, bottom_right","def linearize_pose_landmark_constraint(x, l, z):\n print(\"you shouldn't be here....\")\n e = np.zeros([2, 1])\n A = np.zeros([2, 3])\n B = np.zeros([2, 2])\n\n Ri = v2t(x)[0:2, 0:2]\n ti = x[0:2]\n\n fi = x[2]\n c = np.cos(fi)\n s = np.sin(fi)\n dR_dteta = np.array([[-s, c], [-c, -s]])\n\n e = Ri.transpose() @ (l - x[0:2]) - z\n\n B = Ri.transpose()\n\n A[0:2, 0:2] = -Ri.transpose()\n A[0:2, 2] = dR_dteta @ (l - ti)\n\n return e, A, B","def circle_leads(center_theta, width_theta, radius):\n\ta1 = np.deg2rad(center_theta + width_theta/2)\n\ta2 = np.deg2rad(center_theta - width_theta/2)\n\tpoint_max = radius * np.array([np.cos(a1), np.sin(a1)])\n\tpoint_min = radius * np.array([np.cos(a2), np.sin(a2)])\n\treturn (point_max, point_min)","def check_offset(self):\n\n for d in range(self.n_dmps):\n if abs(self.y0[d] - self.goal[d]) < 1e-4:\n self.goal[d] += 1e-4","def test_coord_preceding_fs(self):"],"string":"[\n \"def _curvature(self):\\n y_eval = self.left_fitx.shape[0] - 10\\n left_curverad = (((1 + (2 * self.left_fit[0] * y_eval + self.left_fit[1]) ** 2) ** 1.5) /\\n np.absolute(2 * self.left_fit[0]))\\n right_curverad = (((1 + (2 * self.right_fit[0] * y_eval + self.right_fit[1]) ** 2) ** 1.5) /\\n np.absolute(2 * self.right_fit[0]))\\n return left_curverad, right_curverad\",\n \"def sanity_check(self):\\n score = 0\\n curvatures = self._curvature()\\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\\n # difference in curvature is more than 15%\\n score -= 1\\n\\n diff_std = np.std(self.right_fitx - self.left_fitx)\\n if diff_std > 30:\\n # std of the difference between the right lane and left lane is more than 30 pixel\\n score -= 1\\n\\n # roughly parallel\\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\\n # difference in slope is more than 15%\\n score -= 1\\n\\n return score\",\n \"def GetLoCorner(self):\\n ...\",\n \"def fix_curvature(self) -> None:\\n self.n1.fix = True\\n self.n2.fix = True\",\n \"def calculate_leg_xy_limits(self, visualize=False):\\n \\n #Find the fixed plate position at the \\\"0\\\" point\\n gonio_zero = copy.copy(self)\\n gonio_zero.relative_sample_position = column([0.0, 0.0, 0.0]) #Tell the sample to be centered well.\\n gonio_zero.getplatepos(0.0, 0.0, 0.0)\\n fixed_plate_zero = np.copy(gonio_zero.fixed_plate)\\n #This defines the center of the following matrices\\n self.fixed_plate_zero = fixed_plate_zero\\n \\n #Now we generate a matrix of allowed positions around those points.\\n self.leg_safe_xaxis = np.arange(-self.travel, self.travel, self.leg_safe_resolution)\\n self.leg_safe_zaxis = np.copy(self.leg_safe_xaxis)\\n\\n #Create the \\\"safe zone\\\" array, initialized to False\\n self.leg_safe_zone = np.zeros( (3, self.leg_safe_xaxis.size, self.leg_safe_zaxis.size), dtype=bool ) \\n\\n #Now make a reasonable approximation\\n real_travel_x = 12.5\\n real_travel_z = real_travel_x\\n for leg in range(3):\\n for i_x in range(self.leg_safe_xaxis.size):\\n x = self.leg_safe_xaxis[i_x]\\n if abs(x)<real_travel_x:\\n for i_z in range(self.leg_safe_zaxis.size):\\n z = self.leg_safe_zaxis[i_z]\\n if abs(z)<real_travel_z:\\n self.leg_safe_zone[leg, i_x, i_z] = True\\n# #Upper left corner of leg A (0)\\n# center = int(len(self.leg_safe_xaxis)/2)\\n# self.leg_safe_zone[0, :, :] = False\\n# self.leg_safe_zone[0, :center, :center] = True\\n# self.leg_safe_zone[1, :, :] = False\\n# self.leg_safe_zone[1, center:, 0:center] = True\\n# self.leg_safe_zone[2, :, :center] = False\\n\\n\\n if visualize:\\n pylab.figure(0)\\n pylab.hold(True)\\n for leg in range(3):\\n pylab.pcolor(self.leg_safe_xaxis+fixed_plate_zero[COORD_X, leg], self.leg_safe_zaxis+fixed_plate_zero[COORD_Z, leg], self.leg_safe_zone[leg, :, :].transpose())\\n pylab.xlabel(\\\"x\\\")\\n pylab.ylabel(\\\"z\\\")\\n pylab.title(\\\"Allowable XZ leg positions for the 3 legs.\\\")\\n pylab.draw()\\n pylab.axis('equal')\\n #pylab.show()\",\n \"def check_borders(self):\\n # Go Homer!\\n # https://en.wikipedia.org/wiki/Torus#Flat_torus\\n if self._posn.x < 0:\\n self._posn.x += self._win_w\\n elif self._posn.x > self._win_w:\\n self._posn.x -= self._win_w\\n if self._posn.y < 0:\\n self._posn.y += self._win_h\\n elif self._posn.y > self._win_h:\\n self._posn.y -= self._win_h\",\n \"def check_boundary(self):\\n\\n\\t\\tif self.Bubble_initial_pos[0] <= self.Bubble_radius or self.Bubble_initial_pos[0] >= self.tk_pic.width - self.Bubble_radius:\\n\\t\\t\\tself.Bubble_vel[0] = -self.Bubble_vel[0]\",\n \"def is_valid(self):\\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\\n return posit1 & posit2 & self.feller()\",\n \"def detectBorders(self, points):\\n lane1 = []; lane2 = []\\n self.leftLane = [None for _ in range(int(np.floor(self.BIRDVIEW_HEIGHT / self.slideThickness)))]\\n self.rightLane = [None for _ in range(int(np.floor(self.BIRDVIEW_HEIGHT / self.slideThickness)))]\\n\\n pointMap = np.zeros((points.shape[0], 20))\\n prePoint = np.zeros((points.shape[0], 20))\\n postPoint = np.zeros((points.shape[0], 20))\\n\\n dis = 10\\n max1 = -1; max2 = -1\\n\\n ##\\n ## /!\\\\ UNSAFE LOOP, TODO: FIX\\n ##\\n for i in range(points.shape[0]):\\n for j in range(len(points[i])):\\n pointMap[i][j] = 1\\n prePoint[i][j] = -1\\n postPoint[i][j] = -1\\n\\n for i in reversed(range(points.shape[0] - 2)):\\n\\n for j in range(len(points[i])):\\n\\n err = 320\\n for m in range(1, min(points.shape[0] - 1 - i, 5)):\\n check = False ## TODO: why unused ?\\n\\n for k in range(len(points[i + 1])):\\n\\n (x_m, y_m) = points[i + m][k].pt\\n (x, y) = points[i][j].pt\\n\\n if (abs(x_m - x) < dis and abs(y_m - y) < err):\\n err = abs(x_m - x)\\n\\n pointMap[i][j] = pointMap[i + m][k] + 1\\n prePoint[i][j] = k\\n postPoint[i + m][k] = j\\n check = True\\n\\n break ## breaks out of the m loop. Why is it not conditioned by check ? TODO: ???\\n\\n if (pointMap[i][j] > max1):\\n max1 = pointMap[i][j]\\n posMax = cv2.KeyPoint(i, j, _size=0)\\n \\n else:\\n posMax = None\\n\\n for i in range(points.shape[0]):\\n for j in range(len(points[i])):\\n if posMax:\\n if (pointMap[i][j] > max2 and (i != posMax.pt[0] or j != posMax.pt[1]) and postPoint[i][j] == -1): #FIXME \\\"local variable 'posMax' referenced before assignment\\\" possible\\n max2 = pointMap[i][j]\\n posMax2 = cv2.KeyPoint(i, j, _size=0)\\n\\n\\n\\n if max1 == -1:\\n return\\n\\n # DEFINES LANE 1 POINTS\\n while (max1 >= 1):\\n (x,y) = points[int(posMax.pt[0])][int(posMax.pt[1])].pt\\n lane1.append(\\n [x,y]\\n )\\n if (max1 == 1):\\n break\\n\\n posMax = cv2.KeyPoint(\\n posMax.pt[0]+1,\\n prePoint[int(posMax.pt[0])][int(posMax.pt[1])],\\n _size=0\\n )\\n\\n max1 -= 1\\n\\n # DEFINES LANE 2 POINTS\\n while (max2 >= 1):\\n (x,y) = points[int(posMax2.pt[0])][int(posMax2.pt[1])].pt\\n lane2.append(\\n [x, y]\\n )\\n if (max2 == 1):\\n break\\n\\n posMax2 = cv2.KeyPoint(\\n posMax2.pt[0]+1,\\n prePoint[int(posMax2.pt[0])][int(posMax2.pt[1])],\\n _size=0\\n )\\n\\n max2-= 1\\n\\n subLane1 = np.array(lane1[0:5])\\n subLane2 = np.array(lane2[0:5])\\n\\n # checking if sublane has an empty value\\n\\n line1 = cv2.fitLine(subLane1, 2, 0, 0.01, 0.01)\\n line2 = cv2.fitLine(subLane2, 2, 0, 0.01, 0.01)\\n\\n try:\\n lane1X = (self.BIRDVIEW_WIDTH - line1[3]) * line1[0] / line1[1] + line1[2]\\n except:\\n lane1X = 0\\n\\n try:\\n lane2X = (self.BIRDVIEW_WIDTH - line2[3]) * line2[0] / line2[1] + line2[2]\\n except:\\n lane2X = 0\\n \\n if (lane1X < lane2X):\\n for i in range(len(lane1)):\\n self.leftLane[int(np.floor(lane1[i][1] / self.slideThickness ))] = lane1[i]\\n\\n for i in range(len(lane2)):\\n self.rightLane[int(np.floor(lane2[i][1] / self.slideThickness ))] = lane2[i]\\n\\n else:\\n\\n for i in range(len(lane1)):\\n self.rightLane[int(np.floor(lane1[i][1] / self.slideThickness ))] = lane1[i]\\n\\n for i in range(len(lane2)):\\n self.leftLane[int(np.floor(lane2[i][1] / self.slideThickness ))] = lane2[i]\",\n \"def curvature(self):\\n if self.x[0] == self.x[-1] and self.y[0] == self.y[-1]:\\n x_looped=self.x\\n y_looped=self.y\\n else:\\n x_looped=np.append(self.x,self.x[0])\\n y_looped=np.append(self.y,self.y[0])\\n\\n dsx=np.diff(x_looped)\\n dsy=np.diff(y_looped)\\n ds=np.sqrt(dsx**2+dsy**2)\\n Tx=dsx/ds\\n Ty=dsy/ds\\n ds2=0.5*(np.append(ds[-1],ds[:-1])+ds)\\n if self.test:\\n print('x_looped', x_looped)\\n print('y_looped', y_looped)\\n print('dsx', dsx)\\n print('dsy', dsy)\\n print('ds', ds)\\n print('ds2', ds2)\\n Hx=np.diff(np.append(Tx[-1],Tx))/ds2\\n Hy=np.diff(np.append(Ty[-1],Ty))/ds2\\n self._curvature_vector=np.asarray([Hx,Hy]).transpose()\\n curvature=np.sqrt(Hx**2+Hy**2)\\n if self.test:\\n print('curvature', curvature)\\n return curvature\",\n \"def check_point_left(nodeL, nodeR, city):\\n A = get_city_points(city)\\n B = get_node_points(nodeR)\\n C = get_node_points(nodeL)\\n slope = _slope(A, B)\\n (F, G) = calibrator(A, B, slope)\\n sign = math.copysign(1, ((G[0] - F[0]) * (C[1] - F[1]) - (G[1] - F[1]) * (C[0] - F[0])))\\n\\n if slope == \\\"horizontal\\\":\\n if sign == -1:\\n if A[0] > B[0]:\\n return True\\n else:\\n return False\\n else:\\n if A[0] < B[0]:\\n return True\\n else:\\n return False\\n\\n if slope == \\\"vertical\\\":\\n if sign == -1:\\n if A[1] < B[1]:\\n return True\\n else:\\n return False\\n else:\\n if A[1] > B[1]:\\n return True\\n else:\\n return False\\n\\n if slope == \\\"inclined\\\":\\n if sign == -1:\\n if A[1] < B[1]:\\n return True\\n else:\\n return False\\n else:\\n if A[1] > B[1]:\\n return True\\n else:\\n return False\\n\\n if slope == \\\"declined\\\":\\n if sign == -1:\\n if A[1] < B[1]:\\n return True\\n else:\\n return False\\n else:\\n if A[1] > B[1]:\\n return True\\n else:\\n return False\",\n \"def boundaries_and_initialize():\\n greenLower = (29, 86, 6) # define the lower and upper boundaries of the \\\"green\\\"\\n greenUpper = (64, 255, 255)\\n pts = [((200,300),(255,255,255), 0)]\\n blanks = []\\n linecolor = (0,0,0)\\n counter = 1\\n radius = 11\\n return greenLower, greenUpper, pts, linecolor, counter, blanks, radius\",\n \"def _calc_side(self):\\n\\n # Calculation of the side of the car with respect to the trajectory\\n next_index = self.index + 1\\n\\n if next_index == len(self.x_trajectory):\\n next_index = self.index\\n\\n trajectory_vector = ((self.x_trajectory[next_index]\\n - self.x_trajectory[self.index]),\\n (self.y_trajectory[next_index]\\n - self.y_trajectory[self.index]))\\n\\n x_diff = self.x - self.x_trajectory[self.index]\\n y_diff = self.y - self.y_trajectory[self.index]\\n\\n ugv_vector = (x_diff, y_diff)\\n\\n vector_z = ugv_vector[0] * trajectory_vector[1] \\\\\\n - ugv_vector[1] * trajectory_vector[0]\\n\\n if vector_z >= 0:\\n\\n # It is in the right side\\n self.sign = 1\\n\\n else:\\n\\n # It is in the left side\\n self.sign = -1\\n\\n return self.sign\",\n \"def getVisualFieldOrigin(self):\\r\\n\\r\\n if not hasattr(self, 'finalPatchesMarked'):\\r\\n raise LookupError('Please mark the final patches first!!')\\r\\n\\r\\n if not hasattr(self, 'altPosMapf'):\\r\\n _ = self._getSignMap()\\r\\n\\r\\n try:\\r\\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\\r\\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\\r\\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\\r\\n\\r\\n overlap = 0 # number of overlaping pixels\\r\\n iterNum = 1 # number of iteration\\r\\n while overlap < 1:\\r\\n # print 'Iteration number for finding overlapping pixel:', iterNum\\r\\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\\r\\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\\r\\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\\r\\n totalField = V1 + LM + RL\\r\\n # plt.imshow(totalField)\\r\\n overlap = len(np.argwhere(totalField == 3))\\r\\n iterNum += 1\\r\\n # print 'Number of overlapping pixels:', overlap\\r\\n # plt.show()\\r\\n\\r\\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\\r\\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\\r\\n\\r\\n except KeyError:\\r\\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\\\nSetting origins to 0 ...')\\r\\n altPosOrigin = 0.\\r\\n aziPosOrigin = 0.\\r\\n\\r\\n return altPosOrigin, aziPosOrigin\",\n \"def lefton(hedge, point):\\r\\n\\r\\n return area2(hedge, point) >= 0\",\n \"def test_velocity_boundaries(self):\\n L_x = self.x_edge[-1]\\n np.testing.assert_array_almost_equal(self.v_box(self.t, 0), 0, decimal=4)\\n np.testing.assert_array_almost_equal(self.v_box(self.t, L_x), 0, decimal=4)\",\n \"def detect_boundary(self, x, l_old):\\n pass\",\n \"def measure_curvature(self, warped, leftx, rightx):\\n\\t\\t# Define conversions in x and y from pixels space to meters\\n\\t\\t#xm_per_pix = 3.7/warped.shape[1] # meters per pixel in x dimension\\n\\t\\t#ym_per_pix = 30.0/warped.shape[0] # meters per pixel in y dimension\\n\\t\\txm_per_pix = 3.7/700 # meters per pixel in x dimension\\n\\t\\tym_per_pix = 30.0/720 # meters per pixel in y dimension\\n\\t\\t# Generate some fake data to represent lane-line pixels\\n\\t\\tploty = np.linspace(0, 719, num=720) # to cover same y-range as image\\n\\t\\t# Fit second order polynomials to x, y in world space\\n\\t\\tleft_fit_cr = np.polyfit(ploty * ym_per_pix, leftx * xm_per_pix, 2)\\n\\t\\tright_fit_cr = np.polyfit(ploty * ym_per_pix, rightx * xm_per_pix, 2)\\n\\t\\t# Define y-value where we want radius of curvature\\n\\t\\t# Choose the maximum y-value, corresponding to the bottom of the image\\n\\t\\ty_eval = np.max(ploty)\\n\\t\\t# Calculate radius of fitted curvature\\n\\t\\tleft_curverad = ((1 + (2 * left_fit_cr[0] * y_eval * ym_per_pix + left_fit_cr[1]) ** 2) ** 1.5) / np.absolute(2 * left_fit_cr[0])\\n\\t\\tright_curverad = ((1 + (2 * right_fit_cr[0] * y_eval * ym_per_pix + right_fit_cr[1]) ** 2) ** 1.5) / np.absolute(2 * right_fit_cr[0])\\n\\t\\t# Calculate the lane deviation\\n\\t\\tlane_deviation = self.lane_deviation(warped, xm_per_pix)\\n\\n\\t\\treturn left_curverad, right_curverad, lane_deviation\",\n \"def near_way(self):\\r\\n\\r\\n prey_position = np.array(self.prey.position)\\r\\n actual_position = np.array(self.previous_data[-1])\\r\\n previous_position = np.array(self.previous_data[-2])\\r\\n\\r\\n difference_actual = np.linalg.norm(prey_position - actual_position)\\r\\n difference_previous = np.linalg.norm(prey_position - previous_position)\\r\\n\\r\\n if difference_actual < difference_previous:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def offset(x, y, L):\\n length = x.size\\n offsetx = np.zeros((length, 2))\\n offsety = np.zeros((length, 2))\\n dx = np.zeros(length-1)\\n dy = np.zeros(length-1)\\n dxL = np.zeros(length-1)\\n dyL = np.zeros(length-1)\\n xl = np.zeros(length) # counterclockwise\\n xr = np.zeros(length) # clockwise\\n yl = np.zeros(length)\\n yr = np.zeros(length)\\n xl0 = np.zeros(length)\\n xr0 = np.zeros(length)\\n yl0 = np.zeros(length)\\n yr0 = np.zeros(length) \\n for i in range(0, length-1):\\n dx[i] = x[i+1]-x[i]\\n dy[i] = y[i+1]-y[i]\\n for i in range(0, length-1):\\n r = np.sqrt(dx[i]**2 + dy[i]**2)\\n dxL[i] = dx[i]*L/r\\n dyL[i] = dy[i]*L/r\\n xl0[i] = -dyL[i] + x[i]\\n yl0[i] = dxL[i] + y[i]\\n xr0[i] = dyL[i] + x[i]\\n yr0[i] = -dxL[i] + y[i]\\n xl0[length-1] = xl0[length-2] + dx[length-2]\\n yl0[length-1] = yl0[length-2] + dy[length-2]\\n xr0[length-1] = xr0[length-2] + dx[length-2]\\n yr0[length-1] = yr0[length-2] + dy[length-2]\\n xl[0] = xl0[0]\\n yl[0] = yl0[0]\\n xl[length-1] = xl0[length-1]\\n yl[length-1] = yl0[length-1]\\n xr[0] = xr0[0]\\n yr[0] = yr0[0]\\n xr[length-1] = xr0[length-1]\\n yr[length-1] = yr0[length-1]\\n for i in range(1, length-1):\\n a = np.array([[dy[i-1], -dx[i-1]], [dy[i], -dx[i]]])\\n bl = np.array([dy[i-1]*xl0[i-1]-dx[i-1]*yl0[i-1], dy[i]*xl0[i]-dx[i]*yl0[i]])\\n br = np.array([dy[i-1]*xr0[i-1]-dx[i-1]*yr0[i-1], dy[i]*xr0[i]-dx[i]*yr0[i]])\\n theta = (dx[i-1]*dx[i]+dy[i-1]*dy[i])/(dx[i-1]**2+dy[i-1]**2)**0.5/(dx[i]**2+dy[i]**2)**0.5\\n if theta > 1 - 1e-10:\\n xl[i] = xl0[i]\\n yl[i] = yl0[i]\\n xr[i] = xr0[i]\\n yr[i] = yr0[i]\\n else:\\n pl = np.linalg.solve(a, bl)\\n xl[i] = pl[0]\\n yl[i] = pl[1]\\n pr = np.linalg.solve(a, br)\\n xr[i] = pr[0]\\n yr[i] = pr[1]\\n offsetx[:, 0], offsetx[:, 1] = xl, xr\\n offsety[:, 0], offsety[:, 1] = yl, yr\\n return offsetx, offsety\",\n \"def maybe_rectal(self):\\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))\",\n \"def find_field_angle(self) -> None:\\r\\n\\r\\n # Gather required info\\r\\n size = self.picture.get_size()\\r\\n \\r\\n # Make a center box in the field\\r\\n # Make sure there are no more than 50 plants in this box\\r\\n smol = 5\\r\\n while len([i\\r\\n for i in self.plants\\r\\n if within(i.get_center(), (smol//2*size[0]//smol,\\r\\n smol//2*size[1]//smol,\\r\\n (smol//2+1)*size[0]//smol,\\r\\n (smol//2+1)*size[1]//smol))]\\r\\n ) > 50:\\r\\n \\r\\n smol += 1\\r\\n\\r\\n small_box = (2*size[0]//smol,\\r\\n 2*size[1]//smol,\\r\\n 3*size[0]//smol,\\r\\n 3*size[1]//smol)\\r\\n\\r\\n slopes = []\\r\\n\\r\\n # iterate throught the centers of all plants in the box \\r\\n for pivot in [i for i in self.centers if within(i, small_box)]:\\r\\n\\r\\n # Get a pivot point within the small_box\\r\\n pivot = (-1, -1)\\r\\n while not within(pivot, small_box):\\r\\n pivot = choice(self.centers)\\r\\n\\r\\n # Initialize variables\\r\\n best_slope = 0\\r\\n percent_green = 0\\r\\n\\r\\n # Go throught all of the plants within the small_box\\r\\n for i in self.centers:\\r\\n if within(i, small_box) and i != pivot:\\r\\n\\r\\n # Determine how much green a line draw\\r\\n # from the pivot to the new point hits\\r\\n try:\\r\\n slope = (pivot[1] - i[1]) / (pivot[0] - i[0])\\r\\n except ZeroDivisionError:\\r\\n continue\\r\\n PGOL = self.picture.percent_plant_on_line(i, slope)\\r\\n\\r\\n # If the green hit is more than the current green,\\r\\n # replace it\\r\\n if PGOL > percent_green:\\r\\n best_slope = slope\\r\\n percent_green = PGOL\\r\\n\\r\\n # Save the best slope\\r\\n slopes.append(best_slope)\\r\\n\\r\\n # Find and set the median of all the best slopes\\r\\n self.slope = median(slopes)\",\n \"def _ul_lr(self):\\n ulx, xres, xskew, uly, yskew, yres = self.geotransform\\n # Index from the end - GDal usually orders bands-first:\\n lrx = ulx + (self.array.shape[-2] * xres)\\n lry = uly + (self.array.shape[-1] * yres)\\n return ulx, uly, lrx, lry\",\n \"def increase_left_boundary(self):\\n self.L = self.L - 1.0\\n self.Ne = self.Ne + 1\",\n \"def detectWallCollision(self):\\n if self.right >= GAME_WIDTH or self.left <= 0:\\n self._vx = -1.0 * self._vx\\n if self.top >= GAME_HEIGHT:\\n self._vy = -1.0 * self._vy\",\n \"def __isFarFromLevel(self, l):\\n\\n s = np.mean(self.df['high'] - self.df['low'])\\n return np.sum([abs(l-x) < s for x in self.levels]) == 0\",\n \"def check_extent(self):\\n if self.lower_left.x > self.upper_right.x:\\n dlx = self.lower_left.x\\n self.lower_left.x = self.upper_right.x\\n self.upper_right.y = dlx\\n\\n if self.lower_left.y > self.upper_right.y:\\n dly = self.lower_left.y\\n self.lower_left.y = self.upper_right.y\\n self.upper_right.y = dly\",\n \"def test_non_euclidean_scale_curvature(self):\\n\\n magic = 77773.333773777773733\\n for kdir in (1, -1):\\n for mul in (2, 5, 1/3, 1/11, magic, 1/magic):\\n for name, dim in (\\n ('sphere_s1', 1),\\n ('sphere_v2', 2),\\n ('sphere_s2', 2),\\n ('sphere_v3', 3)\\n ):\\n s1 = space(fake_curvature=kdir)\\n s2 = space(fake_curvature=kdir / mul)\\n self.assertTrue(isclose(\\n getattr(s1, name)(1) * mul**dim,\\n getattr(s2, name)(mul)\\n ))\",\n \"def check(self):\\n\\n # get values\\n ystart, xleft, xright, nx, ny = self.get()\\n\\n # are they all OK individually?\\n ok = self.ystart.ok() and self.xleft.ok() and self.xright.ok() and \\\\\\n self.nx.ok() and self.ny.ok()\\n\\n # now come cross-value checks:\\n\\n # is rightmost pixel of lefthand window within range\\n if xleft is None or xleft + nx - 1 > 512:\\n self.xleft.config(bg=COL_WARN)\\n ok = False\\n\\n # is rightmost pixel of righthand window within range\\n if xright is None or xright + nx - 1 > 1024:\\n self.xright.config(bg=COL_WARN)\\n ok = False\\n\\n # is top pixel within range\\n if ystart is None or ystart + ny - 1 > 1024:\\n self.ystart.config(bg=COL_WARN)\\n ok = False\\n\\n if ok:\\n # set all OK is everything checks\\n self.ystart.config(bg=COL_TEXT_BG)\\n self.xleft.config(bg=COL_TEXT_BG)\\n self.xright.config(bg=COL_TEXT_BG)\\n self.nx.config(bg=COL_TEXT_BG)\\n self.ny.config(bg=COL_TEXT_BG)\\n \\n return ok\",\n \"def find_reference_radials(azi, vel, debug=False):\\n pos_valid = get_valid_rays(vel)\\n pos_static = get_static_rays(vel)\\n\\n # Finding intersects of criteria 1 to 3.\\n weight_valid = np.arange(0, len(pos_valid), 1)\\n weight_static = np.arange(0, len(pos_static), 1)\\n\\n total_weight = np.zeros(len(pos_valid)) + np.NaN\\n for cnt, (one_valid, one_valid_weight) in enumerate(zip(pos_valid, weight_valid)):\\n try:\\n one_static_weight = weight_static[one_valid == pos_static][0]\\n except IndexError:\\n one_static_weight = 9999\\n\\n total_weight[cnt] = one_static_weight + one_valid_weight\\n\\n pos1 = pos_valid[np.argmin(total_weight)]\\n\\n# # Finding the 2nd radial of reference\\n# pos2 = pos1 + len(azi) // 2\\n# if pos2 >= len(azi):\\n# pos2 -= len(azi)\\n\\n try:\\n ref2_range_min, ref2_range_max = get_opposite_azimuth(azi[pos1])\\n if ref2_range_min < ref2_range_max:\\n goodpos = np.where((azi >= ref2_range_min) & (azi <= ref2_range_max))[0]\\n else:\\n goodpos = np.where((azi >= ref2_range_min) | (azi <= ref2_range_max))[0]\\n\\n rslt = [(a, total_weight[a == pos_valid][0]) for a in goodpos if a in pos_valid]\\n opposite_pos, opposite_weight = zip(*rslt)\\n pos2 = opposite_pos[np.argmin(opposite_weight)]\\n except Exception:\\n pos2 = pos1 + len(azi) // 2\\n if pos2 > len(azi):\\n pos2 -= len(azi)\\n if debug:\\n print(f\\\"References are azimuths {azi[pos1]} and {azi[pos2]}, i.e. azimuthal positions {pos1} and {pos2}.\\\")\\n\\n return pos1, pos2\",\n \"def _GetHorizonAnglesLegacy(its_elev, height_cbsd, height_rx, refractivity):\\n num_points = int(its_elev[0])\\n step = its_elev[1]\\n dist = num_points * step\\n\\n # Find the refractivity at the average terrain height\\n start_avg = int(3.0 + 0.1 * num_points)\\n end_avg = num_points - start_avg + 6\\n zsys = np.mean(its_elev[start_avg-1:end_avg])\\n refractivity *= np.exp(-zsys/9460.0)\\n\\n # Find the ray down-curvature per meter\\n gma = 157e-9\\n gme = gma*(1.0 - 0.04665 * np.exp(refractivity/179.3))\\n\\n alt_cbsd = its_elev[2] + height_cbsd\\n alt_rx = its_elev[num_points+2] + height_rx\\n qc = 0.5 * gme\\n q = qc * dist\\n # theta0 and theta1 the slopes, dl0 and dl1 the horizon distances\\n theta1 = (alt_rx - alt_cbsd) / dist\\n theta0 = theta1 - q\\n theta1 = -theta1 - q\\n dl0 = dist\\n dl1 = dist\\n\\n if num_points >= 2:\\n sa = 0.0\\n sb = dist\\n wq = True\\n for i in range(1, num_points):\\n sa += step\\n sb -= step\\n q = its_elev[i+2] - (qc*sa + theta0) * sa - alt_cbsd\\n if q > 0.0:\\n theta0 += q/sa\\n dl0 = sa\\n wq = False\\n if not wq:\\n q = its_elev[i+2] - (qc*sb + theta1) * sb - alt_rx\\n if q > 0.0:\\n theta1 += q/sb\\n dl1 = sb\\n\\n return (np.arctan(theta0) * 180/np.pi,\\n np.arctan(theta1) * 180/np.pi,\\n dl0,\\n dl1)\",\n \"def box_valid(self):\\n return ((self.lt.x >= 0)\\n and (self.lt.y >= 0)\\n and (self.rb.x >= self.lt.x)\\n and (self.rb.y >= self.lt.y))\",\n \"def _get_valid_index(lons_side1, lons_side2, lons_side3, lons_side4,\\n lats_side1, lats_side2, lats_side3, lats_side4,\\n lons, lats, radius_of_influence):\\n\\n # Coarse reduction of data based on extrema analysis of the boundary\\n # lon lat values of the target grid\\n illegal_lons = (((lons_side1 < -180) | (lons_side1 > 180)).any() or\\n ((lons_side2 < -180) | (lons_side2 > 180)).any() or\\n ((lons_side3 < -180) | (lons_side3 > 180)).any() or\\n ((lons_side4 < -180) | (lons_side4 > 180)).any())\\n\\n illegal_lats = (((lats_side1 < -90) | (lats_side1 > 90)).any() or\\n ((lats_side2 < -90) | (lats_side2 > 90)).any() or\\n ((lats_side3 < -90) | (lats_side3 > 90)).any() or\\n ((lats_side4 < -90) | (lats_side4 > 90)).any())\\n\\n if illegal_lons or illegal_lats:\\n # Grid boundaries are not safe to operate on\\n return np.ones(lons.size, dtype=np.bool)\\n\\n # Find sum angle sum of grid boundary\\n angle_sum = 0\\n for side in (lons_side1, lons_side2, lons_side3, lons_side4):\\n prev = None\\n side_sum = 0\\n for lon in side:\\n if prev:\\n delta = lon - prev\\n if abs(delta) > 180:\\n delta = (abs(delta) - 360) * (delta // abs(delta))\\n angle_sum += delta\\n side_sum += delta\\n prev = lon\\n\\n # Buffer min and max lon and lat of interest with radius of interest\\n lat_min = min(lats_side1.min(), lats_side2.min(), lats_side3.min(),\\n lats_side4.min())\\n lat_min_buffered = lat_min - float(radius_of_influence) / R\\n lat_max = max(lats_side1.max(), lats_side2.max(), lats_side3.max(),\\n lats_side4.max())\\n lat_max_buffered = lat_max + float(radius_of_influence) / R\\n\\n max_angle_s2 = max(abs(lats_side2.max()), abs(lats_side2.min()))\\n max_angle_s4 = max(abs(lats_side4.max()), abs(lats_side4.min()))\\n lon_min_buffered = (lons_side4.min() -\\n float(radius_of_influence) /\\n (np.sin(np.radians(max_angle_s4)) * R))\\n\\n lon_max_buffered = (lons_side2.max() +\\n float(radius_of_influence) /\\n (np.sin(np.radians(max_angle_s2)) * R))\\n\\n # From the winding number theorem follows:\\n # angle_sum possiblilities:\\n # -360: area covers north pole\\n # 360: area covers south pole\\n # 0: area covers no poles\\n # else: area covers both poles\\n if round(angle_sum) == -360:\\n # Covers NP\\n valid_index = (lats >= lat_min_buffered)\\n elif round(angle_sum) == 360:\\n # Covers SP\\n valid_index = (lats <= lat_max_buffered)\\n elif round(angle_sum) == 0:\\n # Covers no poles\\n valid_lats = (lats >= lat_min_buffered) * (lats <= lat_max_buffered)\\n\\n if lons_side2.min() > lons_side4.max():\\n # No date line crossing\\n valid_lons = (lons >= lon_min_buffered) * \\\\\\n (lons <= lon_max_buffered)\\n else:\\n # Date line crossing\\n seg1 = (lons >= lon_min_buffered) * (lons <= 180)\\n seg2 = (lons <= lon_max_buffered) * (lons >= -180)\\n valid_lons = seg1 + seg2\\n\\n valid_index = valid_lats * valid_lons\\n else:\\n # Covers both poles don't reduce\\n valid_index = np.ones(lons.size, dtype=np.bool)\\n\\n return valid_index\",\n \"def nodalLaplacian(self):\\n if getattr(self, '_nodalLaplacian', None) is None:\\n print('Warning: Laplacian has not been tested rigorously.')\\n # The number of cell centers in each direction\\n n = self.vnC\\n # Compute divergence operator on faces\\n if(self.dim == 1):\\n D1 = sdiag(1./self.hx) * ddx(self.nCx)\\n L = - D1.T*D1\\n elif(self.dim == 2):\\n D1 = sdiag(1./self.hx) * ddx(n[0])\\n D2 = sdiag(1./self.hy) * ddx(n[1])\\n L1 = sp.kron(speye(n[1]+1), - D1.T * D1)\\n L2 = sp.kron(- D2.T * D2, speye(n[0]+1))\\n L = L1 + L2\\n elif(self.dim == 3):\\n D1 = sdiag(1./self.hx) * ddx(n[0])\\n D2 = sdiag(1./self.hy) * ddx(n[1])\\n D3 = sdiag(1./self.hz) * ddx(n[2])\\n L1 = kron3(speye(n[2]+1), speye(n[1]+1), - D1.T * D1)\\n L2 = kron3(speye(n[2]+1), - D2.T * D2, speye(n[0]+1))\\n L3 = kron3(- D3.T * D3, speye(n[1]+1), speye(n[0]+1))\\n L = L1 + L2 + L3\\n self._nodalLaplacian = L\\n return self._nodalLaplacian\",\n \"def R_will_change_direction(point0, point1, point2):\\n\\n x0, y0 = point0[0], point0[1]\\n x1, y1 = point1[0], point1[1]\\n x2, y2 = point2[0], point2[1]\\n\\n try:\\n m1 = (x1 - x2) / (y2 - y1)\\n m2 = (y2 - y1) / (x2 - x1)\\n x3 = ((m2 * x1) - (m1 * x0) - y1 + y0) / (m2 - m1)\\n y3 = m1 * (x3 - x0) + y0\\n except ZeroDivisionError:\\n (x3, y3) = (x0, y1) if y1 == y2 else (x1, y0)\\n\\n return ((min(x1, x2) <= x3 <= max(x1, x2)) and (min(y1, y2) <= y3 <= max(y1, y2))), (x3, y3)\",\n \"def isOutsideBorder(self):\\n if (self.posX < -self.myGalaxy.worldWidth or self.posX > self.myGalaxy.worldWidth or\\n self.posY < -self.myGalaxy.worldHeight or self.posY > self.myGalaxy.worldHeight):\\n return 1\\n return 0\",\n \"def In_northIsland(lon, lat):\\n centre_lat = -37.651034\\n centre_lon = 175.435162\\n\\n L_lat = -34.104810\\n L_lon = 172.823488\\n\\n W_lat = -38.888624\\n W_lon = 172.315141\\n\\n theta = -329.0\\n\\n x0 = centre_lon\\n y0 = centre_lat\\n x = lon\\n y = lat\\n\\n xp = np.cos(theta * np.pi / 180.0) * (x - x0) - np.sin(theta * np.pi / 180.0) * (\\n y - y0\\n )\\n yp = np.sin(theta * np.pi / 180.0) * (x - x0) + np.cos(theta * np.pi / 180.0) * (\\n y - y0\\n )\\n\\n xp_L = np.cos(theta * np.pi / 180.0) * (L_lon - x0) - np.sin(\\n theta * np.pi / 180.0\\n ) * (L_lat - y0)\\n yp_L = np.sin(theta * np.pi / 180.0) * (L_lon - x0) + np.cos(\\n theta * np.pi / 180.0\\n ) * (L_lat - y0)\\n L = np.sqrt(xp_L**2 + yp_L**2)\\n\\n xp_W = np.cos(theta * np.pi / 180.0) * (W_lon - x0) - np.sin(\\n theta * np.pi / 180.0\\n ) * (W_lat - y0)\\n yp_W = np.sin(theta * np.pi / 180.0) * (W_lon - x0) + np.cos(\\n theta * np.pi / 180.0\\n ) * (W_lat - y0)\\n W = np.sqrt(xp_W**2 + yp_W**2)\\n\\n if np.abs(xp) <= L and np.abs(yp) <= W:\\n within_southIsland = True\\n else:\\n within_southIsland = False\\n\\n return within_southIsland\",\n \"def corner_init_check():\\r\\n \\\"\\\"\\\"Rule One\\\"\\\"\\\"\\r\\n z = shape-1\\r\\n if example[0, 0] == example[0, 1] and example[0, 0] == example[1, 0] and example[0, 0] != 0: # NE\\r\\n example[0, 0] = 0\\r\\n shade_neighbours(0, 0)\\r\\n print(\\\"RULE 1 NW\\\")\\r\\n if example[0, z] == example[0, z-1] and example[0, z] == example[1, z] and example[0, z] != 0: # NW\\r\\n example[0, z] = 0\\r\\n shade_neighbours(0, z)\\r\\n print(\\\"RULE 1 NE\\\")\\r\\n if example[z, z] == example[z, z-1] and example[z, z] == example[z-1, z] and example[z, z] != 0: # SE\\r\\n example[z, z] = 0\\r\\n shade_neighbours(z, z)\\r\\n print(\\\"RULE 1 SE\\\")\\r\\n if example[z, 0] == example[z, 1] and example[z, 0] == example[z-1, 0] and example[z, 0] != 0: # SW\\r\\n example[z, 0] = 0\\r\\n shade_neighbours(z, 0)\\r\\n print(\\\"RuLE 1 SW\\\")\\r\\n\\r\\n \\\"\\\"\\\"Rule Two\\\"\\\"\\\"\\r\\n if (example[0, 0] == example[0, 1] or example[0, 0] == example[1, 0]) \\\\\\r\\n and (example[1, 1] == example[0, 1] or example[1, 1] == example[1, 0])\\\\\\r\\n and (example[0, 0] != example[1, 1]): # NE\\r\\n example[0, 0] = 0\\r\\n example[1, 1] = 0\\r\\n shade_neighbours(1, 1)\\r\\n print(\\\"RULE 2 NW\\\")\\r\\n if (example[0, z] == example[0, z-1] or example[0, z] == example[1, z]) \\\\\\r\\n and (example[1, z-1] == example[0, z-1] or example[1, z-1] == example[1, z]) \\\\\\r\\n and (example[0, z] != example[1, z-1]): # NW\\r\\n example[0, z] = 0\\r\\n example[1, z-1] = 0\\r\\n shade_neighbours(1, z - 1)\\r\\n print(\\\"RULE 2 NE\\\")\\r\\n if (example[z, z] == example[z, z-1] or example[z, z] == example[z-1, z]) \\\\\\r\\n and (example[z-1, z-1] == example[z-1, z] or example[z-1, z-1] == example[z, z-1]) \\\\\\r\\n and (example[z, z] != example[z-1, z-1]): # SE\\r\\n example[z, z] = 0\\r\\n example[z-1, z-1] = 0\\r\\n shade_neighbours(z - 1, z - 1)\\r\\n print(\\\"RULE 2 SE\\\")\\r\\n if (example[z, 0] == example[z, 1] or example[z, 0] == example[z-1, 0]) \\\\\\r\\n and (example[z-1, 1] == example[z, 1] or example[z-1, 1] == example[z-1, 0]) \\\\\\r\\n and (example[z, 0] != example[z-1, 1]): # SW\\r\\n example[z, 0] = 0\\r\\n example[z-1, 1] = 0\\r\\n shade_neighbours(z - 1, 1)\\r\\n print(\\\"RULE 2 SW\\\")\\r\\n conflict_check()\",\n \"def computeNormalAndCurvature():\\n radius = 50\\n for i,j in pts:\\n nb_pts = ti.cast(0, ti.f32)\\n accu_0 = ti.cast(0, ti.f32)\\n accu_1 = ti.cast(0, ti.f32)\\n accu_2 = ti.cast(0, ti.f32)\\n accu_3 = ti.cast(0, ti.f32)\\n accu_4 = ti.cast(0, ti.f32)\\n accu_5 = ti.cast(0, ti.f32)\\n accu_6 = ti.cast(0, ti.f32)\\n accu_7 = ti.cast(0, ti.f32)\\n accu_8 = ti.cast(0, ti.f32)\\n z = 0\\n for x in range(i-radius, i+radius):\\n for y in range(j-radius, j+radius):\\n if ti.is_active(block1, [x,y]):\\n accu_0 += x * x\\n accu_1 += x * y\\n accu_2 += x * z\\n accu_3 += y * y\\n accu_4 += y * z\\n accu_5 += z * z\\n accu_6 += x\\n accu_7 += y\\n accu_8 += z\\n nb_pts += 1\\n accu_0 /= nb_pts\\n accu_1 /= nb_pts\\n accu_2 /= nb_pts\\n accu_3 /= nb_pts\\n accu_4 /= nb_pts\\n accu_5 /= nb_pts\\n accu_6 /= nb_pts\\n accu_7 /= nb_pts\\n accu_8 /= nb_pts\\n cov_mat_0 = accu_0 - accu_6 * accu_6\\n cov_mat_1 = accu_1 - accu_6 * accu_7\\n cov_mat_2 = accu_2 - accu_6 * accu_8\\n cov_mat_4 = accu_3 - accu_7 * accu_7\\n cov_mat_5 = accu_4 - accu_7 * accu_8\\n cov_mat_8 = accu_5 - accu_8 * accu_8\\n cov_mat_3 = cov_mat_1\\n cov_mat_6 = cov_mat_2\\n cov_mat_7 = cov_mat_5\\n\\n # Compute eigen value and eigen vector\\n # Make sure in [-1, 1]\\n scale = ti.max(1.0, ti.abs(cov_mat_0))\\n scale = ti.max(scale, ti.abs(cov_mat_1))\\n scale = ti.max(scale, ti.abs(cov_mat_2))\\n scale = ti.max(scale, ti.abs(cov_mat_3))\\n scale = ti.max(scale, ti.abs(cov_mat_4))\\n scale = ti.max(scale, ti.abs(cov_mat_5))\\n scale = ti.max(scale, ti.abs(cov_mat_6))\\n scale = ti.max(scale, ti.abs(cov_mat_7))\\n scale = ti.max(scale, ti.abs(cov_mat_8))\\n if scale > 1.0:\\n cov_mat_0 /= scale\\n cov_mat_1 /= scale\\n cov_mat_2 /= scale\\n cov_mat_3 /= scale\\n cov_mat_4 /= scale\\n cov_mat_5 /= scale\\n cov_mat_6 /= scale\\n cov_mat_7 /= scale\\n cov_mat_8 /= scale\\n \\n # Compute roots\\n eigen_val_0 = ti.cast(0, ti.f32)\\n eigen_val_1 = ti.cast(0, ti.f32)\\n eigen_val_2 = ti.cast(0, ti.f32)\\n \\n c0 = cov_mat_0 * cov_mat_4 * cov_mat_8 \\\\\\n + 2 * cov_mat_3 * cov_mat_6 * cov_mat_7 \\\\\\n - cov_mat_0 * cov_mat_7 * cov_mat_7 \\\\\\n - cov_mat_4 * cov_mat_6 * cov_mat_6 \\\\\\n - cov_mat_8 * cov_mat_3 * cov_mat_3\\n c1 = cov_mat_0 * cov_mat_4 \\\\\\n - cov_mat_3 * cov_mat_3 \\\\\\n + cov_mat_0 * cov_mat_8 \\\\\\n - cov_mat_6 * cov_mat_6 \\\\\\n + cov_mat_4 * cov_mat_8 \\\\\\n - cov_mat_7 * cov_mat_7\\n c2 = cov_mat_0 + cov_mat_4 + cov_mat_8\\n \\n if ti.abs(c0) < 0.00001:\\n eigen_val_0 = 0\\n d = c2 * c2 - 4.0 * c1\\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\\n d = 0.0\\n sd = ti.sqrt(d)\\n eigen_val_2 = 0.5 * (c2 + sd)\\n eigen_val_1 = 0.5 * (c2 - sd)\\n else:\\n s_inv3 = ti.cast(1.0 / 3.0, ti.f32)\\n s_sqrt3 = ti.sqrt(3.0)\\n c2_over_3 = c2 * s_inv3\\n a_over_3 = (c1 - c2 * c2_over_3) * s_inv3\\n if a_over_3 > 0:\\n a_over_3 = 0\\n \\n half_b = 0.5 * (c0 + c2_over_3 * (2 * c2_over_3 * c2_over_3 - c1))\\n q = half_b * half_b + a_over_3 * a_over_3 * a_over_3\\n if q > 0:\\n q = 0\\n \\n rho = ti.sqrt(-a_over_3)\\n theta = ti.atan2(ti.sqrt(-q), half_b) * s_inv3\\n cos_theta = ti.cos(theta)\\n sin_theta = ti.sin(theta)\\n eigen_val_0 = c2_over_3 + 2 * rho * cos_theta\\n eigen_val_1 = c2_over_3 - rho * (cos_theta + s_sqrt3 * sin_theta)\\n eigen_val_2 = c2_over_3 - rho * (cos_theta - s_sqrt3 * sin_theta)\\n temp_swap = ti.cast(0, ti.f32)\\n \\n # Sort in increasing order.\\n if eigen_val_0 >= eigen_val_1:\\n temp_swap = eigen_val_1\\n eigen_val_1 = eigen_val_0\\n eigen_val_0 = temp_swap\\n if eigen_val_1 >= eigen_val_2:\\n temp_swap = eigen_val_2\\n eigen_val_2 = eigen_val_1\\n eigen_val_1 = temp_swap\\n if eigen_val_0 >= eigen_val_1:\\n temp_swap = eigen_val_1\\n eigen_val_1 = eigen_val_0\\n eigen_val_0 = temp_swap\\n \\n if eigen_val_0 <= 0:\\n eigen_val_0 = 0\\n d = c2 * c2 - 4.0 * c1\\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\\n d = 0.0\\n sd = ti.sqrt(d)\\n eigen_val_2 = 0.5 * (c2 + sd)\\n eigen_val_1 = 0.5 * (c2 - sd)\\n # end of compute roots\\n\\n eigen_value = eigen_val_1 * scale # eigen value for 2D SDF\\n # eigen value for 3D SDF\\n #eigen_value = eigen_val_0 * scale\\n\\n #print(\\\"eigen_val_0 \\\", eigen_val_0)\\n #print(\\\"eigen_val_1 \\\", eigen_val_1)\\n #print(\\\"eigen_val_2 \\\", eigen_val_2)\\n \\n # TODO\\n #scaledMat.diagonal ().array () -= eigenvalues (0)\\n #eigenvector = detail::getLargest3x3Eigenvector<Vector> (scaledMat).vector;\\n\\n # Compute normal vector (TODO)\\n #visual_norm[i,j][0] = eigen_val_0 #eigen_vector[0]\\n #visual_norm[i,j][1] = eigen_val_1 #eigen_vector[1]\\n #visual_norm[i,j][2] = eigen_val_2 #eigen_vector[2]\\n\\n # Compute the curvature surface change\\n eig_sum = cov_mat_0 + cov_mat_1 + cov_mat_2\\n visual_curv[i,j][0] = 0\\n if eig_sum != 0:\\n visual_curv[i,j][0] = eigen_val_1 # true curvature is: ti.abs(eigen_value / eig_sum)\",\n \"def _cal_meaningful_corners(self):\\n corners = np.where(self._free_of_clash)\\n corners = np.array(corners, dtype=int)\\n corners = corners.transpose()\\n return corners\",\n \"def in_view(self, points):\\n # Need to change this to view in 3D ??\\n pos = self._pos\\n dir = self._dir\\n cpoints = points - pos\\n dists = np.sqrt(np.sum(cpoints**2, axis=0))\\n\\n # Taking dot product for cosine angle\\n cosangles = dir.T.dot(cpoints) / dists\\n cosangles = cosangles[0, :]\\n\\n # The cos angle is negative only when landmark lies behind the robot's heading direction. \\n # Max distance landmarks can be retained. There is no argument or counter-argument yet for in/ex-clusion\\n in_view_pts = (cosangles > np.cos(self._maxangle)) & (dists <= self._maxdist)\\n \\n if len(in_view_pts.shape) > 1:\\n import pdb;pdb.set_trace()\\n return in_view_pts\",\n \"def light_source_directions():\\n L = np.array([[-0.06059872, -0.44839055, 0.8917812],\\n [-0.05939919, -0.33739538, 0.93948714],\\n [-0.05710194, -0.21230722, 0.97553319],\\n [-0.05360061, -0.07800089, 0.99551134],\\n [-0.04919816, 0.05869781, 0.99706274],\\n [-0.04399823, 0.19019233, 0.98076044],\\n [-0.03839991, 0.31049925, 0.9497977],\\n [-0.03280081, 0.41611025, 0.90872238],\\n [-0.18449839, -0.43989616, 0.87889232],\\n [-0.18870114, -0.32950199, 0.92510557],\\n [-0.1901994, -0.20549935, 0.95999698],\\n [-0.18849605, -0.07269848, 0.97937948],\\n [-0.18329657, 0.06229884, 0.98108166],\\n [-0.17500445, 0.19220488, 0.96562453],\\n [-0.16449474, 0.31129005, 0.93597008],\\n [-0.15270716, 0.4160195, 0.89644202],\\n [-0.30139786, -0.42509698, 0.85349393],\\n [-0.31020115, -0.31660118, 0.89640333],\\n [-0.31489186, -0.19549495, 0.92877599],\\n [-0.31450962, -0.06640203, 0.94692897],\\n [-0.30880699, 0.06470146, 0.94892147],\\n [-0.2981084, 0.19100538, 0.93522635],\\n [-0.28359251, 0.30729189, 0.90837601],\\n [-0.26670649, 0.41020998, 0.87212122],\\n [-0.40709586, -0.40559588, 0.81839168],\\n [-0.41919869, -0.29999906, 0.85689732],\\n [-0.42618633, -0.18329412, 0.88587159],\\n [-0.42691512, -0.05950211, 0.90233197],\\n [-0.42090385, 0.0659006, 0.90470827],\\n [-0.40860354, 0.18720162, 0.89330773],\\n [-0.39141794, 0.29941372, 0.87013988],\\n [-0.3707838, 0.39958255, 0.83836338],\\n [-0.499596, -0.38319693, 0.77689378],\\n [-0.51360334, -0.28130183, 0.81060526],\\n [-0.52190667, -0.16990217, 0.83591069],\\n [-0.52326874, -0.05249686, 0.85054918],\\n [-0.51720021, 0.06620003, 0.85330035],\\n [-0.50428312, 0.18139393, 0.84427174],\\n [-0.48561334, 0.28870793, 0.82512267],\\n [-0.46289771, 0.38549809, 0.79819605],\\n [-0.57853599, -0.35932235, 0.73224555],\\n [-0.59329349, -0.26189713, 0.76119165],\\n [-0.60202327, -0.15630604, 0.78303027],\\n [-0.6037003, -0.04570002, 0.7959004],\\n [-0.59781529, 0.06590169, 0.79892043],\\n [-0.58486953, 0.17439091, 0.79215873],\\n [-0.56588359, 0.27639198, 0.77677747],\\n [-0.54241965, 0.36921337, 0.75462733],\\n [0.05220076, -0.43870637, 0.89711304],\\n [0.05199786, -0.33138635, 0.9420612],\\n [0.05109826, -0.20999284, 0.97636672],\\n [0.04919919, -0.07869871, 0.99568366],\\n [0.04640163, 0.05630197, 0.99733494],\\n [0.04279892, 0.18779527, 0.98127529],\\n [0.03870043, 0.30950341, 0.95011048],\\n [0.03440055, 0.41730662, 0.90811441],\\n [0.17290651, -0.43181626, 0.88523333],\\n [0.17839998, -0.32509996, 0.92869988],\\n [0.18160174, -0.20480196, 0.96180921],\\n [0.18200745, -0.07490306, 0.98044012],\\n [0.17919505, 0.05849838, 0.98207285],\\n [0.17329685, 0.18839658, 0.96668244],\\n [0.1649036, 0.30880674, 0.93672045],\\n [0.1549931, 0.41578148, 0.89616009],\\n [0.28720483, -0.41910705, 0.8613145],\\n [0.29740177, -0.31410186, 0.90160535],\\n [0.30420604, -0.1965039, 0.9321185],\\n [0.30640529, -0.07010121, 0.94931639],\\n [0.30361153, 0.05950226, 0.95093613],\\n [0.29588748, 0.18589214, 0.93696036],\\n [0.28409783, 0.30349768, 0.90949304],\\n [0.26939905, 0.40849857, 0.87209694],\\n [0.39120402, -0.40190413, 0.8279085],\\n [0.40481085, -0.29960803, 0.86392315],\\n [0.41411685, -0.18590756, 0.89103626],\\n [0.41769724, -0.06449957, 0.906294],\\n [0.41498764, 0.05959822, 0.90787296],\\n [0.40607977, 0.18089099, 0.89575537],\\n [0.39179226, 0.29439419, 0.87168279],\\n [0.37379609, 0.39649585, 0.83849122],\\n [0.48278794, -0.38169046, 0.78818031],\\n [0.49848546, -0.28279175, 0.8194761],\\n [0.50918069, -0.1740934, 0.84286803],\\n [0.51360856, -0.05870098, 0.85601427],\\n [0.51097962, 0.05899765, 0.8575658],\\n [0.50151639, 0.17420569, 0.84742769],\\n [0.48600297, 0.28260173, 0.82700506],\\n [0.46600106, 0.38110087, 0.79850181],\\n [0.56150442, -0.35990283, 0.74510586],\\n [0.57807114, -0.26498677, 0.77176147],\\n [0.58933134, -0.1617086, 0.7915421],\\n [0.59407609, -0.05289787, 0.80266769],\\n [0.59157958, 0.057798, 0.80417224],\\n [0.58198189, 0.16649482, 0.79597523],\\n [0.56620006, 0.26940003, 0.77900008],\\n [0.54551481, 0.36380988, 0.7550205]], dtype=float)\\n return L\",\n \"def _move_ligand_to_lower_corner(self):\\n spacing = self._grid[\\\"spacing\\\"]\\n lower_ligand_corner = np.array([self._crd[:,i].min() for i in range(3)], dtype=float) - 1.5*spacing\\n upper_ligand_corner = np.array([self._crd[:,i].max() for i in range(3)], dtype=float) + 1.5*spacing\\n #\\n ligand_box_lenghts = upper_ligand_corner - lower_ligand_corner\\n if np.any(ligand_box_lenghts < 0):\\n raise RuntimeError(\\\"One of the ligand box lenghts are negative\\\")\\n\\n max_grid_indices = np.ceil(ligand_box_lenghts / spacing)\\n self._max_grid_indices = self._grid[\\\"counts\\\"] - np.array(max_grid_indices, dtype=int)\\n if np.any(self._max_grid_indices <= 1):\\n raise RuntimeError(\\\"At least one of the max grid indices is <= one\\\")\\n \\n displacement = self._origin_crd - lower_ligand_corner\\n for atom_ind in range(len(self._crd)):\\n self._crd[atom_ind] += displacement\\n \\n self._initial_com = self._get_molecule_center_of_mass()\\n return None\",\n \"def check_point_right(nodeL, nodeR, city):\\n A = get_city_points(city)\\n B = get_node_points(nodeL)\\n C = get_node_points(nodeR)\\n slope = _slope(A, B)\\n (F, G) = calibrator(A, B, slope)\\n sign = math.copysign(1, ((G[0] - F[0]) * (C[1] - F[1]) - (G[1] - F[1]) * (C[0] - F[0])))\\n\\n if slope == \\\"horizontal\\\":\\n if sign == 1:\\n if A[0] > B[0]:\\n return True\\n else:\\n return False\\n else:\\n if A[0] < B[0]:\\n return True\\n else:\\n return False\\n\\n if slope == \\\"vertical\\\":\\n if sign == 1:\\n if A[1] < B[1]:\\n return True\\n else:\\n return False\\n else:\\n if A[1] > B[1]:\\n return True\\n else:\\n return False\\n\\n if slope == \\\"inclined\\\":\\n if sign == 1:\\n if A[1] < B[1]:\\n return True\\n else:\\n return False\\n else:\\n if A[1] > B[1]:\\n return True\\n else:\\n return False\\n\\n if slope == \\\"declined\\\":\\n if sign == 1:\\n if A[1] < B[1]:\\n return True\\n else:\\n return False\\n else:\\n if A[1] > B[1]:\\n return True\\n else:\\n return False\",\n \"def calculate_gate(self,offset):\\n (rx,ry,_) = self.robot.world.particle_filter.pose\\n dx = self.object.x\\n dy = self.object.y\\n dtheta = self.object.theta\\n pt1x = dx + offset * cos(dtheta)\\n pt1y = dy + offset * sin(dtheta)\\n pt2x = dx + offset * cos(dtheta+pi)\\n pt2y = dy + offset * sin(dtheta+pi)\\n dist1sq = (pt1x-rx)**2 + (pt1y-ry)**2\\n dist2sq = (pt2x-rx)**2 + (pt2y-ry)**2\\n if dist1sq < dist2sq:\\n return (pt1x, pt1y)\\n else:\\n return (pt2x, pt2y)\",\n \"def is_rectal(self):\\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\\\\n or bool(self.depth and 4 <= self.depth <= 16)\",\n \"def test_outside_plus_inside(self):\\n for region, bounds in load_region_bounds_dict().items():\\n lon_bounds, lat_bounds = bounds\\n for key in ['data01', 'ds_shift_lon', 'ds_rev_both', 'ds_irr_both']:\\n outside_data = climapy.xr_mask_bounds(data_dict[key],\\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\\n select_how='outside')['PRECL']\\n inside_data = climapy.xr_mask_bounds(data_dict[key],\\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\\n select_how='inside')['PRECL']\\n outside_plus_inside = (np.nan_to_num(outside_data.values) +\\n np.nan_to_num(inside_data.values))\\n diff_from_input = outside_plus_inside - data_dict[key]['PRECL'].values\\n assert np.abs(diff_from_input).max() == 0\",\n \"def find_current_points_r(grad_mag, x_mean_scaled, normals_length, display_normals=False, img=None):\\n if img is None:\\n img = grad_mag\\n\\n # Norm Calculation\\n normals = np.zeros((no_points, 2))\\n for i in range(0, no_points):\\n # the first and the last points vectors should\\n # be calculated using one neighbor\\n if i == 0:\\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i]\\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i + no_points]\\n elif i == no_points - 1:\\n ux = x_mean_scaled[i] - x_mean_scaled[i - 1]\\n uy = x_mean_scaled[i + no_points] - x_mean_scaled[i + no_points - 1]\\n else:\\n # points that have two neighbors\\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i - 1]\\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i - 1 + no_points]\\n # nx, ny for each point\\n normals[i, 0] = -uy / sqrt(ux * ux + uy * uy)\\n normals[i, 1] = ux / sqrt(ux * ux + uy * uy)\\n\\n # PLOT normals\\n if display_normals:\\n display_normals(normals, x_mean_scaled, img, normals_length)\\n\\n # finding correct positions on the model, Y\\n Y = np.zeros(x_mean_scaled.shape)\\n\\n for i in range(0, no_points):\\n # landmark point coordinates\\n px = float(x_mean_scaled[i])\\n py = float(x_mean_scaled[i + no_points])\\n nx, ny = normals[i, :]\\n max_y, max_x = grad_mag.shape\\n check_pixels = []\\n\\n for t in (-normals_length, normals_length):\\n lx = int(px + t * nx)\\n ly = int(py + t * ny)\\n\\n # check boundaries\\n if lx >= max_x:\\n lx = max_x - 1\\n elif lx < 0:\\n lx = 0\\n\\n if ly >= max_y:\\n ly = max_y - 1\\n elif ly < 0:\\n ly = 0\\n\\n check_pixels.append((ly, lx))\\n\\n pf_line = profile_line(grad_mag, check_pixels[1], check_pixels[0], linewidth=3)\\n pf_line_coors = _line_profile_coordinates(check_pixels[1], check_pixels[0], linewidth=1)\\n\\n mag_argmax = np.argmax(pf_line)\\n Y[i] = int(pf_line_coors[1, mag_argmax, :])\\n Y[i + no_points] = int(pf_line_coors[0, mag_argmax, :])\\n\\n return Y\",\n \"def _isLeft(P0, P1, P2):\\n return (P1.x - P0.x)*(P2.y - P0.y) - (P2.x - P0.x)*(P1.y - P0.y)\",\n \"def find_lane(self, warped_img):\\n if not self.detected:\\n # Use sliding window if lanes are not detected on the previous frame\\n leftx, lefty, rightx, righty, out_img = leftx, lefty, rightx, righty, out_img = find_lane_sliding_window(warped_img)\\n left_fit, right_fit, left_fitx, right_fitx, ploty = fit_poly(warped_img.shape, leftx, lefty, rightx, righty)\\n curvature, distance = curvature_and_position(ploty, left_fit, right_fit, warped_img.shape[1])\\n self.last_left_fit = left_fit\\n self.last_right_fit = right_fit\\n self.last_ploty = ploty\\n self.detected = True\\n return left_fitx, right_fitx, ploty, curvature, distance\\n \\n else:\\n try:\\n leftx, lefty, rightx, righty, out_img = find_lane_from_prior(warped_img, self.last_left_fit, self.last_right_fit, self.ploty)\\n left_fit, right_fit, left_fitx, right_fitx, ploty = fit_poly(warped_img.shape, leftx, lefty, rightx, righty)\\n curvature, distance = curvature_and_position(ploty, left_fit, right_fit, warped_img.shape[1])\\n \\n # If the distance doesn't make sense, use sliding window to search again\\n if abs(distance) > self.tol_dist:\\n self.detected = False\\n return self.find_lane(warped_img)\\n else:\\n self.last_left_fit = left_fit\\n self.last_right_fit = right_fit\\n self.last_ploty = ploty\\n self.detected = True\\n return left_fitx, right_fitx, ploty, curvature, distance\\n except:\\n # Exception raised by fitpoly when left/right is empty\\n self.detected = False\\n return self.find_lane(warped_img)\",\n \"def le(self, x, y):\",\n \"def left_or_right(self):\\n #traversal\\n left_total = 0\\n left_count = 0\\n right_total = 0\\n right_count = 0\\n self.scan()\\n for ang, dist in self.scan_data.items():\\n if ang < self.MIDPOINT:\\n right_total += dist\\n right_count += 1\\n print(\\\"Angle: %d // dist: %d // right_count: %d\\\" % (ang, dist, right_count))\\n else:\\n left_total += dist\\n left_count += 1\\n left_avg = left_total / left_count\\n right_avg = right_total / right_count\\n if left_avg > right_avg:\\n self.turn_by_deg(-45)\\n else:\\n self.turn_by_deg(45)\\n # if robot is facing the wrong way it will turn it around\\n self.exit_bias()\",\n \"def lla(self):\\n return self._lla_shape\",\n \"def func_curvature(self):\\n return u.Curvature.CONVEX\",\n \"def laplacian(self, point):\\n n_vertices, n_faces = point.shape[-2], self.faces.shape[0]\\n vertex_0, vertex_1, vertex_2 = self._vertices(point)\\n len_edge_12 = gs.linalg.norm((vertex_1 - vertex_2), axis=-1)\\n len_edge_02 = gs.linalg.norm((vertex_0 - vertex_2), axis=-1)\\n len_edge_01 = gs.linalg.norm((vertex_0 - vertex_1), axis=-1)\\n\\n half_perimeter = 0.5 * (len_edge_12 + len_edge_02 + len_edge_01)\\n area = gs.sqrt(\\n (\\n half_perimeter\\n * (half_perimeter - len_edge_12)\\n * (half_perimeter - len_edge_02)\\n * (half_perimeter - len_edge_01)\\n ).clip(min=1e-6)\\n )\\n sq_len_edge_12, sq_len_edge_02, sq_len_edge_01 = (\\n len_edge_12 * len_edge_12,\\n len_edge_02 * len_edge_02,\\n len_edge_01 * len_edge_01,\\n )\\n cot_12 = (sq_len_edge_02 + sq_len_edge_01 - sq_len_edge_12) / area\\n cot_02 = (sq_len_edge_12 + sq_len_edge_01 - sq_len_edge_02) / area\\n cot_01 = (sq_len_edge_12 + sq_len_edge_02 - sq_len_edge_01) / area\\n cot = gs.stack([cot_12, cot_02, cot_01], axis=1)\\n cot /= 2.0\\n id_vertices_120 = self.faces[:, [1, 2, 0]]\\n id_vertices_201 = self.faces[:, [2, 0, 1]]\\n id_vertices = gs.reshape(\\n gs.stack([id_vertices_120, id_vertices_201], axis=0), (2, n_faces * 3)\\n )\\n\\n def _laplacian(tangent_vec):\\n \\\"\\\"\\\"Evaluate the mesh Laplacian operator.\\n\\n The operator is evaluated at a tangent vector at point to the\\n manifold of DiscreteSurfaces. In other words, the operator is\\n evaluated at a vector field defined on the surface point.\\n\\n Parameters\\n ----------\\n tangent_vec : array-like, shape=[..., n_vertices, 3]\\n Tangent vector to the manifold at the base point that is the\\n triangulated surface. This tangent vector is a vector field\\n on the triangulated surface.\\n\\n Returns\\n -------\\n laplacian_at_tangent_vec: array-like, shape=[..., n_vertices, 3]\\n Mesh Laplacian operator of the triangulated surface applied\\n to one its tangent vector tangent_vec.\\n \\\"\\\"\\\"\\n to_squeeze = False\\n if tangent_vec.ndim == 2:\\n tangent_vec = gs.expand_dims(tangent_vec, axis=0)\\n to_squeeze = True\\n n_tangent_vecs = len(tangent_vec)\\n tangent_vec_diff = (\\n tangent_vec[:, id_vertices[0]] - tangent_vec[:, id_vertices[1]]\\n )\\n values = gs.einsum(\\n \\\"bd,nbd->nbd\\\", gs.stack([gs.flatten(cot)] * 3, axis=1), tangent_vec_diff\\n )\\n\\n laplacian_at_tangent_vec = gs.zeros((n_tangent_vecs, n_vertices, 3))\\n\\n id_vertices_201_repeated = gs.tile(id_vertices[1, :], (n_tangent_vecs, 1))\\n\\n for i_dim in range(3):\\n laplacian_at_tangent_vec[:, :, i_dim] = gs.scatter_add(\\n input=laplacian_at_tangent_vec[:, :, i_dim],\\n dim=1,\\n index=id_vertices_201_repeated,\\n src=values[:, :, i_dim],\\n )\\n return (\\n gs.squeeze(laplacian_at_tangent_vec, axis=0)\\n if to_squeeze\\n else laplacian_at_tangent_vec\\n )\\n\\n return _laplacian\",\n \"def is_on(self, obj1_loc, obj1_dims, obj2_loc, obj2_dims):\\n VERT_MEASUREMENT_TOLERANCE = self.VERT_MEASUREMENT_TOLERANCE\\n result = None\\n obj1_x = obj1_loc[0]\\n obj1_y = obj1_loc[1]\\n obj1_zmin = obj1_loc[2] - (.5 * obj1_dims[2])\\n obj2_xmin, obj2_xmax, obj2_ymin, obj2_ymax, obj2_zmin, obj2_zmax = self.get_corners(obj2_loc, obj2_dims)\\n if obj1_x >= obj2_xmin and obj1_x <= obj2_xmax:\\n if obj1_y >= obj2_ymin and obj1_y <= obj2_ymax:\\n if obj1_zmin >= obj2_zmax-VERT_MEASUREMENT_TOLERANCE and obj1_zmin <= obj2_zmax+VERT_MEASUREMENT_TOLERANCE:\\n result = 'on'\\n return result\",\n \"def lombs(x, y):\\n # Calculate curvature. \\n curv = curvature(x, y)\\n steps = np.sqrt(np.diff(x, axis=0)**2 + np.diff(y, axis=0)**2)[:-1]\\n arc = np.cumsum(steps)\\n # Calculate LS.\\n ls_f, ls_p = LombScargle(arc, curv).autopower()\\n return ls_f, ls_p\",\n \"def curvature_and_position(ploty, left_fit, right_fit, img_w):\\n # Define y-value of interest\\n # We'll choose the maximum y-value, corresponding to the bottom of the image\\n y_eval = np.max(ploty)\\n\\n # Define some constants\\n ym_per_pix = 30/720 # meters per pixel in y dimension\\n xm_per_pix = 3.7/700 # meters per pixel in x dimension\\n \\n # Compute curvature\\n left_fit[0] = left_fit[0]*xm_per_pix/(ym_per_pix**2)\\n left_fit[1] = left_fit[1]*xm_per_pix/ym_per_pix\\n right_fit[0] = right_fit[0]*xm_per_pix/(ym_per_pix**2)\\n right_fit[1] = right_fit[1]*xm_per_pix/ym_per_pix\\n left_curverad = np.power(1+(2*left_fit[0]*y_eval+left_fit[1])**2, 3/2)/np.abs(2*left_fit[0])\\n right_curverad = np.power(1+(2*right_fit[0]*y_eval+right_fit[1])**2, 3/2)/np.abs(2*right_fit[0])\\n aver_curverad = 0.5*(left_curverad + right_curverad)\\n\\n # Compute the relative position\\n x_left = left_fit[0]*y_eval**2+left_fit[1]*y_eval+left_fit[2]\\n x_right = right_fit[0]*y_eval**2+right_fit[1]*y_eval+right_fit[2]\\n\\n car_pos = img_w // 2\\n center_line = (x_left + x_right) // 2\\n \\n distance = (car_pos - center_line)*xm_per_pix\\n \\n # Return the left/right curvature and the distance to the center line (right is positive)\\n return aver_curverad, distance\",\n \"def L(Rd: np.array, Re: np.array):\\n nd = Rd[:, 0]\\n sd = Rd[:, 1]\\n ad = Rd[:, 2]\\n\\n ne = Re[:, 0]\\n se = Re[:, 1]\\n ae = Re[:, 2]\\n\\n ll = -0.5 * (\\n np.dot(skew(nd), skew(ne))\\n + np.dot(skew(sd), skew(se))\\n + np.dot(skew(ad), skew(ae))\\n )\\n\\n llinv = np.linalg.pinv(ll)\\n\\n return ll, llinv\",\n \"def lorentz_func(x, center, width):\\n return 1/np.pi*width/2 *1/((x-center)**2+(x/width)**2)\",\n \"def _check_aliens_leftmost_edge(self):\\n screen_rect = self.screen.get_rect()\\n for alien in self.aliens.sprites():\\n if alien.rect.left <= screen_rect.left:\\n self._sideways_ship_hit()\\n break\",\n \"def _calibrate_landmarks(self, bboxes, landmarks, align=False):\\n\\n x1, y1, x2, y2 = [bboxes[:, i] for i in range(4)]\\n w = x2 - x1 + 1.0\\n h = y2 - y1 + 1.0\\n w = torch.unsqueeze(w, 1)\\n h = torch.unsqueeze(h, 1)\\n\\n translation = torch.cat([w]*5 + [h]* 5, 1).float() * landmarks\\n if align:\\n landmarks = torch.ceil(translation).int()\\n else:\\n landmarks = torch.stack([bboxes[:, 0]] * 5 + [bboxes[:, 1]] * 5, 1) + torch.round(translation).int()\\n return landmarks\",\n \"def checkPointInLampsReach(self, p):\\n v1 = XYPoint(self.Lime.x - self.Red.x, self.Lime.y - self.Red.y)\\n v2 = XYPoint(self.Blue.x - self.Red.x, self.Blue.y - self.Red.y)\\n\\n q = XYPoint(p.x - self.Red.x, p.y - self.Red.y)\\n s = self.crossProduct(q, v2) / self.crossProduct(v1, v2)\\n t = self.crossProduct(v1, q) / self.crossProduct(v1, v2)\\n\\n return (s >= 0.0) and (t >= 0.0) and (s + t <= 1.0)\",\n \"def rad_field_initial_condition(self):\\n\\n # revert in viewing direct\\n angle, _ = f.convert_direction(self.receiver_elevation, self.receiver_azimuth)\\n # Looking at the sky\\n if angle < 90:\\n I_init = (\\n self.sun_intensity\\n * f.delta_func(self.sun_elevation - self.receiver_elevation)\\n * f.delta_func(self.sun_azimuth - self.receiver_azimuth)\\n )\\n\\n # Looking at the ground\\n elif angle > 90:\\n I_ground = RT_model_1D.calc_direct_beam_intensity(self, 0)\\n\\n I_lambert = (\\n I_ground\\n * self.ground_albedo\\n * np.cos(np.deg2rad((self.sun_elevation + 180) % 360))\\n )\\n\\n I_specular = (\\n I_ground\\n * self.ground_albedo\\n * f.delta_func(self.sun_elevation + self.receiver_elevation - 180)\\n * f.delta_func(self.sun_azimuth - self.receiver_azimuth)\\n )\\n\\n I_init = (\\n 1 - self.reflection_type\\n ) * I_lambert + self.reflection_type * I_specular\\n\\n else:\\n I_init = np.empty(self.stokes_dim)\\n I_init.fill(np.nan)\\n\\n return I_init\",\n \"def find_lower_tangent(l_x_as, l_y_as, r_x_as, r_y_as, r_yp_as):\\n # logg = logging.getLogger(f\\\"c.{__name__}.find_lower_tangent\\\")\\n # logg.debug(f\\\"Start find_lower_tangent\\\")\\n\\n # compute the second derivative\\n r_ypp = r_yp_as[1:] - r_yp_as[:-1]\\n mean_r_ypp = np.mean(r_ypp)\\n\\n # logg.debug(f\\\"r_yp_as: {r_yp_as}\\\")\\n # logg.debug(f\\\"r_ypp: {r_ypp}\\\")\\n\\n if mean_r_ypp >= 0:\\n # logg.debug(f\\\"ypp positive\\\")\\n range_xid = range(r_x_as.shape[0])\\n else:\\n # logg.debug(f\\\"ypp negative\\\")\\n range_xid = range(r_x_as.shape[0])[::-1]\\n\\n tangent_start = timer()\\n for xid in range_xid:\\n # point tangent to the *right* segment\\n tang_op = OrientedPoint(r_x_as[xid], r_y_as[xid], slope2deg(r_yp_as[xid]))\\n tang_coeff = tang_op.to_ab_line()\\n\\n # sample it on the *left* segment sample\\n l_tang_y_as = poly_model(l_x_as, tang_coeff, flip_coeff=True)\\n # ax.plot(l_x_as, l_tang_y_as, color=\\\"b\\\", ls=\\\"-\\\", marker=\\\"\\\")\\n # ax.plot(l_x_as, l_tang_y_as, color=\\\"b\\\", ls=\\\"\\\", marker=\\\".\\\")\\n\\n # find if the left segment has some points lower than the tangent\\n lower = l_y_as < l_tang_y_as\\n # logg.debug(f\\\"lower: {lower} {np.sum(lower)}\\\")\\n if np.sum(lower) == 0:\\n # logg.debug(f\\\"Breaking at xid: {xid}\\\")\\n break\\n\\n tangent_end = timer()\\n tangent_time = tangent_end - tangent_start\\n # logg.debug(f\\\"Time to find tangent: {tangent_end - tangent_start:.6f}\\\")\\n\\n # find distance from left segment to tangent\\n dist_left_tangent = l_y_as - l_tang_y_as\\n min_dist_left_tangent = np.min(dist_left_tangent)\\n argmin_dist_left_tangent = np.argmin(dist_left_tangent)\\n recap = f\\\"min_dist_left_tangent: {min_dist_left_tangent:.6f}\\\"\\n recap += \\\" argmin_dist_left_tangent: {argmin_dist_left_tangent}\\\"\\n # logg.debug(recap)\\n\\n if min_dist_left_tangent < 0:\\n # logg.debug(f\\\"Tangent not found\\\")\\n return -1, -1, None, tangent_time\\n\\n l_xid = argmin_dist_left_tangent\\n r_xid = xid\\n\\n return l_xid, r_xid, l_tang_y_as, tangent_time\",\n \"def findslopes(img):\\n img = img.astype(np.float32)\\n DY = np.array([[-1,-1,-1],[0, 0, 0],[1, 1, 1]]) * 1/6\\n DX = DY.transpose()\\n gradx = cv2.filter2D(src=img, ddepth=-1, kernel=DX)\\n grady = cv2.filter2D(src=img, ddepth=-1, kernel=DY)\\n\\n D2Y = np.array([[0.5, 1, 0.5], [-1, -2, -1], [0.5, 1, 0.5]]) * 0.5\\n D2X = D2Y.transpose()\\n DXY = np.array([[-1, 0, 1], [0, 0, 0], [1, 0, -1]]) * 1/4\\n grad2x = cv2.filter2D(src=img, ddepth=-1, kernel=D2X)\\n grad2y = cv2.filter2D(src=img, ddepth=-1, kernel=D2Y)\\n gradxy = cv2.filter2D(src=img, ddepth=-1, kernel=DXY)\\n\\n slopes = gradx**2 + grady**2\\n slopes2 = grad2x**2 + grad2y**2 + 2 * gradxy**2\\n\\n return (slopes, gradx, grady, slopes2, grad2x, grad2y, gradxy)\",\n \"def getNewVal(on, val, pos, corners):\\n\\n (x, y) = pos\\n\\n # corner lights are always on\\n if (x, y) in corners:\\n return 1\\n\\n if val == 0:\\n if on == 3:\\n return 1\\n\\n elif val == 1:\\n if not (on == 2 or on == 3):\\n return 0\\n\\n return val\",\n \"def has_compatible_ligands(self, identity):\\n return ((len(self.bad_coords[identity]) == 0) and\\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))\",\n \"def reset_boundaries(self):\\n self.L = - np.random.uniform(0.0,1.0)\\n self.R = self.L + 1.0\\n self.Ne = 0.0\\n self.Nc = 0.0\",\n \"def get_laser_points_in_region(\\r\\n self, image: np.ndarray, region: Rectangle, is_obj: bool = False,\\r\\n ) -> Optional[np.ndarray]:\\r\\n top_left = region.top_left\\r\\n bottom_right = region.bottom_right\\r\\n region_image = image[top_left.y : bottom_right.y, top_left.x : bottom_right.x]\\r\\n image_inv = cv.cvtColor(~region_image, cv.COLOR_BGR2HSV)\\r\\n lower_red = self.lower_red_obj if is_obj else self.lower_red_planes\\r\\n red_mask = cv.inRange(image_inv, lower_red, self.upper_red)\\r\\n laser_points = cv.findNonZero(red_mask)\\r\\n if laser_points is None or (not is_obj and len(laser_points) < 30):\\r\\n return None\\r\\n return laser_points\",\n \"def find_current_points(grad_mag, x_mean_scaled, normals_length, display_normals = False, img = None):\\n if img is None:\\n img = grad_mag\\n\\n # Norm Calculation\\n normals = np.zeros((no_points, 2))\\n for i in range(0, no_points):\\n # the first and the last points vectors should\\n # be calculated using one neighbor\\n if i == 0:\\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i]\\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i + no_points]\\n elif i == no_points - 1:\\n ux = x_mean_scaled[i] - x_mean_scaled[i - 1]\\n uy = x_mean_scaled[i + no_points] - x_mean_scaled[i + no_points - 1]\\n else:\\n # points that have two neighbors\\n ux = x_mean_scaled[i + 1] - x_mean_scaled[i - 1]\\n uy = x_mean_scaled[i + 1 + no_points] - x_mean_scaled[i - 1 + no_points]\\n # nx, ny for each point\\n normals[i, 0] = -uy / sqrt(ux * ux + uy * uy)\\n normals[i, 1] = ux / sqrt(ux * ux + uy * uy)\\n\\n # PLOT normals\\n if display_normals:\\n display_normals(normals, x_mean_scaled, img, normals_length)\\n\\n # finding correct positions on the model, Y\\n Y = np.zeros(x_mean_scaled.shape)\\n\\n for i in range(0, no_points):\\n # landmark point coordinates\\n px = float(x_mean_scaled[i])\\n py = float(x_mean_scaled[i + no_points])\\n nx, ny = normals[i, :]\\n max_y, max_x = grad_mag.shape\\n check_pixels = []\\n for t in range(-normals_length, +normals_length):\\n lx = px + t * nx\\n ly = py + t * ny\\n # check boundaries\\n if lx >= max_x:\\n lx = max_x - 1\\n elif lx < 0:\\n lx = 0\\n\\n if ly >= max_y:\\n ly = max_y - 1\\n elif ly < 0:\\n ly = 0\\n\\n check_pixels.append((lx, ly))\\n\\n check_pixels = np.array(check_pixels, dtype=int)\\n\\n grad_values = grad_mag[check_pixels[:, 1], check_pixels[:, 0]]\\n mag_argmax = np.argmax(grad_values)\\n Y[i] = check_pixels[mag_argmax, 0]\\n Y[i + no_points] = check_pixels[mag_argmax, 1]\\n\\n return Y\",\n \"def is_valid(self):\\n if len(self.exterior) < 3:\\n return False\\n return self.to_shapely_polygon().is_valid\",\n \"def checkDiagonals( self ):\\n\\n centerVal = self.__grid[4]\\n\\n diag1 = str(centerVal).lower() + str(self.__grid[0]).lower() \\\\\\n + str(self.__grid[8]).lower()\\n diag2 = str(centerVal).lower() + str(self.__grid[2]).lower() \\\\\\n + str(self.__grid[6]).lower()\\n\\n if isinstance(centerVal, int):\\n return None\\n\\n elif 'xx' in diag1: \\n return ('X', diag1)\\n\\n elif 'xx' in diag2:\\n return ('X', diag2)\\n\\n elif 'oo' in diag1:\\n return ('O', diag1)\\n\\n elif 'oo' in diag2:\\n return ('O', diag2)\\n\\n else:\\n return None\",\n \"def checkEdges( self ):\\n\\t\\tx, y = self.position.xy\\n\\t\\tvx, vy = self.velocity.xy\\n\\t\\t\\n\\t\\t#if particle hit left or right wall\\n\\t\\tif abs( x ) > WINDOW_X - self.r:\\n\\t\\t\\t#change vertical speed\\n\\t\\t\\tvx *= -1\\n\\t\\t\\t\\n\\t\\t#if particle hit top or bottom wall\\n\\t\\tif abs( y ) > WINDOW_Y - self.r:\\n\\t\\t\\t#change horizontal speed\\n\\t\\t\\tvy *= -1\\n\\t\\t\\n\\t\\t#enter new velocity\\n\\t\\tself.velocity.xy = (vx, vy)\",\n \"def fun(x0, x1, y0, y1, xx, yy): \\n\\n # Look for point of intersection between interpolated curve between nodes in x, y\\n # and the normal to the face between nodes (x0, y0) and (x1, y1)\\n # Transform coordinate axes\\n # Center of face is xs, ys\\n xs = (x0 + x1)/2.\\n ys = (y0 + y1)/2.\\n\\n if abs(y1 - y0) > abs(x1 - x0):\\n theta = arctan((x1 - x0)/(y1 - y0))\\n theta2 = arctan((xx - xs)/(yy - ys))\\n dy = (yy - ys)/cos(theta2)\\n xn = copy(xx)\\n yn = copy(yy)\\n xn = dy*sin(theta2 - theta)\\n yn = dy*cos(theta2 - theta)\\n w = barycentric_weight(yn)\\n y2 = - yn\\n f = zeros(len(y2), float)\\n ss = sum(w/y2)\\n f[:] = w/y2/ss\\n dy = dot(f, xn)\\n xny = xs + dy*sin(theta + pi/2.)\\n yny = ys + dy*cos(theta + pi/2.)\\n\\n else: \\n theta = arctan((y1 - y0)/(x1 - x0))\\n theta2 = arctan((yy - ys)/(xx - xs))\\n dx = (xx - xs)/cos(theta)\\n xn = copy(xx)\\n yn = copy(yy)\\n xn = dx*cos(theta2 - theta)\\n yn = dx*sin(theta2 - theta)\\n w = barycentric_weight(xn)\\n x2 = - xn\\n f = zeros(len(x2), float)\\n ss = sum(w/x2)\\n f[:] = w/x2/ss\\n dy = dot(f, yn)\\n xny = xs + dy*cos(theta + pi/2.)\\n yny = ys + dy*sin(theta + pi/2.)\\n \\n return xny, yny\",\n \"def PointIsLeft(vi, vf, point):\\n DetPIL = (point[0] - vi[0])*(vf[1] - vi[1]) - (point[1] - vi[1])*(vf[0] - vi[0])\\n if DetPIL < 0 :\\n return True\\n elif DetPIL > 0 :\\n return False\\n else :\\n return None\",\n \"def boundaries_prev(*args):\\n return _ida_hexrays.boundaries_prev(*args)\",\n \"def calc_curvature(self, windows: List[Window]):\\n x, y = zip(*[window.pos_xy() for window in windows])\\n x = np.array(x)\\n y = np.array(y)\\n fit_cr = np.polyfit(y * camera.y_m_per_pix, x * camera.x_m_per_pix, 2)\\n y_eval = np.max(y)\\n return ((1 + (2 * fit_cr[0] * y_eval * camera.y_m_per_pix + fit_cr[1]) ** 2) ** 1.5) / np.absolute(\\n 2 * fit_cr[0])\",\n \"def _add_boundaries(self):\\n logger.info(\\\"add_boundaries: start of method\\\")\\n\\n import scipy.spatial as sptl\\n import scipy.sparse as sprs\\n Lx = self._Lx\\n Ly = self._Ly\\n Lz = self._Lz\\n Np = self.num_pores()\\n btype = self._btype\\n boffset = 0.05\\n\\n #Translate internal pores to each face of domain\\n poffset = np.zeros((7,3))\\n poffset[[2,5],0] = [-Lx, Lx]\\n poffset[[3,4],1] = [-Ly, Ly]\\n poffset[[1,6],2] = [-Lz, Lz]\\n pcoords = pcoords0 = self['pore.coords']\\n for i in np.r_[1:7]:\\n pcoords = np.concatenate((pcoords,pcoords0 + poffset[i,:]),axis=0)\\n\\n #Use some twisted logic to get bval list of + for boundary and - for periodic faces\\n bval = [0, 1, 2, 3, 4, 5, 6]*(np.array([0, btype[2], btype[0], btype[1], btype[1], btype[0], btype[2]])*-2+1)\\n ptype = np.zeros((Np,),dtype=int)\\n for i in np.r_[1:7]:\\n ptype = np.concatenate((ptype,np.ones((Np,),dtype=int)*bval[i]),axis=0)\\n\\n #pnum contains the internal ID number of the boundary pores (for connecting periodic points)\\n pnum = self.pores()\\n pnum = np.tile(pnum,7)\\n\\n Tri = sptl.Delaunay(pcoords)\\n adjmat = sprs.lil_matrix((np.shape(pcoords)[0],np.shape(pcoords)[0]),dtype=int)\\n for i in np.arange(0,np.shape(Tri.simplices)[0]):\\n #Keep only simplices that are fully in real domain\\n adjmat[Tri.simplices[i],Tri.simplices[i]] = 1\\n adjmat = sprs.triu(adjmat,k=1,format=\\\"lil\\\")\\n for i in np.arange(0,Np):\\n #Add periodic throats to the netowrk (if any)\\n tpore2 = pnum[adjmat.rows[i]][ptype[adjmat.rows[i]]<0]\\n tpore1 = np.ones_like(tpore2,dtype=int)*i\\n conns = self['throat.conns']\\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\\n #Add boundary pores and throats to the network\\n newporetyps = np.unique(ptype[adjmat.rows[i]][ptype[adjmat.rows[i]]>0])\\n newporenums = np.r_[self.num_pores():self.num_pores()+np.size(newporetyps)]\\n tpore2 = newporenums\\n tpore1 = np.ones_like(tpore2,dtype=int)*i\\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\\n self['throat.conns'] = conns\\n bcoords = np.zeros((7,3),dtype=float)\\n coords = self['pore.coords']\\n bcoords[1,:] = [coords[i,0], coords[i,1], 0-Lz*boffset]\\n bcoords[2,:] = [0-Lx*boffset, coords[i,1], coords[i,2]]\\n bcoords[3,:] = [coords[i,0], -Ly*boffset, coords[i,2]]\\n bcoords[4,:] = [coords[i,0], Ly+Ly*boffset, coords[i,2]]\\n bcoords[5,:] = [Lx+Lx*boffset, coords[i,1], coords[i,2]]\\n bcoords[6,:] = [coords[i,0], coords[i,1], Lz+Lz*boffset]\\n newporecoords = bcoords[newporetyps,:]\\n coords = np.concatenate((coords,newporecoords),axis=0)\\n self['pore.coords'] = coords\\n #Reset number of pores and throats (easier than tracking it)\\n nums = np.r_[0:np.shape(coords)[0]]\\n self['pore.numbering'] = nums\\n self['pore.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\\n nums = np.r_[0:np.shape(conns)[0]]\\n self['throat.numbering'] = nums\\n self['throat.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\\n logger.debug(\\\"add_boundaries: end of method\\\")\",\n \"def is_left(self):\\n if self.pupils_located:\\n return self.horizontal_ratio() >= 0.65\",\n \"def is_center(self):\\n if self.pupils_located:\\n return self.is_right() is not True and self.is_left() is not True\",\n \"def calculate_celestial_pole(native_reference_x, native_reference_cos_lat,\\n native_reference_sin_lat,\\n reference_x, reference_y,\\n reference_cos_lat, reference_sin_lat,\\n native_pole_x, native_pole_y,\\n select_solution): # pragma: no cover\\n right_angle = np.pi / 2\\n d_phi = native_pole_x - native_reference_x\\n sin_d_phi = np.sin(d_phi)\\n cos_d_phi = np.cos(d_phi)\\n delta_p1 = np.arctan2(\\n native_reference_sin_lat, native_reference_cos_lat * cos_d_phi)\\n cs = native_reference_cos_lat * sin_d_phi\\n\\n delta_p2 = acos(reference_sin_lat / np.sqrt(1 - (cs ** 2)))\\n celestial_y = 0.0\\n\\n delta_n = delta_p1 + delta_p2\\n delta_s = delta_p1 - delta_p2\\n if delta_n > delta_s:\\n temp = delta_s\\n delta_s = delta_n\\n delta_n = temp\\n\\n solutions = 0\\n if np.abs(delta_n) <= right_angle:\\n celestial_y = delta_n\\n solutions += 1\\n\\n if np.abs(delta_s) <= right_angle:\\n solutions += 1\\n if solutions == 1:\\n celestial_y = delta_s\\n elif select_solution == -1:\\n celestial_y = delta_s\\n elif select_solution == 0:\\n if np.abs(delta_s - native_pole_y) < np.abs(\\n delta_n - native_pole_y):\\n celestial_y = delta_s\\n\\n if solutions == 0: # pragma: no cover (shouldn't happen)\\n return np.nan, np.nan\\n\\n if equal_angles(np.abs(reference_y), right_angle):\\n celestial_x = reference_x\\n elif equal_angles(np.abs(celestial_y), right_angle):\\n celestial_x = reference_x\\n if celestial_y > 0:\\n celestial_x += native_pole_x - native_reference_x - np.pi\\n else:\\n celestial_x += native_reference_x - native_pole_x\\n else:\\n cl = np.cos(celestial_y)\\n sl = np.sin(celestial_y)\\n\\n sin_d_lon = sin_d_phi * native_reference_cos_lat / reference_cos_lat\\n cos_d_lon = native_reference_sin_lat - (sl * reference_sin_lat)\\n cos_d_lon /= cl * reference_cos_lat\\n celestial_x = reference_x - np.arctan2(sin_d_lon, cos_d_lon)\\n\\n return celestial_x, celestial_y\",\n \"def isCollinear(a,b,c):\\r\\n #return slope(a, b) == slope(b, c) == slope(c, a) #DOES NOT WORK\\r\\n #return (b[0] - a[0]) * (c[1] - a[1]) == (c[0] - a[0]) * (b[1] - a[1]) \\r\\n #return distance(a,b) + distance(b,c) == distance(a,c)\\r\\n x1 = a[0]\\r\\n y1 = a[1]\\r\\n x2 = b[0]\\r\\n y2 = b[1]\\r\\n x3 = c[0]\\r\\n y3 = c[1] \\r\\n if (x1*(y2 - y3)) + (x2*(y3 - y1)) + (x3*(y1-y2)) == 0: \\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def test_lineclip():\\n # %% LOWER to UPPER test\\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\\n 0, 0, 4, 6)\\n\\n assert [x1, y1, x2, y2] == approx([2, 3, 3.3333333333333, 5])\\n # %% no intersection test\\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\\n 0, 0.1, 0, 0.1)\\n\\n assert x1 is None and y1 is None and x2 is None and y2 is None\\n # %% left to right test\\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\\n 0, 4, 5, 4)\\n\\n assert [x1, y1, x2, y2] == [1, 4, 4, 4]\",\n \"def walled_in(x: int, y: int) -> bool:\\r\\n threshold = 2\\r\\n level = 0\\r\\n if wall_check(x, y, True):\\r\\n threshold = 1\\r\\n if not wall_check(x-1, y+1, False):\\r\\n if example[x-1, y+1] == 0:\\r\\n if mark_traveller(x-1, y+1, \\\"SW\\\"):\\r\\n level += 1\\r\\n if level >= threshold:\\r\\n return True\\r\\n if not wall_check(x - 1, y - 1, False):\\r\\n if example[x - 1, y - 1] == 0:\\r\\n if mark_traveller(x - 1, y - 1, \\\"SE\\\"):\\r\\n level += 1\\r\\n if level >= threshold:\\r\\n return True\\r\\n if not wall_check(x + 1, y - 1, False):\\r\\n if example[x + 1, y - 1] == 0:\\r\\n if mark_traveller(x + 1, y - 1, \\\"NE\\\"):\\r\\n level += 1\\r\\n if level >= threshold:\\r\\n return True\\r\\n if not wall_check(x + 1, y + 1, False):\\r\\n if example[x + 1, y + 1] == 0:\\r\\n if mark_traveller(x + 1, y + 1, \\\"NW\\\"):\\r\\n level += 1\\r\\n if level >= threshold:\\r\\n return True\\r\\n return False\",\n \"def state(self):\\r\\n\\r\\n #Mark in wich direction is the prey\\r\\n prescence_prey_right = 1 if (self.prey.position[0] > self.body[0].position[0]) else 0\\r\\n prescence_prey_left = 1 if (self.prey.position[0] < self.body[0].position[0]) else 0\\r\\n prescence_prey_up = 1 if (self.prey.position[1] < self.body[0].position[1]) else 0\\r\\n prescence_prey_down = 1 if (self.prey.position[1] > self.body[0].position[1]) else 0\\r\\n #Direction where is moving\\r\\n actual_direction_right = 1 if (self.velocities[0] == 1) else 0\\r\\n actual_direction_left = 1 if (self.velocities[0] == -1) else 0\\r\\n actual_direction_up = 1 if (self.velocities[1] == -1) else 0\\r\\n actual_direction_down = 1 if (self.velocities[1] == 1) else 0\\r\\n #Mark if is an obstacle\\r\\n obstacles = np.ravel(self.obstacles())\\r\\n \\r\\n return (np.concatenate((\\r\\n [prescence_prey_right,\\r\\n prescence_prey_left,\\r\\n prescence_prey_up,\\r\\n prescence_prey_down,\\r\\n actual_direction_right,\\r\\n actual_direction_left,\\r\\n actual_direction_up,\\r\\n actual_direction_down],\\r\\n obstacles\\r\\n )))\",\n \"def test_init_attr(self):\\n \\n for k in (0, -1, 1):\\n s = space(curvature=k)\\n self.assertTrue(isclose(\\n s.curvature,\\n k\\n ))\\n \\n for k in (1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\\n s = space(curvature=k)\\n self.assertTrue(s.curvature == k)\\n\\n for fk in (0, -1, 1, 1.75, 0.325, 1/7, -1.75, -0.325, -1/7):\\n s = space(fake_curvature=fk)\\n self.assertTrue(isclose(\\n s.curvature,\\n fk * abs(fk)\\n ))\\n\\n for r in (1, 2, 1j, 2j, float('inf')):\\n s = space(radius=r)\\n self.assertTrue(s.curvature == 1/r**2)\",\n \"def compute_refl(self, step, borders,obstacle):\\n\\n r = self.radius\\n v = self.velocity\\n x = self.position\\n projx = step*abs(np.dot(v,np.array([1.,0.])))\\n projy = step*abs(np.dot(v,np.array([0.,1.])))\\n\\n a = pygame.Rect(0,0,borders[3][0],borders[3][0])\\n b = pygame.Rect(0,borders[0][1]+borders[0][3],borders[3][0],borders[3][1]+borders[3][3])\\n c = pygame.Rect(borders[2][0]+borders[2][2],0,borders[3][0],borders[3][0])\\n d = pygame.Rect(borders[3][0]+borders[3][2],borders[1][1]+borders[1][3],borders[3][0],borders[3][0])\\n\\n if(a.collidepoint(*self.position) or b.collidepoint(*self.position) or c.collidepoint(*self.position) or d.collidepoint(*self.position)):\\n self.vafter *= 0\\n self.delete = True\\n\\n\\n\\n\\n else:\\n if (abs(x[0])-r -borders[0][0]-borders[0][2] < projx ) or (abs(borders[1][0]- x[0])-r < projx):\\n self.vafter[0] *= -1\\n\\n if abs(x[1])-r -(borders[2][1]+borders[2][3]) < projy or abs(borders[3][1]-x[1])-r < projy:\\n self.vafter[1] *= -1.\\n\\n if obstacle != None:\\n obs = pygame.Rect(*obstacle)\\n if obs.collidepoint(x[0] + r,x[1]):\\n self.vafter[0] = -20\\n if obs.collidepoint(x[0] - r,x[1]):\\n self.vafter[0] = 20\\n if obs.collidepoint(x[0],x[1]- r):\\n self.vafter[1] = 20\\n if obs.collidepoint(x[0], x[1]+ r):\\n self.vafter[1] = -20\",\n \"def shield_left(nodeL, new_city, points, angle0=-1):\\n item1 = get_node_points(nodeL)\\n item2 = get_city_points(new_city)\\n\\n a = distance_between_points(item1, points)\\n b = distance_between_points(points, item2)\\n c = dic_list[nodeL.value - 1].get(nodeL.value).get(new_city)\\n\\n if (b == 0) | (check_point_left(nodeL, nodeL.right, new_city) == True):\\n return nodeL\\n angle1 = angle(a, b, c)\\n\\n if (angle1 < angle0) & (check_points(item2, item1, points, get_node_points(nodeL.right)) == False):\\n return nodeL.right\\n else:\\n nodeL = nodeL.left\\n same_side = check_points(item1, get_node_points(nodeL.right), points, item2)\\n if same_side == True:\\n return shield_left(nodeL, new_city, points, angle1)\\n else:\\n return nodeL.right\",\n \"def in_ellipse(x,y,a,b):\\n return ellipse(x,y,a,b) <= 1\",\n \"def check_limits(self):\\n\\n #Find the relative position of each leg vs. its \\\"zero\\\" position\\n relpos = self.fixed_plate - self.fixed_plate_zero\\n\\n for leg in range(3):\\n #Check that the leg is within allowable \\\"safe zone\\\"\\n #Use the position of the leg (relative to 0) to find the index in the \\\"safe zone\\\" matrix\\n i_x = nearest_index(self.leg_safe_xaxis, relpos[COORD_X, leg])\\n i_z = nearest_index(self.leg_safe_zaxis, relpos[COORD_Z, leg])\\n #Look up in the safe zone.\\n self.leg_fault[leg] = (not self.leg_safe_zone[leg, i_x, i_z])\\n\\n if (not all(np.isreal(self.fixed_plate[:, leg]))) or any(np.isnan(self.fixed_plate[:, leg])):\\n #A complex or NaN value = the angle found for the leg was invalid, meaning that the\\n #leg would have to be longer to reach the desired position.\\n self.leg_fault[leg] = True\",\n \"def calc_separation_alt_az(self, body):\\n self.body.compute(self.site)\\n body.body.compute(self.site)\\n\\n delta_az = float(self.body.az) - float(target.az)\\n delta_alt = float(self.body.alt) - float(target.alt)\\n return (delta_alt, delta_az)\",\n \"def check_right(nodeL, nodeR, city):\\n A = get_node_points(nodeL)\\n B = get_node_points(nodeR)\\n C = get_city_points(city)\\n slope = _slope(A, B)\\n (F, G) = calibrator(A, B, slope)\\n sign = math.copysign(1, ((G[0] - F[0]) * (C[1] - F[1]) - (G[1] - F[1]) * (C[0] - F[0])))\\n\\n if slope == \\\"horizontal\\\":\\n if sign == -1:\\n if A[0] > B[0]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\\n else:\\n if A[0] < B[0]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\\n\\n if slope == \\\"vertical\\\":\\n if sign == -1:\\n if A[1] < B[1]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\\n else:\\n if A[1] > B[1]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\\n\\n if slope == \\\"inclined\\\":\\n if sign == -1:\\n if A[1] < B[1]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\\n else:\\n if A[1] > B[1]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\\n\\n if slope == \\\"declined\\\":\\n if sign == -1:\\n if A[1] < B[1]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\\n else:\\n if A[1] > B[1]:\\n return (nodeR, nodeL)\\n else:\\n return (nodeL, nodeR)\",\n \"def corners(self):\\n try:\\n # Try to just set normal CoordinateDefinition corners\\n # (Which doesn't work with bad vals in corners)\\n return super(CoordinateDefinition, self).corners\\n except ValueError:\\n #print ' Corners failed on CoordinateDefinition, try falsecorners'\\n pass\\n\\n lons, lats = self.get_lonlats()\\n\\n #Determine which rows and columns contain good data\\n rows = lons.any(axis=1)\\n cols = lons.any(axis=0)\\n\\n #Get the minimum and maximum row and column that contain good data\\n good_row_inds = np.where(~rows.mask)[0]\\n min_row = good_row_inds.min()\\n max_row = good_row_inds.max()\\n\\n good_col_inds = np.where(~cols.mask)[0]\\n min_col = good_col_inds.min()\\n max_col = good_col_inds.max()\\n\\n log.info(' USING FALSE CORNERS!! setting corners. min row/col: '+\\\\\\n str(min_row)+' '+str(min_col)+' '+\\\\\\n 'max row/col: '+str(max_row)+' '+str(max_col)+' '+\\\\\\n 'shape: '+str(lons.shape))\\n\\n\\n #from .spherical import SCoordinate as Coordinate\\n #from .spherical import Arc\\n from pyresample.spherical_geometry import Coordinate, Arc\\n #Calculate the eight possible corners and produce arcs for each pair\\n #Corners for top side\\n # Right side was failing with Divide by Zero error for NCC data because there was \\n # a single good point in the max_col. Keep incrementing or decrementing until good.min \\n # doesn't equal good.max \\n good = np.where(~lons[min_row,:].mask)[0]\\n tries = 0\\n while (tries < 20 and good.min() == good.max()):\\n #print 'good.min() can\\\\'t equal good.max() for top side, incrementing min_row! Would have failed with ZeroDivisionError before!'\\n min_row += 1\\n tries += 1\\n good = np.where(~lons[min_row,:].mask)[0]\\n top_corners = [Coordinate(*self.get_lonlat(min_row, good.min())),\\n Coordinate(*self.get_lonlat(min_row, good.max()))]\\n top_arc = Arc(top_corners[0], top_corners[1])\\n\\n #Corners for bottom side\\n good = np.where(~lons[max_row,:].mask)[0]\\n tries = 0\\n while (tries < 20 and good.min() == good.max()):\\n #print 'good.min() can\\\\'t equal good.max() for bottom side, decrementing max_row! Would have failed with ZeroDivisionError before!'\\n max_row -= 1\\n tries += 1\\n good = np.where(~lons[max_row,:].mask)[0]\\n bot_corners = [Coordinate(*self.get_lonlat(max_row, good.min())),\\n Coordinate(*self.get_lonlat(max_row, good.max()))]\\n bot_arc = Arc(bot_corners[0], bot_corners[1])\\n\\n #Corners for left side\\n good = np.where(~lons[:,min_col].mask)[0]\\n tries = 0\\n while (tries < 20 and good.min() == good.max()):\\n #print 'good.min() can\\\\'t equal good.max() for left side, incrementing min_col! Would have failed with ZeroDivisionError before!'\\n min_col += 1\\n tries += 1\\n good = np.where(~lons[:,min_col].mask)[0]\\n left_corners = [Coordinate(*self.get_lonlat(good.min(),min_col)),\\n Coordinate(*self.get_lonlat(good.max(),min_col))]\\n left_arc = Arc(left_corners[0], left_corners[1])\\n\\n #Corners for right side\\n good = np.where(~lons[:,max_col].mask)[0]\\n tries = 0\\n while (tries < 20 and good.min() == good.max()):\\n #print 'good.min() can\\\\'t equal good.max() for right side, decrementing max_col! Would have failed with ZeroDivisionError before!'\\n max_col -= 1\\n tries += 1\\n good = np.where(~lons[:,max_col].mask)[0]\\n right_corners = [Coordinate(*self.get_lonlat(good.min(),max_col)),\\n Coordinate(*self.get_lonlat(good.max(),max_col))]\\n right_arc = Arc(right_corners[0], right_corners[1])\\n\\n #Calculate the four false corners\\n _corners = []\\n #Top left false corner\\n top_intersections = top_arc.intersections(left_arc)\\n dists = [inter.distance(top_corners[0]) for inter in top_intersections]\\n if dists[0] < dists[1]:\\n _corners.append(top_intersections[0])\\n else:\\n _corners.append(top_intersections[1])\\n #Top right false corner\\n top_intersections = top_arc.intersections(right_arc)\\n dists = [inter.distance(top_corners[1]) for inter in top_intersections]\\n if dists[0] < dists[1]:\\n _corners.append(top_intersections[0])\\n else:\\n _corners.append(top_intersections[1])\\n #Bottom right false corner\\n bot_intersections = bot_arc.intersections(right_arc)\\n dists = [inter.distance(bot_corners[1]) for inter in bot_intersections]\\n if dists[0] < dists[1]:\\n _corners.append(bot_intersections[0])\\n else:\\n _corners.append(bot_intersections[1])\\n #Bottom left false corner\\n bot_intersections = bot_arc.intersections(left_arc)\\n dists = [inter.distance(bot_corners[0]) for inter in bot_intersections]\\n if dists[0] < dists[1]:\\n _corners.append(bot_intersections[0])\\n else:\\n _corners.append(bot_intersections[1])\\n return _corners\",\n \"def can_left_arc(c, correct_arcs):\\n try:\\n return Arc(c.buffer[0], c.sentence[c.stack[-1]].deprel, c.stack[-1]) in correct_arcs\\n except IndexError:\\n return False\",\n \"def compute_corners(landmarks, mode):\\n right_to_left_eye = landmarks[:, :2] - landmarks[:, 2:4]\\n middle_eye = (landmarks[:, :2] + landmarks[:, 2:4]) / 2\\n eye_to_mouth = landmarks[:, 4:6] - middle_eye\\n centers = middle_eye\\n\\n if np.linalg.norm(right_to_left_eye) > np.linalg.norm(eye_to_mouth):\\n vec_right = right_to_left_eye\\n vec_down = np.fliplr(vec_right).copy()\\n vec_down[:, 0] *= -1.\\n else:\\n vec_down = eye_to_mouth\\n vec_right = np.fliplr(vec_down).copy()\\n vec_right[:, 1] *= -1.\\n\\n if mode == 'face':\\n scale = 1.8\\n elif mode == 'eyes':\\n vec_down *= 0.33\\n scale = 1.\\n else:\\n raise NotImplementedError()\\n\\n diag = scale * (vec_right + vec_down)\\n top_left = centers - diag\\n top_right = top_left + 2 * scale * vec_right\\n bottom_left = top_left + 2 * scale * vec_down\\n bottom_right = centers + diag\\n\\n return top_left, top_right, bottom_left, bottom_right\",\n \"def linearize_pose_landmark_constraint(x, l, z):\\n print(\\\"you shouldn't be here....\\\")\\n e = np.zeros([2, 1])\\n A = np.zeros([2, 3])\\n B = np.zeros([2, 2])\\n\\n Ri = v2t(x)[0:2, 0:2]\\n ti = x[0:2]\\n\\n fi = x[2]\\n c = np.cos(fi)\\n s = np.sin(fi)\\n dR_dteta = np.array([[-s, c], [-c, -s]])\\n\\n e = Ri.transpose() @ (l - x[0:2]) - z\\n\\n B = Ri.transpose()\\n\\n A[0:2, 0:2] = -Ri.transpose()\\n A[0:2, 2] = dR_dteta @ (l - ti)\\n\\n return e, A, B\",\n \"def circle_leads(center_theta, width_theta, radius):\\n\\ta1 = np.deg2rad(center_theta + width_theta/2)\\n\\ta2 = np.deg2rad(center_theta - width_theta/2)\\n\\tpoint_max = radius * np.array([np.cos(a1), np.sin(a1)])\\n\\tpoint_min = radius * np.array([np.cos(a2), np.sin(a2)])\\n\\treturn (point_max, point_min)\",\n \"def check_offset(self):\\n\\n for d in range(self.n_dmps):\\n if abs(self.y0[d] - self.goal[d]) < 1e-4:\\n self.goal[d] += 1e-4\",\n \"def test_coord_preceding_fs(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63404727","0.6133634","0.6060749","0.58401936","0.56271565","0.5616536","0.5516699","0.5483635","0.54565936","0.5450176","0.5428849","0.54229635","0.540363","0.54026043","0.53971386","0.5384905","0.53581065","0.5353302","0.53430974","0.5340143","0.532937","0.53236294","0.53084755","0.5306773","0.5305699","0.5302767","0.5294419","0.5294159","0.5280441","0.52649295","0.52228427","0.5221271","0.52114123","0.52072346","0.5203848","0.5192218","0.5191798","0.51893264","0.5185908","0.5181402","0.51809573","0.51733744","0.5170192","0.5167249","0.5161559","0.51574504","0.5156294","0.5151575","0.5147884","0.51394755","0.5136762","0.5132807","0.512113","0.51199216","0.5117852","0.5116792","0.5116205","0.51121515","0.5107979","0.5105224","0.5103945","0.5103181","0.50994635","0.50952107","0.50860626","0.5078496","0.50773424","0.5069469","0.50607413","0.50587785","0.5054682","0.5050547","0.5050532","0.50471073","0.50459796","0.50450647","0.5038109","0.5037803","0.50335366","0.502863","0.5028471","0.50261515","0.5021058","0.5020808","0.50154614","0.50142336","0.5012762","0.5011661","0.5001392","0.49986026","0.49955955","0.499461","0.49916673","0.4989332","0.49882886","0.49867004","0.4985717","0.49846116","0.4981638","0.49784234"],"string":"[\n \"0.63404727\",\n \"0.6133634\",\n \"0.6060749\",\n \"0.58401936\",\n \"0.56271565\",\n \"0.5616536\",\n \"0.5516699\",\n \"0.5483635\",\n \"0.54565936\",\n \"0.5450176\",\n \"0.5428849\",\n \"0.54229635\",\n \"0.540363\",\n \"0.54026043\",\n \"0.53971386\",\n \"0.5384905\",\n \"0.53581065\",\n \"0.5353302\",\n \"0.53430974\",\n \"0.5340143\",\n \"0.532937\",\n \"0.53236294\",\n \"0.53084755\",\n \"0.5306773\",\n \"0.5305699\",\n \"0.5302767\",\n \"0.5294419\",\n \"0.5294159\",\n \"0.5280441\",\n \"0.52649295\",\n \"0.52228427\",\n \"0.5221271\",\n \"0.52114123\",\n \"0.52072346\",\n \"0.5203848\",\n \"0.5192218\",\n \"0.5191798\",\n \"0.51893264\",\n \"0.5185908\",\n \"0.5181402\",\n \"0.51809573\",\n \"0.51733744\",\n \"0.5170192\",\n \"0.5167249\",\n \"0.5161559\",\n \"0.51574504\",\n \"0.5156294\",\n \"0.5151575\",\n \"0.5147884\",\n \"0.51394755\",\n \"0.5136762\",\n \"0.5132807\",\n \"0.512113\",\n \"0.51199216\",\n \"0.5117852\",\n \"0.5116792\",\n \"0.5116205\",\n \"0.51121515\",\n \"0.5107979\",\n \"0.5105224\",\n \"0.5103945\",\n \"0.5103181\",\n \"0.50994635\",\n \"0.50952107\",\n \"0.50860626\",\n \"0.5078496\",\n \"0.50773424\",\n \"0.5069469\",\n \"0.50607413\",\n \"0.50587785\",\n \"0.5054682\",\n \"0.5050547\",\n \"0.5050532\",\n \"0.50471073\",\n \"0.50459796\",\n \"0.50450647\",\n \"0.5038109\",\n \"0.5037803\",\n \"0.50335366\",\n \"0.502863\",\n \"0.5028471\",\n \"0.50261515\",\n \"0.5021058\",\n \"0.5020808\",\n \"0.50154614\",\n \"0.50142336\",\n \"0.5012762\",\n \"0.5011661\",\n \"0.5001392\",\n \"0.49986026\",\n \"0.49955955\",\n \"0.499461\",\n \"0.49916673\",\n \"0.4989332\",\n \"0.49882886\",\n \"0.49867004\",\n \"0.4985717\",\n \"0.49846116\",\n \"0.4981638\",\n \"0.49784234\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70147413"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14797,"cells":{"query":{"kind":"string","value":"Use the left and right fit"},"document":{"kind":"string","value":"def update_lanewidth(left_fit, right_fit, img_):\n img_size = img_.shape\n y_eval = np.linspace(0, img_size[0], 20)\n left_x = get_intercepts(left_fit, y_eval)\n right_x = get_intercepts(right_fit, y_eval)\n return np.clip(right_x - left_x, 400, 800)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __call__(self, left, mode, right, size=None, **kwargs):\n return super().__call__(left, mode, right, size=size, **kwargs)","def hflip(self):\n self.leftimg, self.rightimg = self.rightimg, self.leftimg","def rightbox(self):\r\n pass","def check_extent(self):\n if self.lower_left.x > self.upper_right.x:\n dlx = self.lower_left.x\n self.lower_left.x = self.upper_right.x\n self.upper_right.y = dlx\n\n if self.lower_left.y > self.upper_right.y:\n dly = self.lower_left.y\n self.lower_left.y = self.upper_right.y\n self.upper_right.y = dly","def update(self):\n left_height = self.left.height if self.left else -1\n right_height = self.right.height if self.right else -1\n self.height = 1 + max(left_height, right_height)\n self.bf = right_height - left_height","def shrink(self, right=0, bottom=0, left=0, top=0):\n self.min_col += left\n self.min_row += top\n self.max_col -= right\n self.max_row -= bottom","def reshape(self, bottom, top):\n\t\tpass","def reshape(self, bottom, top):\r\n pass","def _change_shape(self,x,y,w,h):\n top = y \n left = x\n right = x + w\n bottom = y + h\n return top,right,bottom,left","def increase_right_boundary(self):\n self.R = self.R + 1.0\n self.Ne = self.Ne + 1","def reshape(self,bottom,top):\n pass","def fit_lanes(self, points_left, points_right, fit_globally=False) -> dict:\n xl, yl = points_left\n xr, yr = points_right\n\n fit_vals = {}\n if fit_globally:\n # Define global model to fit\n x_left, y_left, x_right, y_right = symfit.variables('x_left, y_left, x_right, y_right')\n a, b, x0_left, x0_right = symfit.parameters('a, b, x0_left, x0_right')\n\n model = symfit.Model({\n x_left: a * y_left ** 2 + b * y_left + x0_left,\n x_right: a * y_right ** 2 + b * y_right + x0_right\n })\n\n # Apply fit\n xl, yl = points_left\n xr, yr = points_right\n fit = symfit.Fit(model, x_left=xl, y_left=yl, x_right=xr, y_right=yr)\n fit = fit.execute()\n fit_vals.update({'ar': fit.value(a), 'al': fit.value(a), 'bl': fit.value(b), 'br': fit.value(b),\n 'x0l': fit.value(x0_left), 'x0r': fit.value(x0_right)})\n\n else:\n # Fit lines independently\n x, y = symfit.variables('x, y')\n a, b, x0 = symfit.parameters('a, b, x0')\n\n model = symfit.Model({\n x: a * y ** 2 + b * y + x0,\n })\n\n # Apply fit on left\n fit = symfit.Fit(model, x=xl, y=yl)\n fit = fit.execute()\n fit_vals.update({'al': fit.value(a), 'bl': fit.value(b), 'x0l': fit.value(x0)})\n\n # Apply fit on right\n fit = symfit.Fit(model, x=xr, y=yr)\n fit = fit.execute()\n fit_vals.update({'ar': fit.value(a), 'br': fit.value(b), 'x0r': fit.value(x0)})\n\n return fit_vals","def setHeuristics(self, fitwid, fitoff, bothpass, relht, relwid, reloff):\n\tself.fwidth = fitwid\n\tself.foffset = fitoff\n\tself.bothpass = bothpass\n\tself.rheight = relht\n\tself.rwidth = relwid\n\tself.roffset = reloff","def expand(self, right=0, down=0, left=0, up=0):\n self.min_col -= left\n self.min_row -= up\n self.max_col += right\n self.max_row += down","def expanded_boundaries(self):\n width = self._points[0][3][0] - self._points[0][1][0]\n height = self._points[0][3][1] - self._points[0][1][1]\n factor = np.multiply((width, height), Window.BORDER)\n return (\n np.subtract(self._points[0][1], factor),\n np.add(self._points[0][3], factor))","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def __call__(self, axes, renderer):\n bbox0 = self.get_original_position(axes, renderer)\n bbox = bbox0\n\n x1, y1, w, h = bbox.bounds\n extesion_fraction = self.extesion_fraction\n dw, dh = w*extesion_fraction, h*extesion_fraction\n\n if self.extend in [\"min\", \"both\"]:\n if self.orientation == \"horizontal\":\n x1 = x1 + dw\n else:\n y1 = y1+dh\n\n if self.extend in [\"max\", \"both\"]:\n if self.orientation == \"horizontal\":\n w = w-2*dw\n else:\n h = h-2*dh\n\n return Bbox.from_bounds(x1, y1, w, h)","def _rect_right(self):\n\treturn max(self.x, self.x + self.w)","def right(self):\n return self.left + self.width","def sidebyside(w1, w2, buffer=20):\n import re\n import warnings\n # regex to extract the geometry\n geore = re.compile(r'(\\d+)x(\\d+)([\\+-]\\d+)([\\+-]\\d+)')\n\n # First, get the geometry of w1\n rematch = geore.match(w1.winfo_geometry())\n if not rematch:\n # We tried...\n warnings.warn('Could not determine geometry of parent window!')\n return\n\n w1_width, w1_height, w1_offsetx, w1_offsety = rematch.groups()\n\n # Now get w2's geometry\n rematch = geore.match(w2.winfo_geometry())\n if not rematch:\n # We tried...\n warnings.warn('Could not determine geometry of slave window!')\n return\n\n w2_width, w2_height, w2_offsetx, w2_offsety = rematch.groups()\n\n # If the original x offset is - (i.e., closer to RHS of screen), put w2\n # on the left. Otherwise, put it on the right\n if w1_offsetx[0] is '-':\n w2_offsetx = '-%d' % (int(w1_offsetx) - int(w1_width) - 20)\n w2.geometry('%sx%s%s%s' % (w2_width, w2_height, w2_offsetx, w2_offsety))\n else:\n w2_offsetx = '+%d' % (int(w1_offsetx) + int(w1_width) + 20)\n w2.geometry('%sx%s%s%s' % (w2_width, w2_height, w2_offsetx, w2_offsety))","def go_right(self):\n self.rect.centerx += 9","def __scale_and_shift(self, image, landmarks, scale_range, output_size):\n (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h) = self.get_bbox_of_landmarks(\n image, landmarks, scale_range, shift_rate=0.3)\n box_image = image[y1:y2, x1:x2]\n if need_pad:\n box_image = np.lib.pad(box_image, ((p_y, p_h), (p_x, p_w), (0, 0)), 'constant')\n box_image = cv2.resize(box_image, (output_size, output_size))\n landmarks = (landmarks - (x1 - p_x, y1 - p_y)) / (new_size, new_size)\n return box_image, landmarks","def pad(self):\n if self._mg_problem.boundaries[0] == 'periodic':\n # left side\n self.left[:] = self.mid[-self.borders[0]:]\n # right side\n self.right[:] = self.mid[:self.borders[1]]\n elif self._mg_problem.boundaries[0] == 'dirichlet':\n\n # left from border\n l_f_b = self.space_tensor[0:self.borders[0]]\n # right_from_border\n r_f_b = self.space_tensor[-self.borders[1]:]\n # left side\n self.left[:] = self.fl(l_f_b)\n # right side\n self.right[:] = self.fr(r_f_b)","def wheels(self, left, right):\n\t\twith self.data_lock:\n\t\t\tself.leftSpeed \t= left\t/500.0\t# leftSpeed and rightSpeed are in pixels per second\n\t\t\tself.rightSpeed = right\t/500.0","def adjust_visual(self):\n\n if (self.direction is bs.Direction.LEFT):\n self.rect.x -= 0.5 * CELL_SIZE","def scale(self):","def custom_space(self, xleft, ytop, xright, ybottom,\n lock_ratio=False):\n\n # basic info\n bbox = xleft,ytop,xright,ybottom\n x2x = (xleft,xright)\n y2y = (ybottom,ytop)\n xwidth = max(x2x)-min(x2x)\n yheight = max(y2y)-min(y2y)\n oldxwidth,oldyheight = xwidth,yheight\n\n # constrain the coordinate view ratio to the screen ratio, shrinking the coordinate space to ensure that it is fully contained inside the image\n centered = affine.Affine.identity()\n if lock_ratio:\n # make coords same proportions as screen\n screenxratio = self.width / float(self.height)\n yheight = yheight\n xwidth = yheight * screenxratio\n # ensure that altered coords do not shrink the original coords\n diffratio = 1.0\n if xwidth < oldxwidth: diffratio = oldxwidth / float(xwidth)\n elif yheight < oldyheight: diffratio = oldyheight / float(yheight)\n xwidth *= diffratio\n yheight *= diffratio\n # move the center of focus to middle of coordinate space if view ratio has been constrained\n xoff = (xwidth - oldxwidth) / 2.0\n yoff = (yheight - oldyheight) / 2.0\n centered *= affine.Affine.translate(xoff, yoff)\n \n # Note: The sequence of matrix multiplication is important and sensitive.\n # ...see eg http://negativeprobability.blogspot.no/2011/11/affine-transformations-and-their.html\n\n # scale ie resize world to screen coords\n scalex = self.width / float(xwidth)\n scaley = self.height / float(yheight)\n scaled = affine.Affine.scale(scalex,scaley)\n if xleft < xright: xoff = -min(x2x)\n else: xoff = min(x2x)\n if ytop < ybottom: yoff = -min(y2y)\n else: yoff = min(y2y)\n scaled *= affine.Affine.translate(xoff,yoff) # to force anchor upperleft world coords to upper left screen coords\n\n # flip world coords if axes run in different direction than screen axes\n xflip = xright < xleft\n yflip = ybottom < ytop\n if xflip: xflipoff = xwidth\n else: xflipoff = 0\n if yflip: yflipoff = yheight\n else: yflipoff = 0\n flipped = affine.Affine.translate(xflipoff,yflipoff) # to make the flipping stay in same place\n flipped *= affine.Affine.flip(xflip,yflip)\n\n # calculate the final coefficients and set as the drawtransform\n transcoeffs = (scaled * flipped * centered).coefficients\n self.drawer.settransform(transcoeffs)\n\n # finally remember the new coordinate extents and affine matrix\n self.coordspace_bbox = bboxhelper.resize_ratio(bbox,\n xratio=xwidth / float(oldxwidth),\n yratio=yheight / float(oldyheight) )\n self.coordspace_transform = transcoeffs","def _force_rescale(self, setpoint_x, setpoint_y):","def fit_ms2(stack, min_distances=(70,50,50), sigma_small=1, \n sigma_big=4, bg_radius=4, fitwindow_rad_xy=10, \n fitwindow_rad_z=2):\n\n # Task: change size to minimum distance\n def get_fitwindow(data, peak, xy_rad, z_rad):\n \"\"\"Retrieve section of image stack corresponding to given\n window around a point and the coordinate adjustments necessary\n to convert window coordinates to coordinates in the original image\"\"\"\n \n # Set the start points for windows and \"adjust\" them if they get \n # to negative numbers.\n zmin = peak[0] - z_rad\n xmin = peak[1] - xy_rad\n ymin = peak[2] - xy_rad\n # Initialize adjustments to values that are correct if no edge problems \n # are encountered.\n z_adj = -z_rad\n x_adj = -xy_rad\n y_adj = -xy_rad\n # Update mins and adjustments if windows start at negative coordinates.\n if (zmin < 0):\n zmin = 0\n z_adj = -peak[0]\n if (xmin < 0):\n xmin = 0\n x_adj = -peak[1]\n if (ymin < 0):\n ymin = 0\n y_adj = -peak[2]\n\n # Get end points, constained by max coordinate in data.\n zmax = min(data.shape[0] - 1, peak[0] + z_rad)\n xmax = min(data.shape[1] - 1, peak[1] + xy_rad)\n ymax = min(data.shape[2] - 1, peak[2] + xy_rad)\n\n return (data[zmin:(zmax+1), xmin:(xmax+1), ymin:(ymax+1)], z_adj, x_adj, y_adj)\n \n def relabel(peak_ids, oldparams, mask):\n \"\"\"Renumber labelmask and corresponding fit parameters\n Set background as 0, objects in order 1...end.\n \"\"\"\n spot_data = {}\n peak_num = 1\n for peak in peak_ids:\n #coords = np.where(mask == peak)\n paramsnew = oldparams[peak-1,:] # object 1 will be fitparams row 0\n # Rearrange params from fit function so coordinates lead.\n spot_data[peak_num] = paramsnew[[1,2,3,0,4,5,6]]\n peak_num = peak_num + 1\n return spot_data\n\n def clamp(n, minn, maxn):\n \"\"\"Bound a number between two constants\"\"\"\n return max(min(maxn, n), minn)\n \n def fit_frame(substack, min_distances, sigma_small, \n sigma_big, bg_radius, fitwindow_rad_xy, \n fitwindow_rad_z):\n \"\"\"Perform 3D gaussian fitting on a 3D image stack.\"\"\"\n\n # Filter and background subtract image.\n dog = dog_filter(substack, sigma_small, sigma_big)\n bg = ndi.filters.minimum_filter(dog, bg_radius)\n dog_bs = dog - bg\n\n # Make a labelmask corresponding to local maxima peaks.\n peak_window_size = (min_distances[0] * 2 + 1, min_distances[1] * 2 + 1, min_distances[2] * 2 + 1)\n mask, peaks = peak_local_max_nD(dog_bs, peak_window_size)\n\n # Fit 3D gaussian in window surrounding each local maximum.\n fitparams = np.ndarray((0,7))\n for peak in peaks:\n fitwindow, z_adj, x_adj, y_adj = get_fitwindow(substack, peak, fitwindow_rad_xy, \n fitwindow_rad_z)\n opt = fitgaussian3d(fitwindow)\n if opt.success:\n peak_fitparams = opt.x\n # Move center coordinates to match center of gaussian fit, ensure they're within image. \n # If they're outside the image, coordinate is assigned as the edge of the image.\n peak_fitparams[0] = int(round(clamp((peak[0] + peak_fitparams[0] + z_adj), 0, substack.shape[-3]-1)))\n peak_fitparams[1] = int(round(clamp((peak[1] + peak_fitparams[1] + x_adj), 0, substack.shape[-2]-1)))\n peak_fitparams[2] = int(round(clamp((peak[2] + peak_fitparams[2] + y_adj), 0, substack.shape[-1]-1)))\n fitparams = np.vstack((fitparams, peak_fitparams))\n # If fit fails, add dummy entry for spot.\n else:\n fitparams = np.vstack((fitparams, np.array([z_adj,x_adj,y_adj,0,np.inf,np.inf,np.inf])))\n return fitparams\n \n #### Main ####\n # Do fitting on first frame.\n fit_data_frame0 = fit_frame(stack[0], min_distances, sigma_small, \n sigma_big, bg_radius, fitwindow_rad_xy, \n fitwindow_rad_z)\n # Make fit_data a list of ndarrays.\n fit_data = [fit_data_frame0]\n \n # Fit the rest of the frames, add their data to fit_data.\n for i in range(1, stack.shape[0]):\n print(i, end=' ')\n fit_data_thisframe = fit_frame(stack[i], min_distances, sigma_small, \n sigma_big, bg_radius, fitwindow_rad_xy, \n fitwindow_rad_z)\n fit_data.append(fit_data_thisframe)\n \n return fit_data","def flip(self):\n self.align = self._left if self.align == self._right else self._right\n self.group.layout_all()","def _align_toplevel_grid(self):\n\n # align origin with nearest multple of 128\n self.mins[0] -= self.mins[0] % 128\n self.mins[1] -= self.mins[1] % 128\n\n width = self.maxs[0] - self.mins[0]\n height = self.maxs[1] - self.mins[1]\n greatest_dim = max(width, height)\n nearest_pow_two = int(2 ** np.ceil(np.log2(greatest_dim)))\n width_adjustment = (nearest_pow_two - width)\n height_adjustment = (nearest_pow_two - height)\n\n self.maxs[0] += width_adjustment\n self.maxs[1] += height_adjustment","def toFit(curr_width, curr_height, bounds_width, bounds_height):\n\n\t# Return\n\tlRet\t= [0,0]\n\n\t# Convert current width/height to floats\n\tcurr_width\t\t= float(curr_width)\n\tcurr_height\t\t= float(curr_height)\n\n\t# If either width or height is smaller than the boundary box, resize up\n\tif curr_width < bounds_width and curr_height < bounds_height:\n\n\t\t# Which is the side that needs to grow less?\n\t\tif (bounds_width / curr_width) > (bounds_height / curr_height):\n\t\t\tlRet[1]\t= bounds_height\n\t\t\tlRet[0]\t= int(round(bounds_height * (curr_width / curr_height)))\n\t\telse:\n\t\t\tlRet[0]\t= bounds_width\n\t\t\tlRet[1]\t= int(round(bounds_width * (curr_height / curr_width)))\n\n\t# Else if the image is already larger than the boundary, resize down\n\telse:\n\n\t\t# Which is the side that needs to shrink more?\n\t\tif (curr_width / bounds_width) > (curr_height / bounds_height):\n\t\t\tlRet[0]\t= bounds_width\n\t\t\tlRet[1]\t= int(round(bounds_width * (curr_height / curr_width)))\n\t\telse:\n\t\t\tlRet[1]\t= bounds_height\n\t\t\tlRet[0]\t= int(round(bounds_height * (curr_width / curr_height)))\n\n\t# Return the new dimensions\n\treturn lRet","def setFitMethod(self,method = RESIZE):","def make_empty_right(self, e=0):\n self.make_empty_side(u'right')","def set_xlim(self, left=None, right=None):\n if right is None and np.iterable(left):\n left, right = left\n\n if left is None or right is None:\n old_left, old_right = self.get_xlim()\n if left is None:\n left = old_left\n if right is None:\n right = old_right\n\n if left == right:\n warnings.warn(\n \"Attempting to set identical left == right == {} x-axis limits\".format(\n left\n ),\n stacklevel=2,\n )\n\n if left > right:\n raise ValueError(\"Axis limits must be in increasing order\")\n\n if right <= 0 and self._logx:\n warnings.warn(\n \"Attempting to set non-positive right xlim on a log-scaled axis.\\n\"\n \"Invalid limit will be ignored.\",\n stacklevel=2,\n )\n right = self.get_xlim()[1]\n\n elif left <= 0 and self._logx:\n warnings.warn(\n \"Attempting to set non-positive left xlim on a log-scaled axis.\\n\"\n \"Invalid limit will be ignored.\",\n stacklevel=2,\n )\n left = self.get_xlim()[0]\n\n if isinstance(self._frame, root.TH1F):\n self._frame.GetXaxis().SetLimits(left, right)\n else:\n self._frame.GetXaxis().SetRangeUser(left, right)\n\n self._pad.Modified() # Draw the updated axes\n\n return (left, right)","def create_right_left_containers(self) -> None:\n self.frame_left = tk.Frame(self, borderwidth=5, relief=tk.GROOVE)\n self.frame_left.grid(row=0, column=0)\n # self.window_left_info = None\n self.frame_right = tk.Frame(self, borderwidth=5, relief=tk.GROOVE)\n self.frame_right.grid(row=0, column=1)","def measure_offset(self, left_fit, right_fit):\n xm_per_pix = 3.7 / 130 # meters per pixel in x dimension\n y_val = self.warped_image_size[1] / 2\n # Camera is not exactly on center of car so we need to compensate it with this number\n # It is calculated by measuring the center of lane from \"straight_lines1.jpg\"\n x_correction = -67\n base_leftx = left_fit[0] * y_val ** 2 + left_fit[1] * y_val + left_fit[2]\n base_rightx = right_fit[0] * y_val ** 2 + right_fit[1] * y_val + right_fit[2]\n\n # Calculate image x-center (TODO: This calculation should be somewhere else. Not reasonable to calculate on every iteration.)\n center_of_image = self.warped_image_size[0] / 2.\n # Measured center and real offset calculations\n measured_center = base_leftx + (base_rightx - base_leftx) + x_correction\n measured_offset = (center_of_image - measured_center) * xm_per_pix\n return measured_offset","def stretch(self, x_stretch=1, y_stretch=1):\n self.width *= x_stretch\n self.height *= y_stretch\n\n # Always update the corners after operation\n self.update_corners()\n return","def set_relative_viewbox(self, x0, y0, x1, y1):\n # prevent too small zoombox\n if (np.abs(x1 - x0) < .07) & (np.abs(y1 - y0) < .07):\n return\n # force the zoombox to keep its original ratio\n if self.parent.constrain_ratio:\n x0, y0, x1, y1 = self.constrain_viewbox(x0, y0, x1, y1)\n if (x1-x0) and (y1-y0):\n self.tx += -(x1+x0)/(2*self.sx)\n self.ty += -(y1+y0)/(2*self.sy)\n self.sx *= 2./abs(x1-x0)\n self.sy *= 2./abs(y1-y0)\n self.sxl, self.syl = self.sx, self.sy","def display_right_to_left(self):\n return self.container['display_right_to_left']","def _resize_interval(start, end, size):\n center = int(0.5 * (start + end))\n half_size = int(0.5 * size)\n left = center - half_size\n right = left + size\n return left, right","def _rect_left(self):\n\treturn min(self.x, self.x + self.w)","def right_or_left(self):\n self.scan()\n\n max = 0\n side = 'l'\n\n #analyze scan results\n for angle in self.scan_data:\n #RIGHT SIDE\n if angle < self.MIDPOINT:\n if self.scan_data[angle] > max:\n max = self.scan_data[angle]\n side = 'r'\n #LEFT SIDE\n else:\n if self.scan_data[angle] > max:\n max = self.scan_data[angle]\n side = 'l'\n\n return side","def __init__(self, top_left, bottom_right, keep_aspect=True, fix_axis=None):\n super().__init__(top_left, bottom_right, keep_aspect=keep_aspect, fix_axis=fix_axis, margins=margins)","def _overlay_ref_fit(self, img, mean, fit, off=25):\n\n def plus(img, x, y, val=0, r=10):\n img[x - 1:x, y - r:y + r], img[x - r:x + r, y - 1:y] = val, val\n return img\n\n if len(self.refzone) != 4:\n return img\n\n centers = [(self.ref_rc[0] - off, self.ref_rc[1] - off),\n (self.ref_rc[0] - off, self.ref_rc[1] + off),\n (self.ref_rc[0] + off, self.ref_rc[1] - off),\n (self.ref_rc[0] + off, self.ref_rc[1] + off)]\n\n img = plus(img, self.ref_rc[0], self.ref_rc[1], val=150, r=15) # final mean offset\n img = plus(img, self.ref_rc[0] + mean[0], self.ref_rc[1] + mean[1], val=0)\n for [x0, x1, y0, y1], [x_off, y_off], (cx, cy) in zip(self.refzone, fit, centers):\n img = plus(img, cx, cy, val=120, r=15) # panel fitted\n img = plus(img, cx + x_off, cy + y_off, val=0) # panel reference\n img = plus(img, x0, y0, val=150) # expected reference\n img = plus(img, x1, y1, val=150) #\n img = plus(img, x0 + x_off, y0 + y_off, val=0) # actual fitted\n img = plus(img, x1 + x_off, y1 + y_off, val=0) #\n\n return img","def set_tight_lims(data_x, data_y, center_x=None, center_y=None,\n mode='symmetric', buf=0.3):\n ax = plt.gca()\n\n if center_x is None:\n maxx = max(data_x)\n minx = min(data_x)\n sepx = maxx - minx\n maxx = maxx + buf * sepx\n minx = minx - buf * sepx\n ax.set_xlim((minx, maxx))\n else:\n distx = data_x - center_x\n maxx = max(max(distx), 0)\n minx = min(min(distx), 0)\n if mode == 'symmetric':\n limx = max(abs(maxx), abs(minx))\n limx = limx + buf * limx\n ax.set_xlim((center_x - limx, center_x + limx))\n elif mode == 'tight':\n maxx = maxx + buf * maxx if maxx != 0 else -buf * minx\n minx = minx + buf * minx if minx != 0 else -buf * maxx\n ax.set_xlim((center_x + minx, center_x + maxx))\n\n if center_y is None:\n maxy = max(data_y)\n miny = min(data_y)\n sepy = maxy - miny\n maxy = maxy + buf * sepy\n miny = miny - buf * sepy\n ax.set_ylim((miny, maxy))\n else:\n disty = data_y - center_y\n maxy = max(max(disty), 0)\n miny = min(min(disty), 0)\n if mode == 'symmetric':\n limy = max(abs(maxy), abs(miny))\n limy = limy + buf * limy\n ax.set_ylim((center_y - limy, center_y + limy))\n elif mode == 'tight':\n maxy = maxy + buf * maxy if maxy != 0 else -buf * miny\n miny = miny + buf * miny if miny != 0 else -buf * maxy\n ax.set_ylim((center_y + miny, center_y + maxy))","def positive_left_right_requirements(\n self,\n ) -> Tuple[Tuple[GriddedPerm, ...], Tuple[GriddedPerm, ...]]:\n left, right = [], []\n for (x, y) in self._tiling.active_cells:\n if self._fuse_row and y == self._row_idx:\n left.append(GriddedPerm.single_cell((0,), (x, y)))\n right.append(GriddedPerm.single_cell((0,), (x, y + 1)))\n if not self._fuse_row and x == self._col_idx:\n left.append(GriddedPerm.single_cell((0,), (x, y)))\n right.append(GriddedPerm.single_cell((0,), (x + 1, y)))\n return tuple(sorted(left)), tuple(sorted(right))","def align(self):\n ...","def project_grid(self):\n\n # option 1: no shared axes. Trees are scaled(?)\n\n\n # option 2: shared axes. Spacing of tree","def inner_fit(self):\n pass","def inner_fit(self):\n pass","def test_fit(self, fit: str, baseline_images):\n fig = plt.figure()\n ax = fig.add_subplot(projection=\"ternary\")\n tn0, tn1, tn2 = get_spiral()\n ax.plot(tn0, tn1, tn2, \"C0\")\n ax.plot(tn0, tn1, tn2, \"k\", transform=ax.transTernaryAxes)\n ax.set_facecolor(\"0.9\")\n ax.grid(True)\n ax.set_ternary_lim(0.1, 0.7, 0.1, 0.6, 0.1, 0.5, fit)","def set_viewbox(self, x0, y0, x1, y1):\n # force the zoombox to keep its original ratio\n if self.parent.constrain_ratio:\n x0, y0, x1, y1 = self.constrain_viewbox(x0, y0, x1, y1)\n if (x1-x0) and (y1-y0):\n self.tx = -(x1+x0)/2\n self.ty = -(y1+y0)/2\n self.sx = 2./abs(x1-x0)\n self.sy = 2./abs(y1-y0)\n self.sxl, self.syl = self.sx, self.sy","def leftToRight(self):\n self.displaymode |= self.LCD_ENTRYLEFT\n self.write_lcd(self.LCD_DATA_E1, self.LCD_ENTRYMODESET | self.displaymode)\n self.write_lcd(self.LCD_DATA_E2, self.LCD_ENTRYMODESET | self.displaymode)","def xlim(self, left=None, right=None):\r\n for ax in self._subaxes:\r\n ax.set_xlim(left, right)\r\n self.figure.canvas.draw()","def calculate_coordinates(self):\n # get coordinates for lef side of equation\n self._calculate_for_one_side(self.left_side)\n\n # set process glyph x coordinate\n self.process_glyph_x = self.x_limit + 150\n\n self._calculate_for_one_side(self.right_side, side=\"right_side\")\n\n self.x_limit, self.y_limit = self._generate_real_coordinates_according_to_compartment()\n\n # set process glyph y coordinate\n self.process_glyph_y = self.y_limit / 2\n\n # set final image width, height\n self.x_limit += 10\n self.y_limit += 20","def get_best_fit(self, binary_warped):\r\n # print('smart fit')\r\n left_fit, right_fit = self.fit_dict['left_fit'], self.fit_dict['right_fit']\r\n nonzero = binary_warped.nonzero()\r\n nonzeroy = np.array(nonzero[0])\r\n nonzerox = np.array(nonzero[1])\r\n margin = 100\r\n minpix = 5000\r\n left_lane_inds = (\r\n (nonzerox > (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) & (\r\n nonzerox < (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] + margin)))\r\n right_lane_inds = (\r\n (nonzerox > (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) & (\r\n nonzerox < (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] + margin)))\r\n\r\n if len(left_lane_inds.nonzero()[0]) < minpix or len(right_lane_inds.nonzero()[0]) < minpix:\r\n self.apply_sliding_window_flag = True\r\n return self.get_best_fit_using_sliding_window(binary_warped)\r\n # Again, extract left and right line pixel positions\r\n leftx = nonzerox[left_lane_inds]\r\n lefty = nonzeroy[left_lane_inds]\r\n rightx = nonzerox[right_lane_inds]\r\n righty = nonzeroy[right_lane_inds]\r\n\r\n if not self.check_valid_params(leftx, lefty, rightx, righty):\r\n self.apply_sliding_window_flag = True\r\n return self.get_best_fit_using_sliding_window(binary_warped)\r\n # Fit a second order polynomial to each\r\n left_fit = np.polyfit(lefty, leftx, 2)\r\n right_fit = np.polyfit(righty, rightx, 2)\r\n self.fit_dict['left_fit'], self.fit_dict['right_fit'] = left_fit, right_fit\r\n left_curve_rad, right_curve_rad, vehicle_offset = self.compute_lane_statistics(binary_warped)\r\n self.fit_dict['left_curve_rad'], self.fit_dict['right_curve_rad'] = left_curve_rad, right_curve_rad\r\n self.fit_dict['vehicle_offset'] = vehicle_offset\r\n self.result_buffer.append(self.fit_dict.copy())\r\n return","def box_function(width_left, width_right, shift, sigma, x):\n\n prefactor = 2.0 * 0.25\n left = erf( (1.0/width_left * x + 1.0/width_left * shift + 1.0) / ( sigma * math.sqrt(2.0)) )\n right = erf( (1.0/width_right * x + 1.0/width_right * shift - 1.0) / ( sigma * math.sqrt(2.0)) )\n\n return prefactor * (left - right)","def swap_main(self):\n if self.align == self._left:\n self.swap_left()\n elif self.align == self._right:\n self.swap_right()","def pad(self, left=0, top=0, bottom=0, right=0):\n\n self.x -= left\n self.y -= top\n self.width += left + right\n self.height += top + bottom","def extent(self):\n left = self.transform[0]\n right = left + self.transform[1] * self.shape[1]\n top = self.transform[3]\n bottom = top + self.transform[5] * self.shape[0]\n return left, right, bottom, top","def bounds(self) -> tuple[float, float, float, float]:\n transform = self.transform\n a, b, c, d, e, f, _, _, _ = transform\n if b == d == 0:\n xs = (c, c + a * self.width)\n ys = (f, f + e * self.height)\n else: # rotated\n c0x, c0y = c, f\n c1x, c1y = transform * (0, self.height)\n c2x, c2y = transform * (self.width, self.height)\n c3x, c3y = transform * (self.width, 0)\n xs = (c0x, c1x, c2x, c3x)\n ys = (c0y, c1y, c2y, c3y)\n return min(xs), min(ys), max(xs), max(ys)","def updateHeight(self):\n leftHeight = self.left.height if self.left != None else 0\n rightHeight = self.right.height if self.right != None else 0\n self.height = max(rightHeight, leftHeight) + 1","def grow_right(self, width, height):\r\n old_self = copy.copy(self)\r\n self.used = True\r\n self.x = self.y = 0\r\n self.width += width\r\n self.down = old_self\r\n self.right = SquareAlgorithmNode(x=old_self.width,\r\n y=0,\r\n width=width,\r\n height=self.height)\r\n\r\n node = self.find(self, width, height)\r\n if node:\r\n return self.split(node, width, height)\r\n return None","def get_rightmost_edge(self):\n return self.offset + sum(self.get_screen_widths())","def xlim(left=None, right=None):\n impl.xlim(**locals())","def _configure_right(self, client, index):\n widths = self._get_secondary_widths()\n height = self._get_secondary_height(index)\n left = self.screen_rect.x + widths[0] + self._get_main_width()\n top = self.screen_rect.y + self._get_relative_sizes_above(index)\n\n self._place_client(client, left, top, widths[1], height)","def setAxisParts(lowx='all', lefty='all', upx='ticks', righty='ticks'):\n partdict = {'none':'NONE','lines':'LINE','ticks':'TICKS',\n 'labels':'LABELS', 'all':'NAME'} \n dislin.setgrf(partdict[lowx], partdict[lefty],\\\n partdict[upx], partdict[righty])","def set_lanes(left_lines, right_lines, image):\n \n Y_LANE_EXTRAP = 35 # percent up from bottom of image to extrapolate lane lines\n \n image_wk = np.copy(image) # working copy\n image_lines = np.copy(image_wk)*0 # create a blank to draw lines on\n im_y = image_wk.shape[0]\n \n y1_lane = im_y\n y2_lane = np.int32(im_y - (Y_LANE_EXTRAP/100*im_y))\n \n # Process left lane\n if left_lines:\n z_left = my_linear_polyfit(left_lines)\n x1_lane = np.int32( (y1_lane - z_left[1]) / z_left[0] ) # x = (y-b)/m\n x2_lane = np.int32( (y2_lane - z_left[1]) / z_left[0] )\n \n # Draw left lane on blank image\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\n \n # Process right lane\n if right_lines:\n z_right = my_linear_polyfit(right_lines)\n x1_lane = np.int32( (y1_lane - z_right[1]) / z_right[0] ) # x = (y-b)/m\n x2_lane = np.int32( (y2_lane - z_right[1]) / z_right[0] )\n \n # Draw right lane on blank image\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\n \n # Overlay detected left/right lanes on road image\n image_wk = weighted_img(image_lines, image_wk)\n \n # Output road image with overlaid left/right lanes\n return image_wk","def midright(self):\n return (self.right, self.centery)","def annotate(self, left_right=True, positions=True, size=12, **kwargs):\n kwargs = kwargs.copy()\n if not 'color' in kwargs:\n if self._black_bg:\n kwargs['color'] = 'w'\n else:\n kwargs['color'] = 'k'\n\n bg_color = ('k' if self._black_bg else 'w')\n if left_right:\n for cut_ax in self.axes.values():\n cut_ax.draw_left_right(size=size, bg_color=bg_color,\n **kwargs)\n\n if positions:\n for cut_ax in self.axes.values():\n cut_ax.draw_position(size=size, bg_color=bg_color,\n **kwargs)","def build_filler_images(self):","def resize_to_fit(self, bbox_lower, bbox_upper, padding=0.0):\n lower_offset = np.array((padding, padding, 0.0))\n self.lower_vertex = bbox_lower - lower_offset\n upper_offset = np.array([padding] * 3)\n self.upper_vertex = bbox_upper + upper_offset","def increase_left_boundary(self):\n self.L = self.L - 1.0\n self.Ne = self.Ne + 1","def _texture_fit(\n self,\n side: Side,\n tex_size: float,\n field_length: float,\n fizz: Fizzler,\n neg: Vec,\n pos: Vec,\n is_laserfield: bool = False,\n ) -> None:\n # Compute the orientations that are up and along the fizzler.\n side.uaxis.x, side.uaxis.y, side.uaxis.z = fizz.forward()\n side.vaxis.x, side.vaxis.y, side.vaxis.z = -fizz.up_axis\n\n side.uaxis.offset = -(tex_size / field_length) * neg.dot(side.uaxis.vec())\n side.vaxis.offset = -(tex_size / 128) * neg.dot(side.vaxis.vec())\n\n # The above fits it correctly, except it's vertically half-offset.\n # For laserfields that's what we want, for fizzlers we want it normal.\n if not is_laserfield:\n side.vaxis.offset += tex_size / 2\n\n side.uaxis.scale = field_length / tex_size\n side.vaxis.scale = 128 / tex_size\n\n side.uaxis.offset %= tex_size\n side.vaxis.offset %= tex_size","def right_option():\n active = get_active_window()\n Width=get_corner_Width(active)\n Height=get_middle_Height()\n PosX = get_right_PosX(active,Width)\n PosY=get_middle_PosY()\n move_window(active,PosX,PosY,Width,Height)\n raise_window(active)","def _boundRect(self):\n self.upperleft = list(map(min, zip(*self.addresstamp)))\n self.bottomright = list(map(max, zip(*self.addresstamp)))\n self.upperright = [self.bottomright[0], self.upperleft[1]]\n self.bottomleft = [self.upperleft[0], self.bottomright[1]]\n (self.width, self.height) = (self.upperright[0] - self.bottomleft[0], self.bottomleft[1] - self.upperright[1])\n assert self.width >= 0\n assert self.height >= 0\n self.center = [self.upperleft[0] + self.width / float(2), self.upperleft[1] + self.height / float(2)]\n self.corners = [self.upperright, self.bottomleft, self.upperleft, self.bottomright]","def get_bbox_of_landmarks(self, image, landmarks, scale_range, shift_rate=0.3):\n ori_h, ori_w = image.shape[:2]\n x = int(min(landmarks[:, 0]))\n y = int(min(landmarks[:, 1]))\n w = int(max(landmarks[:, 0]) - x)\n h = int(max(landmarks[:, 1]) - y)\n if type(scale_range) == float:\n scale = scale_range\n else:\n scale = np.random.randint(int(scale_range[0] * 100.0), int(scale_range[1] * 100.0)) / 100.0\n new_size = int(max(w, h) * scale)\n if shift_rate >= 0.5:\n x1 = x - (new_size - w) / 2\n y1 = y - (new_size - h) / 2\n else:\n x1 = x - np.random.randint(int((new_size - w) * shift_rate), int((new_size - w) * (1.0 - shift_rate)))\n y1 = y - np.random.randint(int((new_size - w) * shift_rate), int((new_size - w) * (1.0 - shift_rate)))\n x2 = x1 + new_size\n y2 = y1 + new_size\n need_pad = False\n p_x, p_y, p_w, p_h = 0, 0, 0, 0\n if x1 < 0:\n p_x = -x1\n x1 = 0\n need_pad = True\n if y1 < 0:\n p_y = -y1\n y1 = 0\n need_pad = True\n if x2 > ori_w:\n p_w = x2 - ori_w\n x2 = ori_w\n need_pad = True\n if y2 > ori_h:\n p_h = y2 - ori_h\n y2 = ori_h\n need_pad = True\n\n return (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h)","def _locator(self, axes, renderer):\n x0, y0, x1, y1 = self.rect\n width_dict = dict()\n cut_ax_dict = self.axes\n for cut_ax in cut_ax_dict.values():\n bounds = cut_ax.get_object_bounds()\n if not bounds:\n # This happens if the call to _map_show was not\n # succesful. As it happens asyncroniously (during a\n # refresh of the figure) we capture the problem and\n # ignore it: it only adds a non informative traceback\n bounds = [0, 1, 0, 1]\n xmin, xmax, ymin, ymax = bounds\n width_dict[cut_ax.ax] = (xmax - xmin)\n total_width = float(sum(width_dict.values()))\n for ax, width in width_dict.items():\n width_dict[ax] = width/total_width*(x1 -x0)\n left_dict = dict()\n left = float(x0)\n for coord, cut_ax in sorted(cut_ax_dict.items()):\n left_dict[cut_ax.ax] = left\n this_width = width_dict[cut_ax.ax]\n left += this_width\n return transforms.Bbox([[left_dict[axes], y0],\n [left_dict[axes] + width_dict[axes], y1]])","def fill_box(self, x, y, w, h):\n\t\tpass","def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False):\n\n assert mode in ['iou', 'iof']\n\n rows = bboxes1.size(0)\n cols = bboxes2.size(0)\n if is_aligned:\n assert rows == cols\n\n if rows * cols == 0:\n return bboxes1.new(rows, 1) if is_aligned else bboxes1.new(rows, cols)\n\n if is_aligned:\n lt = torch.max(bboxes1[:, :2], bboxes2[:, :2]) # [rows, 2]\n rb = torch.min(bboxes1[:, 2:], bboxes2[:, 2:]) # [rows, 2]\n\n wh = (rb - lt + 1).clamp(min=0) # [rows, 2]\n overlap = wh[:, 0] * wh[:, 1]\n area1 = (bboxes1[:, 2] - bboxes1[:, 0] + 1) * (\n bboxes1[:, 3] - bboxes1[:, 1] + 1)\n\n if mode == 'iou':\n area2 = (bboxes2[:, 2] - bboxes2[:, 0] + 1) * (\n bboxes2[:, 3] - bboxes2[:, 1] + 1)\n ious = overlap / (area1 + area2 - overlap)\n else:\n ious = overlap / area1\n else:\n # not aligned boxes are usually used for assigners,\n # because assigners need to know all the overlaps between every bbox and every gtbox\n \n # none add a new axis ag: [3,4] => [3, 1, 4] \n # torch.max will broadcast: 3 1 4, 5 4 => 3 5 4\n lt = torch.max(bboxes1[:, None, :2], bboxes2[:, :2]) # [rows, cols, 2]\n rb = torch.min(bboxes1[:, None, 2:], bboxes2[:, 2:]) # [rows, cols, 2]\n\n wh = (rb - lt + 1).clamp(min=0) # [rows, cols, 2]\n overlap = wh[:, :, 0] * wh[:, :, 1]\n area1 = (bboxes1[:, 2] - bboxes1[:, 0] + 1) * (\n bboxes1[:, 3] - bboxes1[:, 1] + 1)\n\n if mode == 'iou':\n area2 = (bboxes2[:, 2] - bboxes2[:, 0] + 1) * (\n bboxes2[:, 3] - bboxes2[:, 1] + 1)\n ious = overlap / (area1[:, None] + area2 - overlap)\n else:\n ious = overlap / (area1[:, None])\n\n return ious","def raw_resolution(resolution, splitter=False):\n width, height = resolution\n if splitter:\n fwidth = (width + 15) & ~15\n else:\n fwidth = (width + 31) & ~31\n fheight = (height + 15) & ~15\n return fwidth, fheight","def _do_layout(self):\n if self.stack_order == \"bottom_to_top\":\n components = (self.zoomed_plot, self.reference_plot)\n relative_sizes = (4 / 3., 2 / 3.)\n else:\n components = (self.reference_plot, self.zoomed_plot)\n relative_sizes = (2 / 3., 4 / 3.)\n if self.halign == \"left\":\n align = \"min\"\n elif self.halign == \"center\":\n align = \"center\"\n else:\n align = \"max\"\n #import pdb; pdb.set_trace()\n return self._do_stack_layout(components, relative_sizes, align)","def go_right(self):\n self.rect.centerx += self.__dx","def bbox_rel(image_width, image_height, *xyxy):\n\tbbox_left = min([xyxy[0].item(), xyxy[2].item()])\n\tbbox_top = min([xyxy[1].item(), xyxy[3].item()])\n\tbbox_w = abs(xyxy[0].item() - xyxy[2].item())\n\tbbox_h = abs(xyxy[1].item() - xyxy[3].item())\n\tx_c = (bbox_left + bbox_w / 2)\n\ty_c = (bbox_top + bbox_h / 2)\n\tw = bbox_w\n\th = bbox_h\n\treturn x_c, y_c, w, h","def makeLeftRightline(self):\r\n left_lines = []\r\n right_lines = []\r\n for i in self.lines:\r\n for x1,y1,x2,y2 in i:\r\n if x1 == x2:\r\n #Vertical Lines\r\n pass\r\n else:\r\n m = (y2 - y1) / (x2 - x1)\r\n c = y1 - m * x1\r\n if m < 0:\r\n left_lines.append((m,c))\r\n elif m >= 0:\r\n right_lines.append((m,c))\r\n return left_lines,right_lines","def setRect(self, p_float, p_float_1, p_float_2, p_float_3): # real signature unknown; restored from __doc__\r\n pass","def box(self, x, y, w, h):\n\t\tpass","def adjust_left_right_positions():\n # bp_* is synonym for 'Best Position Left/Right' and are adjusted \n # to optimize bmv_*\n p_l, bp_l = [pos] * 2\n p_r, bp_r = [pos + qlen] * 2\n\n # bmv_* are declared here in case they are untouched in optimization\n bmv_l = match_values[p_l / step]\n bmv_r = match_values[p_l / step]\n\n for f in range(flex):\n ll = _match(query, corpus[p_l - f: p_r])\n if ll > bmv_l:\n bmv_l = ll\n bp_l = p_l - f\n\n lr = _match(query, corpus[p_l + f: p_r])\n if lr > bmv_l:\n bmv_l = lr\n bp_l = p_l + f\n\n rl = _match(query, corpus[p_l: p_r - f])\n if rl > bmv_r:\n bmv_r = rl\n bp_r = p_r - f\n\n rr = _match(query, corpus[p_l: p_r + f])\n if rr > bmv_r:\n bmv_r = rr\n bp_r = p_r + f\n\n if verbose:\n print(\"\\n\" + str(f))\n print(\"ll: -- value: %f -- snippet: %s\" % (ll, corpus[p_l - f: p_r]))\n print(\"lr: -- value: %f -- snippet: %s\" % (lr, corpus[p_l + f: p_r]))\n print(\"rl: -- value: %f -- snippet: %s\" % (rl, corpus[p_l: p_r - f]))\n print(\"rr: -- value: %f -- snippet: %s\" % (rl, corpus[p_l: p_r + f]))\n\n return bp_l, bp_r, _match(query, corpus[bp_l : bp_r])","def draw(self, binary, leftx, rightx):\n\t\tfilled = np.zeros_like(binary)\n\t\tploty = np.linspace(0, filled.shape[0] - 1, filled.shape[0])\n\t\t# Recast the x and y points into usable format for cv2.fillpoly()\n\t\tpts_left = np.array([np.transpose(np.vstack([leftx, ploty]))])\n\t\tpts_right = np.array([np.flipud(np.transpose(np.vstack([rightx, ploty])))])\n\t\tpts = np.hstack((pts_left, pts_right))\n\t\t# Draw the lane onto the warped blank image\n\t\tcv2.fillPoly(filled, np.int_([pts]), (0, 255, 0))\n\t\treturn filled"],"string":"[\n \"def __call__(self, left, mode, right, size=None, **kwargs):\\n return super().__call__(left, mode, right, size=size, **kwargs)\",\n \"def hflip(self):\\n self.leftimg, self.rightimg = self.rightimg, self.leftimg\",\n \"def rightbox(self):\\r\\n pass\",\n \"def check_extent(self):\\n if self.lower_left.x > self.upper_right.x:\\n dlx = self.lower_left.x\\n self.lower_left.x = self.upper_right.x\\n self.upper_right.y = dlx\\n\\n if self.lower_left.y > self.upper_right.y:\\n dly = self.lower_left.y\\n self.lower_left.y = self.upper_right.y\\n self.upper_right.y = dly\",\n \"def update(self):\\n left_height = self.left.height if self.left else -1\\n right_height = self.right.height if self.right else -1\\n self.height = 1 + max(left_height, right_height)\\n self.bf = right_height - left_height\",\n \"def shrink(self, right=0, bottom=0, left=0, top=0):\\n self.min_col += left\\n self.min_row += top\\n self.max_col -= right\\n self.max_row -= bottom\",\n \"def reshape(self, bottom, top):\\n\\t\\tpass\",\n \"def reshape(self, bottom, top):\\r\\n pass\",\n \"def _change_shape(self,x,y,w,h):\\n top = y \\n left = x\\n right = x + w\\n bottom = y + h\\n return top,right,bottom,left\",\n \"def increase_right_boundary(self):\\n self.R = self.R + 1.0\\n self.Ne = self.Ne + 1\",\n \"def reshape(self,bottom,top):\\n pass\",\n \"def fit_lanes(self, points_left, points_right, fit_globally=False) -> dict:\\n xl, yl = points_left\\n xr, yr = points_right\\n\\n fit_vals = {}\\n if fit_globally:\\n # Define global model to fit\\n x_left, y_left, x_right, y_right = symfit.variables('x_left, y_left, x_right, y_right')\\n a, b, x0_left, x0_right = symfit.parameters('a, b, x0_left, x0_right')\\n\\n model = symfit.Model({\\n x_left: a * y_left ** 2 + b * y_left + x0_left,\\n x_right: a * y_right ** 2 + b * y_right + x0_right\\n })\\n\\n # Apply fit\\n xl, yl = points_left\\n xr, yr = points_right\\n fit = symfit.Fit(model, x_left=xl, y_left=yl, x_right=xr, y_right=yr)\\n fit = fit.execute()\\n fit_vals.update({'ar': fit.value(a), 'al': fit.value(a), 'bl': fit.value(b), 'br': fit.value(b),\\n 'x0l': fit.value(x0_left), 'x0r': fit.value(x0_right)})\\n\\n else:\\n # Fit lines independently\\n x, y = symfit.variables('x, y')\\n a, b, x0 = symfit.parameters('a, b, x0')\\n\\n model = symfit.Model({\\n x: a * y ** 2 + b * y + x0,\\n })\\n\\n # Apply fit on left\\n fit = symfit.Fit(model, x=xl, y=yl)\\n fit = fit.execute()\\n fit_vals.update({'al': fit.value(a), 'bl': fit.value(b), 'x0l': fit.value(x0)})\\n\\n # Apply fit on right\\n fit = symfit.Fit(model, x=xr, y=yr)\\n fit = fit.execute()\\n fit_vals.update({'ar': fit.value(a), 'br': fit.value(b), 'x0r': fit.value(x0)})\\n\\n return fit_vals\",\n \"def setHeuristics(self, fitwid, fitoff, bothpass, relht, relwid, reloff):\\n\\tself.fwidth = fitwid\\n\\tself.foffset = fitoff\\n\\tself.bothpass = bothpass\\n\\tself.rheight = relht\\n\\tself.rwidth = relwid\\n\\tself.roffset = reloff\",\n \"def expand(self, right=0, down=0, left=0, up=0):\\n self.min_col -= left\\n self.min_row -= up\\n self.max_col += right\\n self.max_row += down\",\n \"def expanded_boundaries(self):\\n width = self._points[0][3][0] - self._points[0][1][0]\\n height = self._points[0][3][1] - self._points[0][1][1]\\n factor = np.multiply((width, height), Window.BORDER)\\n return (\\n np.subtract(self._points[0][1], factor),\\n np.add(self._points[0][3], factor))\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def __call__(self, axes, renderer):\\n bbox0 = self.get_original_position(axes, renderer)\\n bbox = bbox0\\n\\n x1, y1, w, h = bbox.bounds\\n extesion_fraction = self.extesion_fraction\\n dw, dh = w*extesion_fraction, h*extesion_fraction\\n\\n if self.extend in [\\\"min\\\", \\\"both\\\"]:\\n if self.orientation == \\\"horizontal\\\":\\n x1 = x1 + dw\\n else:\\n y1 = y1+dh\\n\\n if self.extend in [\\\"max\\\", \\\"both\\\"]:\\n if self.orientation == \\\"horizontal\\\":\\n w = w-2*dw\\n else:\\n h = h-2*dh\\n\\n return Bbox.from_bounds(x1, y1, w, h)\",\n \"def _rect_right(self):\\n\\treturn max(self.x, self.x + self.w)\",\n \"def right(self):\\n return self.left + self.width\",\n \"def sidebyside(w1, w2, buffer=20):\\n import re\\n import warnings\\n # regex to extract the geometry\\n geore = re.compile(r'(\\\\d+)x(\\\\d+)([\\\\+-]\\\\d+)([\\\\+-]\\\\d+)')\\n\\n # First, get the geometry of w1\\n rematch = geore.match(w1.winfo_geometry())\\n if not rematch:\\n # We tried...\\n warnings.warn('Could not determine geometry of parent window!')\\n return\\n\\n w1_width, w1_height, w1_offsetx, w1_offsety = rematch.groups()\\n\\n # Now get w2's geometry\\n rematch = geore.match(w2.winfo_geometry())\\n if not rematch:\\n # We tried...\\n warnings.warn('Could not determine geometry of slave window!')\\n return\\n\\n w2_width, w2_height, w2_offsetx, w2_offsety = rematch.groups()\\n\\n # If the original x offset is - (i.e., closer to RHS of screen), put w2\\n # on the left. Otherwise, put it on the right\\n if w1_offsetx[0] is '-':\\n w2_offsetx = '-%d' % (int(w1_offsetx) - int(w1_width) - 20)\\n w2.geometry('%sx%s%s%s' % (w2_width, w2_height, w2_offsetx, w2_offsety))\\n else:\\n w2_offsetx = '+%d' % (int(w1_offsetx) + int(w1_width) + 20)\\n w2.geometry('%sx%s%s%s' % (w2_width, w2_height, w2_offsetx, w2_offsety))\",\n \"def go_right(self):\\n self.rect.centerx += 9\",\n \"def __scale_and_shift(self, image, landmarks, scale_range, output_size):\\n (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h) = self.get_bbox_of_landmarks(\\n image, landmarks, scale_range, shift_rate=0.3)\\n box_image = image[y1:y2, x1:x2]\\n if need_pad:\\n box_image = np.lib.pad(box_image, ((p_y, p_h), (p_x, p_w), (0, 0)), 'constant')\\n box_image = cv2.resize(box_image, (output_size, output_size))\\n landmarks = (landmarks - (x1 - p_x, y1 - p_y)) / (new_size, new_size)\\n return box_image, landmarks\",\n \"def pad(self):\\n if self._mg_problem.boundaries[0] == 'periodic':\\n # left side\\n self.left[:] = self.mid[-self.borders[0]:]\\n # right side\\n self.right[:] = self.mid[:self.borders[1]]\\n elif self._mg_problem.boundaries[0] == 'dirichlet':\\n\\n # left from border\\n l_f_b = self.space_tensor[0:self.borders[0]]\\n # right_from_border\\n r_f_b = self.space_tensor[-self.borders[1]:]\\n # left side\\n self.left[:] = self.fl(l_f_b)\\n # right side\\n self.right[:] = self.fr(r_f_b)\",\n \"def wheels(self, left, right):\\n\\t\\twith self.data_lock:\\n\\t\\t\\tself.leftSpeed \\t= left\\t/500.0\\t# leftSpeed and rightSpeed are in pixels per second\\n\\t\\t\\tself.rightSpeed = right\\t/500.0\",\n \"def adjust_visual(self):\\n\\n if (self.direction is bs.Direction.LEFT):\\n self.rect.x -= 0.5 * CELL_SIZE\",\n \"def scale(self):\",\n \"def custom_space(self, xleft, ytop, xright, ybottom,\\n lock_ratio=False):\\n\\n # basic info\\n bbox = xleft,ytop,xright,ybottom\\n x2x = (xleft,xright)\\n y2y = (ybottom,ytop)\\n xwidth = max(x2x)-min(x2x)\\n yheight = max(y2y)-min(y2y)\\n oldxwidth,oldyheight = xwidth,yheight\\n\\n # constrain the coordinate view ratio to the screen ratio, shrinking the coordinate space to ensure that it is fully contained inside the image\\n centered = affine.Affine.identity()\\n if lock_ratio:\\n # make coords same proportions as screen\\n screenxratio = self.width / float(self.height)\\n yheight = yheight\\n xwidth = yheight * screenxratio\\n # ensure that altered coords do not shrink the original coords\\n diffratio = 1.0\\n if xwidth < oldxwidth: diffratio = oldxwidth / float(xwidth)\\n elif yheight < oldyheight: diffratio = oldyheight / float(yheight)\\n xwidth *= diffratio\\n yheight *= diffratio\\n # move the center of focus to middle of coordinate space if view ratio has been constrained\\n xoff = (xwidth - oldxwidth) / 2.0\\n yoff = (yheight - oldyheight) / 2.0\\n centered *= affine.Affine.translate(xoff, yoff)\\n \\n # Note: The sequence of matrix multiplication is important and sensitive.\\n # ...see eg http://negativeprobability.blogspot.no/2011/11/affine-transformations-and-their.html\\n\\n # scale ie resize world to screen coords\\n scalex = self.width / float(xwidth)\\n scaley = self.height / float(yheight)\\n scaled = affine.Affine.scale(scalex,scaley)\\n if xleft < xright: xoff = -min(x2x)\\n else: xoff = min(x2x)\\n if ytop < ybottom: yoff = -min(y2y)\\n else: yoff = min(y2y)\\n scaled *= affine.Affine.translate(xoff,yoff) # to force anchor upperleft world coords to upper left screen coords\\n\\n # flip world coords if axes run in different direction than screen axes\\n xflip = xright < xleft\\n yflip = ybottom < ytop\\n if xflip: xflipoff = xwidth\\n else: xflipoff = 0\\n if yflip: yflipoff = yheight\\n else: yflipoff = 0\\n flipped = affine.Affine.translate(xflipoff,yflipoff) # to make the flipping stay in same place\\n flipped *= affine.Affine.flip(xflip,yflip)\\n\\n # calculate the final coefficients and set as the drawtransform\\n transcoeffs = (scaled * flipped * centered).coefficients\\n self.drawer.settransform(transcoeffs)\\n\\n # finally remember the new coordinate extents and affine matrix\\n self.coordspace_bbox = bboxhelper.resize_ratio(bbox,\\n xratio=xwidth / float(oldxwidth),\\n yratio=yheight / float(oldyheight) )\\n self.coordspace_transform = transcoeffs\",\n \"def _force_rescale(self, setpoint_x, setpoint_y):\",\n \"def fit_ms2(stack, min_distances=(70,50,50), sigma_small=1, \\n sigma_big=4, bg_radius=4, fitwindow_rad_xy=10, \\n fitwindow_rad_z=2):\\n\\n # Task: change size to minimum distance\\n def get_fitwindow(data, peak, xy_rad, z_rad):\\n \\\"\\\"\\\"Retrieve section of image stack corresponding to given\\n window around a point and the coordinate adjustments necessary\\n to convert window coordinates to coordinates in the original image\\\"\\\"\\\"\\n \\n # Set the start points for windows and \\\"adjust\\\" them if they get \\n # to negative numbers.\\n zmin = peak[0] - z_rad\\n xmin = peak[1] - xy_rad\\n ymin = peak[2] - xy_rad\\n # Initialize adjustments to values that are correct if no edge problems \\n # are encountered.\\n z_adj = -z_rad\\n x_adj = -xy_rad\\n y_adj = -xy_rad\\n # Update mins and adjustments if windows start at negative coordinates.\\n if (zmin < 0):\\n zmin = 0\\n z_adj = -peak[0]\\n if (xmin < 0):\\n xmin = 0\\n x_adj = -peak[1]\\n if (ymin < 0):\\n ymin = 0\\n y_adj = -peak[2]\\n\\n # Get end points, constained by max coordinate in data.\\n zmax = min(data.shape[0] - 1, peak[0] + z_rad)\\n xmax = min(data.shape[1] - 1, peak[1] + xy_rad)\\n ymax = min(data.shape[2] - 1, peak[2] + xy_rad)\\n\\n return (data[zmin:(zmax+1), xmin:(xmax+1), ymin:(ymax+1)], z_adj, x_adj, y_adj)\\n \\n def relabel(peak_ids, oldparams, mask):\\n \\\"\\\"\\\"Renumber labelmask and corresponding fit parameters\\n Set background as 0, objects in order 1...end.\\n \\\"\\\"\\\"\\n spot_data = {}\\n peak_num = 1\\n for peak in peak_ids:\\n #coords = np.where(mask == peak)\\n paramsnew = oldparams[peak-1,:] # object 1 will be fitparams row 0\\n # Rearrange params from fit function so coordinates lead.\\n spot_data[peak_num] = paramsnew[[1,2,3,0,4,5,6]]\\n peak_num = peak_num + 1\\n return spot_data\\n\\n def clamp(n, minn, maxn):\\n \\\"\\\"\\\"Bound a number between two constants\\\"\\\"\\\"\\n return max(min(maxn, n), minn)\\n \\n def fit_frame(substack, min_distances, sigma_small, \\n sigma_big, bg_radius, fitwindow_rad_xy, \\n fitwindow_rad_z):\\n \\\"\\\"\\\"Perform 3D gaussian fitting on a 3D image stack.\\\"\\\"\\\"\\n\\n # Filter and background subtract image.\\n dog = dog_filter(substack, sigma_small, sigma_big)\\n bg = ndi.filters.minimum_filter(dog, bg_radius)\\n dog_bs = dog - bg\\n\\n # Make a labelmask corresponding to local maxima peaks.\\n peak_window_size = (min_distances[0] * 2 + 1, min_distances[1] * 2 + 1, min_distances[2] * 2 + 1)\\n mask, peaks = peak_local_max_nD(dog_bs, peak_window_size)\\n\\n # Fit 3D gaussian in window surrounding each local maximum.\\n fitparams = np.ndarray((0,7))\\n for peak in peaks:\\n fitwindow, z_adj, x_adj, y_adj = get_fitwindow(substack, peak, fitwindow_rad_xy, \\n fitwindow_rad_z)\\n opt = fitgaussian3d(fitwindow)\\n if opt.success:\\n peak_fitparams = opt.x\\n # Move center coordinates to match center of gaussian fit, ensure they're within image. \\n # If they're outside the image, coordinate is assigned as the edge of the image.\\n peak_fitparams[0] = int(round(clamp((peak[0] + peak_fitparams[0] + z_adj), 0, substack.shape[-3]-1)))\\n peak_fitparams[1] = int(round(clamp((peak[1] + peak_fitparams[1] + x_adj), 0, substack.shape[-2]-1)))\\n peak_fitparams[2] = int(round(clamp((peak[2] + peak_fitparams[2] + y_adj), 0, substack.shape[-1]-1)))\\n fitparams = np.vstack((fitparams, peak_fitparams))\\n # If fit fails, add dummy entry for spot.\\n else:\\n fitparams = np.vstack((fitparams, np.array([z_adj,x_adj,y_adj,0,np.inf,np.inf,np.inf])))\\n return fitparams\\n \\n #### Main ####\\n # Do fitting on first frame.\\n fit_data_frame0 = fit_frame(stack[0], min_distances, sigma_small, \\n sigma_big, bg_radius, fitwindow_rad_xy, \\n fitwindow_rad_z)\\n # Make fit_data a list of ndarrays.\\n fit_data = [fit_data_frame0]\\n \\n # Fit the rest of the frames, add their data to fit_data.\\n for i in range(1, stack.shape[0]):\\n print(i, end=' ')\\n fit_data_thisframe = fit_frame(stack[i], min_distances, sigma_small, \\n sigma_big, bg_radius, fitwindow_rad_xy, \\n fitwindow_rad_z)\\n fit_data.append(fit_data_thisframe)\\n \\n return fit_data\",\n \"def flip(self):\\n self.align = self._left if self.align == self._right else self._right\\n self.group.layout_all()\",\n \"def _align_toplevel_grid(self):\\n\\n # align origin with nearest multple of 128\\n self.mins[0] -= self.mins[0] % 128\\n self.mins[1] -= self.mins[1] % 128\\n\\n width = self.maxs[0] - self.mins[0]\\n height = self.maxs[1] - self.mins[1]\\n greatest_dim = max(width, height)\\n nearest_pow_two = int(2 ** np.ceil(np.log2(greatest_dim)))\\n width_adjustment = (nearest_pow_two - width)\\n height_adjustment = (nearest_pow_two - height)\\n\\n self.maxs[0] += width_adjustment\\n self.maxs[1] += height_adjustment\",\n \"def toFit(curr_width, curr_height, bounds_width, bounds_height):\\n\\n\\t# Return\\n\\tlRet\\t= [0,0]\\n\\n\\t# Convert current width/height to floats\\n\\tcurr_width\\t\\t= float(curr_width)\\n\\tcurr_height\\t\\t= float(curr_height)\\n\\n\\t# If either width or height is smaller than the boundary box, resize up\\n\\tif curr_width < bounds_width and curr_height < bounds_height:\\n\\n\\t\\t# Which is the side that needs to grow less?\\n\\t\\tif (bounds_width / curr_width) > (bounds_height / curr_height):\\n\\t\\t\\tlRet[1]\\t= bounds_height\\n\\t\\t\\tlRet[0]\\t= int(round(bounds_height * (curr_width / curr_height)))\\n\\t\\telse:\\n\\t\\t\\tlRet[0]\\t= bounds_width\\n\\t\\t\\tlRet[1]\\t= int(round(bounds_width * (curr_height / curr_width)))\\n\\n\\t# Else if the image is already larger than the boundary, resize down\\n\\telse:\\n\\n\\t\\t# Which is the side that needs to shrink more?\\n\\t\\tif (curr_width / bounds_width) > (curr_height / bounds_height):\\n\\t\\t\\tlRet[0]\\t= bounds_width\\n\\t\\t\\tlRet[1]\\t= int(round(bounds_width * (curr_height / curr_width)))\\n\\t\\telse:\\n\\t\\t\\tlRet[1]\\t= bounds_height\\n\\t\\t\\tlRet[0]\\t= int(round(bounds_height * (curr_width / curr_height)))\\n\\n\\t# Return the new dimensions\\n\\treturn lRet\",\n \"def setFitMethod(self,method = RESIZE):\",\n \"def make_empty_right(self, e=0):\\n self.make_empty_side(u'right')\",\n \"def set_xlim(self, left=None, right=None):\\n if right is None and np.iterable(left):\\n left, right = left\\n\\n if left is None or right is None:\\n old_left, old_right = self.get_xlim()\\n if left is None:\\n left = old_left\\n if right is None:\\n right = old_right\\n\\n if left == right:\\n warnings.warn(\\n \\\"Attempting to set identical left == right == {} x-axis limits\\\".format(\\n left\\n ),\\n stacklevel=2,\\n )\\n\\n if left > right:\\n raise ValueError(\\\"Axis limits must be in increasing order\\\")\\n\\n if right <= 0 and self._logx:\\n warnings.warn(\\n \\\"Attempting to set non-positive right xlim on a log-scaled axis.\\\\n\\\"\\n \\\"Invalid limit will be ignored.\\\",\\n stacklevel=2,\\n )\\n right = self.get_xlim()[1]\\n\\n elif left <= 0 and self._logx:\\n warnings.warn(\\n \\\"Attempting to set non-positive left xlim on a log-scaled axis.\\\\n\\\"\\n \\\"Invalid limit will be ignored.\\\",\\n stacklevel=2,\\n )\\n left = self.get_xlim()[0]\\n\\n if isinstance(self._frame, root.TH1F):\\n self._frame.GetXaxis().SetLimits(left, right)\\n else:\\n self._frame.GetXaxis().SetRangeUser(left, right)\\n\\n self._pad.Modified() # Draw the updated axes\\n\\n return (left, right)\",\n \"def create_right_left_containers(self) -> None:\\n self.frame_left = tk.Frame(self, borderwidth=5, relief=tk.GROOVE)\\n self.frame_left.grid(row=0, column=0)\\n # self.window_left_info = None\\n self.frame_right = tk.Frame(self, borderwidth=5, relief=tk.GROOVE)\\n self.frame_right.grid(row=0, column=1)\",\n \"def measure_offset(self, left_fit, right_fit):\\n xm_per_pix = 3.7 / 130 # meters per pixel in x dimension\\n y_val = self.warped_image_size[1] / 2\\n # Camera is not exactly on center of car so we need to compensate it with this number\\n # It is calculated by measuring the center of lane from \\\"straight_lines1.jpg\\\"\\n x_correction = -67\\n base_leftx = left_fit[0] * y_val ** 2 + left_fit[1] * y_val + left_fit[2]\\n base_rightx = right_fit[0] * y_val ** 2 + right_fit[1] * y_val + right_fit[2]\\n\\n # Calculate image x-center (TODO: This calculation should be somewhere else. Not reasonable to calculate on every iteration.)\\n center_of_image = self.warped_image_size[0] / 2.\\n # Measured center and real offset calculations\\n measured_center = base_leftx + (base_rightx - base_leftx) + x_correction\\n measured_offset = (center_of_image - measured_center) * xm_per_pix\\n return measured_offset\",\n \"def stretch(self, x_stretch=1, y_stretch=1):\\n self.width *= x_stretch\\n self.height *= y_stretch\\n\\n # Always update the corners after operation\\n self.update_corners()\\n return\",\n \"def set_relative_viewbox(self, x0, y0, x1, y1):\\n # prevent too small zoombox\\n if (np.abs(x1 - x0) < .07) & (np.abs(y1 - y0) < .07):\\n return\\n # force the zoombox to keep its original ratio\\n if self.parent.constrain_ratio:\\n x0, y0, x1, y1 = self.constrain_viewbox(x0, y0, x1, y1)\\n if (x1-x0) and (y1-y0):\\n self.tx += -(x1+x0)/(2*self.sx)\\n self.ty += -(y1+y0)/(2*self.sy)\\n self.sx *= 2./abs(x1-x0)\\n self.sy *= 2./abs(y1-y0)\\n self.sxl, self.syl = self.sx, self.sy\",\n \"def display_right_to_left(self):\\n return self.container['display_right_to_left']\",\n \"def _resize_interval(start, end, size):\\n center = int(0.5 * (start + end))\\n half_size = int(0.5 * size)\\n left = center - half_size\\n right = left + size\\n return left, right\",\n \"def _rect_left(self):\\n\\treturn min(self.x, self.x + self.w)\",\n \"def right_or_left(self):\\n self.scan()\\n\\n max = 0\\n side = 'l'\\n\\n #analyze scan results\\n for angle in self.scan_data:\\n #RIGHT SIDE\\n if angle < self.MIDPOINT:\\n if self.scan_data[angle] > max:\\n max = self.scan_data[angle]\\n side = 'r'\\n #LEFT SIDE\\n else:\\n if self.scan_data[angle] > max:\\n max = self.scan_data[angle]\\n side = 'l'\\n\\n return side\",\n \"def __init__(self, top_left, bottom_right, keep_aspect=True, fix_axis=None):\\n super().__init__(top_left, bottom_right, keep_aspect=keep_aspect, fix_axis=fix_axis, margins=margins)\",\n \"def _overlay_ref_fit(self, img, mean, fit, off=25):\\n\\n def plus(img, x, y, val=0, r=10):\\n img[x - 1:x, y - r:y + r], img[x - r:x + r, y - 1:y] = val, val\\n return img\\n\\n if len(self.refzone) != 4:\\n return img\\n\\n centers = [(self.ref_rc[0] - off, self.ref_rc[1] - off),\\n (self.ref_rc[0] - off, self.ref_rc[1] + off),\\n (self.ref_rc[0] + off, self.ref_rc[1] - off),\\n (self.ref_rc[0] + off, self.ref_rc[1] + off)]\\n\\n img = plus(img, self.ref_rc[0], self.ref_rc[1], val=150, r=15) # final mean offset\\n img = plus(img, self.ref_rc[0] + mean[0], self.ref_rc[1] + mean[1], val=0)\\n for [x0, x1, y0, y1], [x_off, y_off], (cx, cy) in zip(self.refzone, fit, centers):\\n img = plus(img, cx, cy, val=120, r=15) # panel fitted\\n img = plus(img, cx + x_off, cy + y_off, val=0) # panel reference\\n img = plus(img, x0, y0, val=150) # expected reference\\n img = plus(img, x1, y1, val=150) #\\n img = plus(img, x0 + x_off, y0 + y_off, val=0) # actual fitted\\n img = plus(img, x1 + x_off, y1 + y_off, val=0) #\\n\\n return img\",\n \"def set_tight_lims(data_x, data_y, center_x=None, center_y=None,\\n mode='symmetric', buf=0.3):\\n ax = plt.gca()\\n\\n if center_x is None:\\n maxx = max(data_x)\\n minx = min(data_x)\\n sepx = maxx - minx\\n maxx = maxx + buf * sepx\\n minx = minx - buf * sepx\\n ax.set_xlim((minx, maxx))\\n else:\\n distx = data_x - center_x\\n maxx = max(max(distx), 0)\\n minx = min(min(distx), 0)\\n if mode == 'symmetric':\\n limx = max(abs(maxx), abs(minx))\\n limx = limx + buf * limx\\n ax.set_xlim((center_x - limx, center_x + limx))\\n elif mode == 'tight':\\n maxx = maxx + buf * maxx if maxx != 0 else -buf * minx\\n minx = minx + buf * minx if minx != 0 else -buf * maxx\\n ax.set_xlim((center_x + minx, center_x + maxx))\\n\\n if center_y is None:\\n maxy = max(data_y)\\n miny = min(data_y)\\n sepy = maxy - miny\\n maxy = maxy + buf * sepy\\n miny = miny - buf * sepy\\n ax.set_ylim((miny, maxy))\\n else:\\n disty = data_y - center_y\\n maxy = max(max(disty), 0)\\n miny = min(min(disty), 0)\\n if mode == 'symmetric':\\n limy = max(abs(maxy), abs(miny))\\n limy = limy + buf * limy\\n ax.set_ylim((center_y - limy, center_y + limy))\\n elif mode == 'tight':\\n maxy = maxy + buf * maxy if maxy != 0 else -buf * miny\\n miny = miny + buf * miny if miny != 0 else -buf * maxy\\n ax.set_ylim((center_y + miny, center_y + maxy))\",\n \"def positive_left_right_requirements(\\n self,\\n ) -> Tuple[Tuple[GriddedPerm, ...], Tuple[GriddedPerm, ...]]:\\n left, right = [], []\\n for (x, y) in self._tiling.active_cells:\\n if self._fuse_row and y == self._row_idx:\\n left.append(GriddedPerm.single_cell((0,), (x, y)))\\n right.append(GriddedPerm.single_cell((0,), (x, y + 1)))\\n if not self._fuse_row and x == self._col_idx:\\n left.append(GriddedPerm.single_cell((0,), (x, y)))\\n right.append(GriddedPerm.single_cell((0,), (x + 1, y)))\\n return tuple(sorted(left)), tuple(sorted(right))\",\n \"def align(self):\\n ...\",\n \"def project_grid(self):\\n\\n # option 1: no shared axes. Trees are scaled(?)\\n\\n\\n # option 2: shared axes. Spacing of tree\",\n \"def inner_fit(self):\\n pass\",\n \"def inner_fit(self):\\n pass\",\n \"def test_fit(self, fit: str, baseline_images):\\n fig = plt.figure()\\n ax = fig.add_subplot(projection=\\\"ternary\\\")\\n tn0, tn1, tn2 = get_spiral()\\n ax.plot(tn0, tn1, tn2, \\\"C0\\\")\\n ax.plot(tn0, tn1, tn2, \\\"k\\\", transform=ax.transTernaryAxes)\\n ax.set_facecolor(\\\"0.9\\\")\\n ax.grid(True)\\n ax.set_ternary_lim(0.1, 0.7, 0.1, 0.6, 0.1, 0.5, fit)\",\n \"def set_viewbox(self, x0, y0, x1, y1):\\n # force the zoombox to keep its original ratio\\n if self.parent.constrain_ratio:\\n x0, y0, x1, y1 = self.constrain_viewbox(x0, y0, x1, y1)\\n if (x1-x0) and (y1-y0):\\n self.tx = -(x1+x0)/2\\n self.ty = -(y1+y0)/2\\n self.sx = 2./abs(x1-x0)\\n self.sy = 2./abs(y1-y0)\\n self.sxl, self.syl = self.sx, self.sy\",\n \"def leftToRight(self):\\n self.displaymode |= self.LCD_ENTRYLEFT\\n self.write_lcd(self.LCD_DATA_E1, self.LCD_ENTRYMODESET | self.displaymode)\\n self.write_lcd(self.LCD_DATA_E2, self.LCD_ENTRYMODESET | self.displaymode)\",\n \"def xlim(self, left=None, right=None):\\r\\n for ax in self._subaxes:\\r\\n ax.set_xlim(left, right)\\r\\n self.figure.canvas.draw()\",\n \"def calculate_coordinates(self):\\n # get coordinates for lef side of equation\\n self._calculate_for_one_side(self.left_side)\\n\\n # set process glyph x coordinate\\n self.process_glyph_x = self.x_limit + 150\\n\\n self._calculate_for_one_side(self.right_side, side=\\\"right_side\\\")\\n\\n self.x_limit, self.y_limit = self._generate_real_coordinates_according_to_compartment()\\n\\n # set process glyph y coordinate\\n self.process_glyph_y = self.y_limit / 2\\n\\n # set final image width, height\\n self.x_limit += 10\\n self.y_limit += 20\",\n \"def get_best_fit(self, binary_warped):\\r\\n # print('smart fit')\\r\\n left_fit, right_fit = self.fit_dict['left_fit'], self.fit_dict['right_fit']\\r\\n nonzero = binary_warped.nonzero()\\r\\n nonzeroy = np.array(nonzero[0])\\r\\n nonzerox = np.array(nonzero[1])\\r\\n margin = 100\\r\\n minpix = 5000\\r\\n left_lane_inds = (\\r\\n (nonzerox > (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) & (\\r\\n nonzerox < (left_fit[0] * (nonzeroy ** 2) + left_fit[1] * nonzeroy + left_fit[2] + margin)))\\r\\n right_lane_inds = (\\r\\n (nonzerox > (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) & (\\r\\n nonzerox < (right_fit[0] * (nonzeroy ** 2) + right_fit[1] * nonzeroy + right_fit[2] + margin)))\\r\\n\\r\\n if len(left_lane_inds.nonzero()[0]) < minpix or len(right_lane_inds.nonzero()[0]) < minpix:\\r\\n self.apply_sliding_window_flag = True\\r\\n return self.get_best_fit_using_sliding_window(binary_warped)\\r\\n # Again, extract left and right line pixel positions\\r\\n leftx = nonzerox[left_lane_inds]\\r\\n lefty = nonzeroy[left_lane_inds]\\r\\n rightx = nonzerox[right_lane_inds]\\r\\n righty = nonzeroy[right_lane_inds]\\r\\n\\r\\n if not self.check_valid_params(leftx, lefty, rightx, righty):\\r\\n self.apply_sliding_window_flag = True\\r\\n return self.get_best_fit_using_sliding_window(binary_warped)\\r\\n # Fit a second order polynomial to each\\r\\n left_fit = np.polyfit(lefty, leftx, 2)\\r\\n right_fit = np.polyfit(righty, rightx, 2)\\r\\n self.fit_dict['left_fit'], self.fit_dict['right_fit'] = left_fit, right_fit\\r\\n left_curve_rad, right_curve_rad, vehicle_offset = self.compute_lane_statistics(binary_warped)\\r\\n self.fit_dict['left_curve_rad'], self.fit_dict['right_curve_rad'] = left_curve_rad, right_curve_rad\\r\\n self.fit_dict['vehicle_offset'] = vehicle_offset\\r\\n self.result_buffer.append(self.fit_dict.copy())\\r\\n return\",\n \"def box_function(width_left, width_right, shift, sigma, x):\\n\\n prefactor = 2.0 * 0.25\\n left = erf( (1.0/width_left * x + 1.0/width_left * shift + 1.0) / ( sigma * math.sqrt(2.0)) )\\n right = erf( (1.0/width_right * x + 1.0/width_right * shift - 1.0) / ( sigma * math.sqrt(2.0)) )\\n\\n return prefactor * (left - right)\",\n \"def swap_main(self):\\n if self.align == self._left:\\n self.swap_left()\\n elif self.align == self._right:\\n self.swap_right()\",\n \"def pad(self, left=0, top=0, bottom=0, right=0):\\n\\n self.x -= left\\n self.y -= top\\n self.width += left + right\\n self.height += top + bottom\",\n \"def extent(self):\\n left = self.transform[0]\\n right = left + self.transform[1] * self.shape[1]\\n top = self.transform[3]\\n bottom = top + self.transform[5] * self.shape[0]\\n return left, right, bottom, top\",\n \"def bounds(self) -> tuple[float, float, float, float]:\\n transform = self.transform\\n a, b, c, d, e, f, _, _, _ = transform\\n if b == d == 0:\\n xs = (c, c + a * self.width)\\n ys = (f, f + e * self.height)\\n else: # rotated\\n c0x, c0y = c, f\\n c1x, c1y = transform * (0, self.height)\\n c2x, c2y = transform * (self.width, self.height)\\n c3x, c3y = transform * (self.width, 0)\\n xs = (c0x, c1x, c2x, c3x)\\n ys = (c0y, c1y, c2y, c3y)\\n return min(xs), min(ys), max(xs), max(ys)\",\n \"def updateHeight(self):\\n leftHeight = self.left.height if self.left != None else 0\\n rightHeight = self.right.height if self.right != None else 0\\n self.height = max(rightHeight, leftHeight) + 1\",\n \"def grow_right(self, width, height):\\r\\n old_self = copy.copy(self)\\r\\n self.used = True\\r\\n self.x = self.y = 0\\r\\n self.width += width\\r\\n self.down = old_self\\r\\n self.right = SquareAlgorithmNode(x=old_self.width,\\r\\n y=0,\\r\\n width=width,\\r\\n height=self.height)\\r\\n\\r\\n node = self.find(self, width, height)\\r\\n if node:\\r\\n return self.split(node, width, height)\\r\\n return None\",\n \"def get_rightmost_edge(self):\\n return self.offset + sum(self.get_screen_widths())\",\n \"def xlim(left=None, right=None):\\n impl.xlim(**locals())\",\n \"def _configure_right(self, client, index):\\n widths = self._get_secondary_widths()\\n height = self._get_secondary_height(index)\\n left = self.screen_rect.x + widths[0] + self._get_main_width()\\n top = self.screen_rect.y + self._get_relative_sizes_above(index)\\n\\n self._place_client(client, left, top, widths[1], height)\",\n \"def setAxisParts(lowx='all', lefty='all', upx='ticks', righty='ticks'):\\n partdict = {'none':'NONE','lines':'LINE','ticks':'TICKS',\\n 'labels':'LABELS', 'all':'NAME'} \\n dislin.setgrf(partdict[lowx], partdict[lefty],\\\\\\n partdict[upx], partdict[righty])\",\n \"def set_lanes(left_lines, right_lines, image):\\n \\n Y_LANE_EXTRAP = 35 # percent up from bottom of image to extrapolate lane lines\\n \\n image_wk = np.copy(image) # working copy\\n image_lines = np.copy(image_wk)*0 # create a blank to draw lines on\\n im_y = image_wk.shape[0]\\n \\n y1_lane = im_y\\n y2_lane = np.int32(im_y - (Y_LANE_EXTRAP/100*im_y))\\n \\n # Process left lane\\n if left_lines:\\n z_left = my_linear_polyfit(left_lines)\\n x1_lane = np.int32( (y1_lane - z_left[1]) / z_left[0] ) # x = (y-b)/m\\n x2_lane = np.int32( (y2_lane - z_left[1]) / z_left[0] )\\n \\n # Draw left lane on blank image\\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\\n \\n # Process right lane\\n if right_lines:\\n z_right = my_linear_polyfit(right_lines)\\n x1_lane = np.int32( (y1_lane - z_right[1]) / z_right[0] ) # x = (y-b)/m\\n x2_lane = np.int32( (y2_lane - z_right[1]) / z_right[0] )\\n \\n # Draw right lane on blank image\\n cv2.line(image_lines, (x1_lane, y1_lane), (x2_lane, y2_lane), (100,100,100), 15)\\n \\n # Overlay detected left/right lanes on road image\\n image_wk = weighted_img(image_lines, image_wk)\\n \\n # Output road image with overlaid left/right lanes\\n return image_wk\",\n \"def midright(self):\\n return (self.right, self.centery)\",\n \"def annotate(self, left_right=True, positions=True, size=12, **kwargs):\\n kwargs = kwargs.copy()\\n if not 'color' in kwargs:\\n if self._black_bg:\\n kwargs['color'] = 'w'\\n else:\\n kwargs['color'] = 'k'\\n\\n bg_color = ('k' if self._black_bg else 'w')\\n if left_right:\\n for cut_ax in self.axes.values():\\n cut_ax.draw_left_right(size=size, bg_color=bg_color,\\n **kwargs)\\n\\n if positions:\\n for cut_ax in self.axes.values():\\n cut_ax.draw_position(size=size, bg_color=bg_color,\\n **kwargs)\",\n \"def build_filler_images(self):\",\n \"def resize_to_fit(self, bbox_lower, bbox_upper, padding=0.0):\\n lower_offset = np.array((padding, padding, 0.0))\\n self.lower_vertex = bbox_lower - lower_offset\\n upper_offset = np.array([padding] * 3)\\n self.upper_vertex = bbox_upper + upper_offset\",\n \"def increase_left_boundary(self):\\n self.L = self.L - 1.0\\n self.Ne = self.Ne + 1\",\n \"def _texture_fit(\\n self,\\n side: Side,\\n tex_size: float,\\n field_length: float,\\n fizz: Fizzler,\\n neg: Vec,\\n pos: Vec,\\n is_laserfield: bool = False,\\n ) -> None:\\n # Compute the orientations that are up and along the fizzler.\\n side.uaxis.x, side.uaxis.y, side.uaxis.z = fizz.forward()\\n side.vaxis.x, side.vaxis.y, side.vaxis.z = -fizz.up_axis\\n\\n side.uaxis.offset = -(tex_size / field_length) * neg.dot(side.uaxis.vec())\\n side.vaxis.offset = -(tex_size / 128) * neg.dot(side.vaxis.vec())\\n\\n # The above fits it correctly, except it's vertically half-offset.\\n # For laserfields that's what we want, for fizzlers we want it normal.\\n if not is_laserfield:\\n side.vaxis.offset += tex_size / 2\\n\\n side.uaxis.scale = field_length / tex_size\\n side.vaxis.scale = 128 / tex_size\\n\\n side.uaxis.offset %= tex_size\\n side.vaxis.offset %= tex_size\",\n \"def right_option():\\n active = get_active_window()\\n Width=get_corner_Width(active)\\n Height=get_middle_Height()\\n PosX = get_right_PosX(active,Width)\\n PosY=get_middle_PosY()\\n move_window(active,PosX,PosY,Width,Height)\\n raise_window(active)\",\n \"def _boundRect(self):\\n self.upperleft = list(map(min, zip(*self.addresstamp)))\\n self.bottomright = list(map(max, zip(*self.addresstamp)))\\n self.upperright = [self.bottomright[0], self.upperleft[1]]\\n self.bottomleft = [self.upperleft[0], self.bottomright[1]]\\n (self.width, self.height) = (self.upperright[0] - self.bottomleft[0], self.bottomleft[1] - self.upperright[1])\\n assert self.width >= 0\\n assert self.height >= 0\\n self.center = [self.upperleft[0] + self.width / float(2), self.upperleft[1] + self.height / float(2)]\\n self.corners = [self.upperright, self.bottomleft, self.upperleft, self.bottomright]\",\n \"def get_bbox_of_landmarks(self, image, landmarks, scale_range, shift_rate=0.3):\\n ori_h, ori_w = image.shape[:2]\\n x = int(min(landmarks[:, 0]))\\n y = int(min(landmarks[:, 1]))\\n w = int(max(landmarks[:, 0]) - x)\\n h = int(max(landmarks[:, 1]) - y)\\n if type(scale_range) == float:\\n scale = scale_range\\n else:\\n scale = np.random.randint(int(scale_range[0] * 100.0), int(scale_range[1] * 100.0)) / 100.0\\n new_size = int(max(w, h) * scale)\\n if shift_rate >= 0.5:\\n x1 = x - (new_size - w) / 2\\n y1 = y - (new_size - h) / 2\\n else:\\n x1 = x - np.random.randint(int((new_size - w) * shift_rate), int((new_size - w) * (1.0 - shift_rate)))\\n y1 = y - np.random.randint(int((new_size - w) * shift_rate), int((new_size - w) * (1.0 - shift_rate)))\\n x2 = x1 + new_size\\n y2 = y1 + new_size\\n need_pad = False\\n p_x, p_y, p_w, p_h = 0, 0, 0, 0\\n if x1 < 0:\\n p_x = -x1\\n x1 = 0\\n need_pad = True\\n if y1 < 0:\\n p_y = -y1\\n y1 = 0\\n need_pad = True\\n if x2 > ori_w:\\n p_w = x2 - ori_w\\n x2 = ori_w\\n need_pad = True\\n if y2 > ori_h:\\n p_h = y2 - ori_h\\n y2 = ori_h\\n need_pad = True\\n\\n return (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h)\",\n \"def _locator(self, axes, renderer):\\n x0, y0, x1, y1 = self.rect\\n width_dict = dict()\\n cut_ax_dict = self.axes\\n for cut_ax in cut_ax_dict.values():\\n bounds = cut_ax.get_object_bounds()\\n if not bounds:\\n # This happens if the call to _map_show was not\\n # succesful. As it happens asyncroniously (during a\\n # refresh of the figure) we capture the problem and\\n # ignore it: it only adds a non informative traceback\\n bounds = [0, 1, 0, 1]\\n xmin, xmax, ymin, ymax = bounds\\n width_dict[cut_ax.ax] = (xmax - xmin)\\n total_width = float(sum(width_dict.values()))\\n for ax, width in width_dict.items():\\n width_dict[ax] = width/total_width*(x1 -x0)\\n left_dict = dict()\\n left = float(x0)\\n for coord, cut_ax in sorted(cut_ax_dict.items()):\\n left_dict[cut_ax.ax] = left\\n this_width = width_dict[cut_ax.ax]\\n left += this_width\\n return transforms.Bbox([[left_dict[axes], y0],\\n [left_dict[axes] + width_dict[axes], y1]])\",\n \"def fill_box(self, x, y, w, h):\\n\\t\\tpass\",\n \"def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False):\\n\\n assert mode in ['iou', 'iof']\\n\\n rows = bboxes1.size(0)\\n cols = bboxes2.size(0)\\n if is_aligned:\\n assert rows == cols\\n\\n if rows * cols == 0:\\n return bboxes1.new(rows, 1) if is_aligned else bboxes1.new(rows, cols)\\n\\n if is_aligned:\\n lt = torch.max(bboxes1[:, :2], bboxes2[:, :2]) # [rows, 2]\\n rb = torch.min(bboxes1[:, 2:], bboxes2[:, 2:]) # [rows, 2]\\n\\n wh = (rb - lt + 1).clamp(min=0) # [rows, 2]\\n overlap = wh[:, 0] * wh[:, 1]\\n area1 = (bboxes1[:, 2] - bboxes1[:, 0] + 1) * (\\n bboxes1[:, 3] - bboxes1[:, 1] + 1)\\n\\n if mode == 'iou':\\n area2 = (bboxes2[:, 2] - bboxes2[:, 0] + 1) * (\\n bboxes2[:, 3] - bboxes2[:, 1] + 1)\\n ious = overlap / (area1 + area2 - overlap)\\n else:\\n ious = overlap / area1\\n else:\\n # not aligned boxes are usually used for assigners,\\n # because assigners need to know all the overlaps between every bbox and every gtbox\\n \\n # none add a new axis ag: [3,4] => [3, 1, 4] \\n # torch.max will broadcast: 3 1 4, 5 4 => 3 5 4\\n lt = torch.max(bboxes1[:, None, :2], bboxes2[:, :2]) # [rows, cols, 2]\\n rb = torch.min(bboxes1[:, None, 2:], bboxes2[:, 2:]) # [rows, cols, 2]\\n\\n wh = (rb - lt + 1).clamp(min=0) # [rows, cols, 2]\\n overlap = wh[:, :, 0] * wh[:, :, 1]\\n area1 = (bboxes1[:, 2] - bboxes1[:, 0] + 1) * (\\n bboxes1[:, 3] - bboxes1[:, 1] + 1)\\n\\n if mode == 'iou':\\n area2 = (bboxes2[:, 2] - bboxes2[:, 0] + 1) * (\\n bboxes2[:, 3] - bboxes2[:, 1] + 1)\\n ious = overlap / (area1[:, None] + area2 - overlap)\\n else:\\n ious = overlap / (area1[:, None])\\n\\n return ious\",\n \"def raw_resolution(resolution, splitter=False):\\n width, height = resolution\\n if splitter:\\n fwidth = (width + 15) & ~15\\n else:\\n fwidth = (width + 31) & ~31\\n fheight = (height + 15) & ~15\\n return fwidth, fheight\",\n \"def _do_layout(self):\\n if self.stack_order == \\\"bottom_to_top\\\":\\n components = (self.zoomed_plot, self.reference_plot)\\n relative_sizes = (4 / 3., 2 / 3.)\\n else:\\n components = (self.reference_plot, self.zoomed_plot)\\n relative_sizes = (2 / 3., 4 / 3.)\\n if self.halign == \\\"left\\\":\\n align = \\\"min\\\"\\n elif self.halign == \\\"center\\\":\\n align = \\\"center\\\"\\n else:\\n align = \\\"max\\\"\\n #import pdb; pdb.set_trace()\\n return self._do_stack_layout(components, relative_sizes, align)\",\n \"def go_right(self):\\n self.rect.centerx += self.__dx\",\n \"def bbox_rel(image_width, image_height, *xyxy):\\n\\tbbox_left = min([xyxy[0].item(), xyxy[2].item()])\\n\\tbbox_top = min([xyxy[1].item(), xyxy[3].item()])\\n\\tbbox_w = abs(xyxy[0].item() - xyxy[2].item())\\n\\tbbox_h = abs(xyxy[1].item() - xyxy[3].item())\\n\\tx_c = (bbox_left + bbox_w / 2)\\n\\ty_c = (bbox_top + bbox_h / 2)\\n\\tw = bbox_w\\n\\th = bbox_h\\n\\treturn x_c, y_c, w, h\",\n \"def makeLeftRightline(self):\\r\\n left_lines = []\\r\\n right_lines = []\\r\\n for i in self.lines:\\r\\n for x1,y1,x2,y2 in i:\\r\\n if x1 == x2:\\r\\n #Vertical Lines\\r\\n pass\\r\\n else:\\r\\n m = (y2 - y1) / (x2 - x1)\\r\\n c = y1 - m * x1\\r\\n if m < 0:\\r\\n left_lines.append((m,c))\\r\\n elif m >= 0:\\r\\n right_lines.append((m,c))\\r\\n return left_lines,right_lines\",\n \"def setRect(self, p_float, p_float_1, p_float_2, p_float_3): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def box(self, x, y, w, h):\\n\\t\\tpass\",\n \"def adjust_left_right_positions():\\n # bp_* is synonym for 'Best Position Left/Right' and are adjusted \\n # to optimize bmv_*\\n p_l, bp_l = [pos] * 2\\n p_r, bp_r = [pos + qlen] * 2\\n\\n # bmv_* are declared here in case they are untouched in optimization\\n bmv_l = match_values[p_l / step]\\n bmv_r = match_values[p_l / step]\\n\\n for f in range(flex):\\n ll = _match(query, corpus[p_l - f: p_r])\\n if ll > bmv_l:\\n bmv_l = ll\\n bp_l = p_l - f\\n\\n lr = _match(query, corpus[p_l + f: p_r])\\n if lr > bmv_l:\\n bmv_l = lr\\n bp_l = p_l + f\\n\\n rl = _match(query, corpus[p_l: p_r - f])\\n if rl > bmv_r:\\n bmv_r = rl\\n bp_r = p_r - f\\n\\n rr = _match(query, corpus[p_l: p_r + f])\\n if rr > bmv_r:\\n bmv_r = rr\\n bp_r = p_r + f\\n\\n if verbose:\\n print(\\\"\\\\n\\\" + str(f))\\n print(\\\"ll: -- value: %f -- snippet: %s\\\" % (ll, corpus[p_l - f: p_r]))\\n print(\\\"lr: -- value: %f -- snippet: %s\\\" % (lr, corpus[p_l + f: p_r]))\\n print(\\\"rl: -- value: %f -- snippet: %s\\\" % (rl, corpus[p_l: p_r - f]))\\n print(\\\"rr: -- value: %f -- snippet: %s\\\" % (rl, corpus[p_l: p_r + f]))\\n\\n return bp_l, bp_r, _match(query, corpus[bp_l : bp_r])\",\n \"def draw(self, binary, leftx, rightx):\\n\\t\\tfilled = np.zeros_like(binary)\\n\\t\\tploty = np.linspace(0, filled.shape[0] - 1, filled.shape[0])\\n\\t\\t# Recast the x and y points into usable format for cv2.fillpoly()\\n\\t\\tpts_left = np.array([np.transpose(np.vstack([leftx, ploty]))])\\n\\t\\tpts_right = np.array([np.flipud(np.transpose(np.vstack([rightx, ploty])))])\\n\\t\\tpts = np.hstack((pts_left, pts_right))\\n\\t\\t# Draw the lane onto the warped blank image\\n\\t\\tcv2.fillPoly(filled, np.int_([pts]), (0, 255, 0))\\n\\t\\treturn filled\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5895596","0.5836528","0.5623411","0.55394584","0.5525405","0.5424819","0.53840476","0.53774345","0.53398556","0.53164613","0.52830184","0.5280889","0.5272965","0.52709484","0.52354926","0.51937866","0.51937866","0.51937866","0.51937866","0.51937866","0.51937866","0.51937866","0.51937866","0.51937866","0.51937866","0.51937866","0.51778024","0.51444316","0.5143091","0.51209366","0.5080918","0.50743246","0.507297","0.50515187","0.50498396","0.50475454","0.50141","0.50066555","0.49998572","0.4979662","0.4979187","0.4977473","0.49764347","0.4973043","0.49600852","0.49595696","0.49485284","0.49419016","0.4937385","0.49264985","0.49144965","0.49137744","0.49106687","0.4903614","0.48919365","0.48891768","0.48873746","0.48804563","0.48780668","0.48681358","0.48681358","0.48586085","0.48572022","0.48569137","0.48535755","0.48385012","0.48175085","0.4816615","0.48159128","0.48129812","0.4810086","0.48064625","0.47878873","0.47827697","0.47794223","0.47769397","0.47702438","0.47671303","0.47670788","0.47666565","0.47664142","0.47621074","0.4754166","0.47528175","0.47522017","0.47493607","0.47465456","0.47437933","0.4742708","0.47358167","0.47312948","0.47267216","0.47260204","0.4725666","0.4719224","0.4713118","0.47028503","0.46947223","0.46936858","0.46862316"],"string":"[\n \"0.5895596\",\n \"0.5836528\",\n \"0.5623411\",\n \"0.55394584\",\n \"0.5525405\",\n \"0.5424819\",\n \"0.53840476\",\n \"0.53774345\",\n \"0.53398556\",\n \"0.53164613\",\n \"0.52830184\",\n \"0.5280889\",\n \"0.5272965\",\n \"0.52709484\",\n \"0.52354926\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51937866\",\n \"0.51778024\",\n \"0.51444316\",\n \"0.5143091\",\n \"0.51209366\",\n \"0.5080918\",\n \"0.50743246\",\n \"0.507297\",\n \"0.50515187\",\n \"0.50498396\",\n \"0.50475454\",\n \"0.50141\",\n \"0.50066555\",\n \"0.49998572\",\n \"0.4979662\",\n \"0.4979187\",\n \"0.4977473\",\n \"0.49764347\",\n \"0.4973043\",\n \"0.49600852\",\n \"0.49595696\",\n \"0.49485284\",\n \"0.49419016\",\n \"0.4937385\",\n \"0.49264985\",\n \"0.49144965\",\n \"0.49137744\",\n \"0.49106687\",\n \"0.4903614\",\n \"0.48919365\",\n \"0.48891768\",\n \"0.48873746\",\n \"0.48804563\",\n \"0.48780668\",\n \"0.48681358\",\n \"0.48681358\",\n \"0.48586085\",\n \"0.48572022\",\n \"0.48569137\",\n \"0.48535755\",\n \"0.48385012\",\n \"0.48175085\",\n \"0.4816615\",\n \"0.48159128\",\n \"0.48129812\",\n \"0.4810086\",\n \"0.48064625\",\n \"0.47878873\",\n \"0.47827697\",\n \"0.47794223\",\n \"0.47769397\",\n \"0.47702438\",\n \"0.47671303\",\n \"0.47670788\",\n \"0.47666565\",\n \"0.47664142\",\n \"0.47621074\",\n \"0.4754166\",\n \"0.47528175\",\n \"0.47522017\",\n \"0.47493607\",\n \"0.47465456\",\n \"0.47437933\",\n \"0.4742708\",\n \"0.47358167\",\n \"0.47312948\",\n \"0.47267216\",\n \"0.47260204\",\n \"0.4725666\",\n \"0.4719224\",\n \"0.4713118\",\n \"0.47028503\",\n \"0.46947223\",\n \"0.46936858\",\n \"0.46862316\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6062885"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14798,"cells":{"query":{"kind":"string","value":"Create an ISO 6346 shipping container code."},"document":{"kind":"string","value":"def create(owner_code, serial, category='U'):\n if not (len(owner_code) == 3 and owner_code.isalpha()):\n raise ValueError(\"Invalid ISO 6346 owner code '{}'\".format(owner_code))\n\n if category not in ('U', 'J', 'Z', 'R'):\n raise ValueError(\"Invalid ISO 6346 category identifier '{}'\".format(category))\n\n if not (len(serial) == 6 and serial.isdigit()):\n raise ValueError(\"Invalid ISO 6346 serial number\")\n\n raw_code = owner_code + category + serial\n full_code = raw_code + str(check_digit(raw_code))\n return full_code"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def USCode(self, short):\n states = {\n 'AK': 'Alaska',\n 'AL': 'Alabama',\n 'AR': 'Arkansas',\n 'AS': 'American Samoa',\n 'AZ': 'Arizona',\n 'CA': 'California',\n 'CO': 'Colorado',\n 'CT': 'Connecticut',\n 'DC': 'District of Columbia',\n 'DE': 'Delaware',\n 'FL': 'Florida',\n 'GA': 'Georgia',\n 'GU': 'Guam',\n 'HI': 'Hawaii',\n 'IA': 'Iowa',\n 'ID': 'Idaho',\n 'IL': 'Illinois',\n 'IN': 'Indiana',\n 'KS': 'Kansas',\n 'KY': 'Kentucky',\n 'LA': 'Louisiana',\n 'MA': 'Massachusetts',\n 'MD': 'Maryland',\n 'ME': 'Maine',\n 'MI': 'Michigan',\n 'MN': 'Minnesota',\n 'MO': 'Missouri',\n 'MP': 'Northern Mariana Islands',\n 'MS': 'Mississippi',\n 'MT': 'Montana',\n 'NA': 'National',\n 'NC': 'North Carolina',\n 'ND': 'North Dakota',\n 'NE': 'Nebraska',\n 'NH': 'New Hampshire',\n 'NJ': 'New Jersey',\n 'NM': 'New Mexico',\n 'NV': 'Nevada',\n 'NY': 'New York',\n 'OH': 'Ohio',\n 'OK': 'Oklahoma',\n 'OR': 'Oregon',\n 'PA': 'Pennsylvania',\n 'PR': 'Puerto Rico',\n 'RI': 'Rhode Island',\n 'SC': 'South Carolina',\n 'SD': 'South Dakota',\n 'TN': 'Tennessee',\n 'TX': 'Texas',\n 'UT': 'Utah',\n 'VA': 'Virginia',\n 'VI': 'Virgin Islands',\n 'VT': 'Vermont',\n 'WA': 'Washington',\n 'WI': 'Wisconsin',\n 'WV': 'West Virginia',\n 'WY': 'Wyoming'\n }\n return states.get(short)","def getCurrencyIsoCode(id=None):","def create_currency_from_ISO(isocode):\n from .commodity import Commodity\n\n # if self.get_session().query(Commodity).filter_by(isocode=isocode).first():\n # raise GncCommodityError(\"Currency '{}' already exists\".format(isocode))\n\n from .currency_ISO import ISO_currencies\n\n cur = ISO_currencies.get(isocode)\n\n if cur is None:\n raise ValueError(\n \"Could not find the ISO code '{}' in the ISO table\".format(isocode)\n )\n\n # create the currency\n cdty = Commodity(\n mnemonic=cur.mnemonic,\n fullname=cur.currency,\n fraction=10 ** int(cur.fraction),\n cusip=cur.cusip,\n namespace=\"CURRENCY\",\n quote_flag=1,\n )\n\n # self.gnc_session.add(cdty)\n return cdty","def country(alpha_2_code: str) -> None:","def create_code(root_node):\r\n huff_list = [\"\"] * 256\r\n code = \"\"\r\n return create_code_helper(root_node, code, huff_list)","def add_city(g, code, name, country, continent, timezone, coordinates, population, region):\n port = Ports(code, name, country, continent, timezone, coordinates, population, region)\n g.city_dict[code] = port\n g.convert[name] = code \n return g","def getAAAZZZSId(self):\n if self.element.symbol == \"C\":\n return \"120060\"\n elif self.element.symbol == \"V\":\n return \"510230\"\n else:\n return None","def create_symbol(self, base_ccy, asset):\n asset = self.user_to_exchange(self.name, asset)\n return (asset+base_ccy).upper()","def encode_v33_ce(geometry: GeomDict, identifier: str) -> Element:\n\n return GML33CE_ENCODER.encode(geometry, identifier)","def build_cart(self) -> str:\n return \"bc {} {}\".format(self.pos.x, self.pos.y)","def getSerpentId(self):\n return \"{}-nat\".format(self.element.symbol.capitalize())","def card_factory(value: str, base: str, is_hidden: bool = False) -> str:\n if 1 <= len(value) <= 2:\n card = list(base)\n card[13:15] = f\"{value} \" if len(value) == 1 else f\"{value}\"\n card[74:76] = f\" {value}\" if len(value) == 1 else f\"{value}\"\n else:\n raise Exception(\"Invalid value lenght. Must be 1 or 2 charaters\")\n\n return hidden_face if is_hidden else \"\".join(card)","def create_dgp_contract(self):\n contract_data = self.node.createcontract(\"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\", 4000000)\n self.contract_address = contract_data['address']\n self.node.generate(1)","def create_proposal_contract(self):\n contract_data = self.node.createcontract(\"60806040526104e060405190810160405280600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001603262ffffff168152602001601e62ffffff168152602001600662ffffff16815260200160c862ffffff16815260200160c962ffffff16815260200161138862ffffff168152602001613a9862ffffff168152602001600162ffffff1681526020016205b4f062ffffff168152602001600862ffffff16815260200161017762ffffff168152602001617d0062ffffff1681526020016102bc62ffffff1681526020016108fc62ffffff16815260200161232862ffffff1681526020016161a862ffffff168152602001615dc062ffffff168152602001600362ffffff16815260200161020062ffffff16815260200160c862ffffff16815260200161520862ffffff16815260200161cf0862ffffff168152602001600462ffffff168152602001604462ffffff168152602001600362ffffff1681526020016102bc62ffffff1681526020016102bc62ffffff16815260200161019062ffffff16815260200161138862ffffff16815260200161600062ffffff168152506000906027610206929190610219565b5034801561021357600080fd5b506102ee565b8260276007016008900481019282156102aa5791602002820160005b8382111561027857835183826101000a81548163ffffffff021916908362ffffff1602179055509260200192600401602081600301049283019260010302610235565b80156102a85782816101000a81549063ffffffff0219169055600401602081600301049283019260010302610278565b505b5090506102b791906102bb565b5090565b6102eb91905b808211156102e757600081816101000a81549063ffffffff0219169055506001016102c1565b5090565b90565b610160806102fd6000396000f300608060405260043610610041576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806326fadbe214610046575b600080fd5b34801561005257600080fd5b5061005b610099565b6040518082602760200280838360005b8381101561008657808201518184015260208101905061006b565b5050505090500191505060405180910390f35b6100a1610110565b6000602780602002604051908101604052809291908260278015610106576020028201916000905b82829054906101000a900463ffffffff1663ffffffff16815260200190600401906020826003010492830192600103820291508084116100c95790505b5050505050905090565b6104e0604051908101604052806027906020820280388339808201915050905050905600a165627a7a723058205e249731b14c9492ca6a161a7342bd0796c89a7eea6a30255be7fe5c0ee8995a0029\", 10000000)\n self.proposal_address = contract_data['address']\n self.abiGetSchedule = \"26fadbe2\"","def build(self, definition_id, to_format, container_name):\n url = f\"{self.base_url}/build\"\n payload = {\"definition_id\": definition_id, \"to_format\": to_format, \"container_name\": container_name}\n response = requests.post(url, json=payload, headers=self.headers)\n build_id = response.text\n\n return build_id","def _mk_coref_id():\n num, alpha = int(_mk_coref_id.id[:-1]), _mk_coref_id.id[-1]\n if alpha == 'Z':\n alpha = 'A'\n num += 1\n else:\n alpha = chr(ord(alpha) + 1)\n\n _mk_coref_id.id = '%s%s' % (num, alpha)\n return _mk_coref_id.id","def uCSIsLatin1Supplement(code):\n ret = libxml2mod.xmlUCSIsLatin1Supplement(code)\n return ret","def getAAAZZZSId(self):\n return f\"{self.a}{self.z:>03d}{self.state}\"","def card_html_id(card):\n return f'c{card:02d}'","def to_code(self, ipt_args_in_construct: str, variable_name: str, output_var: str, code_fragment):","def COUNTRY_CODE():\n COUNTRY_CODE = \"us/90210\"\n return COUNTRY_CODE","def reformat_tract_code(tract: str, state_code: str, county_code: str) -> str:\n \n # If the tract code contains a period, remove it, then prepend zeroes until length is 6\n if \".\" in tract:\n tract = tract.replace(\".\", \"\")\n num_zeroes = 6 - len(tract)\n tract = (\"0\" * num_zeroes) + tract\n # Else prepend zeroes until the length is 4, then add 2 zeroes to the end\n else:\n num_zeroes = 4 - len(tract)\n tract = (\"0\" * num_zeroes) + tract + \"00\"\n \n # Prepend state and county FIPS codes\n geoid = state_code + county_code + tract\n \n return geoid","def getSerpentId(self):\n symbol = self.element.symbol.capitalize()\n return \"{}-{}{}\".format(symbol, self.a, \"m\" if self.state else \"\")","def gee_ic_id(self):\n toa = 'COPERNICUS/S2'\n sr = 'COPERNICUS/S2_SR'\n return toa if self._isTOA() else sr","def test_create_shipping_address(self):\n self.cim.create_shipping_address(\n customer_profile_id=100,\n ship_phone=u'415-415-4154',\n ship_first_name=u'valentino'\n )","def generate_new_code():\n code = ''.join(random.choice(string.digits) for i in range(6))\n return code","def set_code_to_printings_key(printing):\n return (\n printing.set_integer or 0,\n str(printing.set_variant),\n printing.multiverseid or 0,\n printing.card_name,\n )","def make_quantity(string):\n pass","def _generate_cart_id():\n cart_id = ''\n characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()'\n cart_id_length = 50\n cart_id = ''.join([ _generate(characters) for y in range(cart_id_length)])\n\n return cart_id","def _format_intermediary_institution_56D(self, val):\n account = val.get('ACCOUNT')\n name = val.get('NAME')\n address = val.get('ADDRESS')\n if name and address:\n name = FSwiftWriterUtils.split_text_and_prefix(name, 35)\n address = FSwiftWriterUtils.split_text_and_prefix(address, 35)\n val = FSwiftWriterUtils.allocate_space_for_name_address_without_constraint(name, address)\n if account:\n val = \"/\" + str(account) + \"\\n\" + str(val)\n return val","def create_isosj_instance( self, isoform_id ):\n hash_pos = { 'chrom': self.snv_chrom, 'pos_oi': self.snv_start } #used to find the closest position for an isoform\n bool_simulant_sj = False\n group_sj = 0 #this means splicing events will NOT be grouped into 5' or 3' competitive splicing\n iso_sj = IsoformSJ( isoform_id, [], -10, hash_pos, bool_simulant_sj, group_sj )\n \n return iso_sj","def code() -> str:\n return \"\"\"\n G91 G17\n G0 Y10 X-10\n G0 Y0 X-5\n G0 Y5 X0\n G0 Y0 X5\n G0 Y0 X-5\n G0 Y-5 X0\n G3 Y-5 X5 J0 I5\n G0 Y0 X5\n G0 Y5 X0\n G3 Y5 X-5 J0 I-5\n G0 Y-5 X0\n G0 Y-10 X10\n G0 Y0 X-5\n G0 Y-15 X-15\n G0 Y0 X5\n G0 Y5 X0\n G0 Y0 X-5\n G0 Y-5 X0\n G0 Y5 X0\n G2 Y5 X5 J0 I5\n G0 Y0 X5\n G0 Y-5 X0\n G2 Y-5 X-5 J0 I-5\n G0 Y5 X0\n G0 Y10 X10\n G0 Y0 X-30\n G3 Y0 X-10 J0 I-5\n G3 Y0 X10 J0 I5\n\n G0 Y0 X5\n G3 Y5 X5 J5 I0\n G3 Y10 X-10 J0 I-10\n G3 Y-5 X-5 J-5 I0\n G0 Y-5 X0\n\n G0 Y5 X0\n G3 Y5 X-5 J0 I-5\n G3 Y-10 X-10 J-10 I0\n G3 Y-5 X5 J0 I5\n G0 Y0 X5\n\n G0 Y0 X-5\n G3 Y-5 X-5 J-5 I0\n G3 Y-10 X10 J0 I10\n G3 Y5 X5 J5 I0\n G0 Y5 X0\n\n G0 Y-5 X0\n G3 Y-5 X5 J0 I5\n G3 Y10 X10 J10 I0\n G3 Y5 X-5 J0 I-5\n G0 Y0 X-5\n \"\"\"","def bank_operation_code_23B(self):\n if self.use_operations_xml:\n bank_operation_code = FSwiftWriterUtils.get_value_from_xml_tag(self.swift_metadata_xml_dom,\n ['SWIFT', 'BANK_OPERATION_CODE'])\n else:\n bank_operation_code = get_bank_operation_code()\n return bank_operation_code","def uCSIsTaiXuanJingSymbols(code):\n ret = libxml2mod.xmlUCSIsTaiXuanJingSymbols(code)\n return ret","def country() -> str:","def test_templatetags_search_tags_rfc_5646_locale_canada_first(self):\n # Full ISO 15897 locales incl. region\n self.assertEqual(rfc_5646_locale(\"fr_FR\"), \"fr-FR\")\n self.assertEqual(rfc_5646_locale(\"fr_CA\"), \"fr-CA\")\n\n # Django style dash-separated lowercase language-region pairs\n self.assertEqual(rfc_5646_locale(\"en-us\"), \"en-US\")\n self.assertEqual(rfc_5646_locale(\"es-es\"), \"es-ES\")\n\n # Simple languages\n self.assertEqual(rfc_5646_locale(\"en\"), \"en-US\")\n self.assertEqual(rfc_5646_locale(\"es\"), \"es-ES\")\n self.assertEqual(rfc_5646_locale(\"fr\"), \"fr-CA\")","def encode(self):\n packet = (\n\n str(self.pos_number) + # 2 octets 0:3\n\n ('%.0f' % (self.amount * 100)).zfill(8) + # 8 octets 3:11\n\n self.answer_flag + # 1 octet 11:12\n\n self.payment_mode + # 1 octet 12:13\n\n self.transaction_type + # 1 octet 13:14\n\n self.currency_numeric + # 3 octet 14:17\n\n self.private + # 10 octet 17:27\n\n self.delay + # 4 octet 27:31\n\n self.authorization) # 4 octet 31:35\n\n packet_len = len(packet)\n\n if packet_len != TERMINAL_ASK_REQUIRED_SIZE:\n raise SequenceDoesNotMatchLengthException('Cannot create ask payment sequence with len != {0} octets. '\n 'Currently have {1} octet(s).'.format\n (TERMINAL_ASK_REQUIRED_SIZE, packet_len))\n\n return TeliumData.framing(packet)","def padded_area_code(phone_number):\r\n area_code = grab_area_code(phone_number)\r\n return area_code + \"*******\"","def _generate_os_code(self, name, version, bits, extra_info):\r\n name = name.replace(' Linux', '')\r\n name = name.replace('Enterprise', '')\r\n name = name.replace('GNU/Linux', '')\r\n\r\n os_code = name.strip().replace(' ', '_').upper()\r\n\r\n if os_code.startswith('RED_HAT'):\r\n os_code = 'REDHAT'\r\n\r\n if 'UBUNTU' in os_code:\r\n version = re.sub(r'\\.\\d+', '', version)\r\n\r\n os_code += '_' + version.replace('.0', '')\r\n\r\n if bits:\r\n os_code += '_' + bits\r\n\r\n if extra_info:\r\n garbage = ['Install', '(32 bit)', '(64 bit)']\r\n\r\n for obj in garbage:\r\n extra_info = extra_info.replace(obj, '')\r\n\r\n os_code += '_' + extra_info.strip().replace(' ', '_').upper()\r\n\r\n return os_code","def register_shape_i_c_code(typ, code, version=()):\r\n Shape_i.c_code_and_version[typ] = (code, version)","def new_barcode(num_digits=5, chars=string.digits+string.uppercase):\n return 'FLIM-'+(''.join([random.choice(chars) for _ in xrange(num_digits)]))","def market_gen (market): #input ACKS market class\r\n\tif market==\"VI\":\r\n\t\tchargen (1, 2, 1, 1, 1, 1, 0, 0, 0, 0)\r\n\telif market==\"V\":\r\n\t\tchargen (1, 6, 1, 1, 1, 1, 1, 1, 0, 0)\r\n\telif market==\"IV\":\r\n\t\tchargen (3, 4, 1, 2, 1, 1, 1, 1, 0, 0)\r\n\telif market==\"III\":\r\n\t\tchargen (4, 8, 1, 4, 1, 3, 1, 1, 1, 1)\r\n\telif market==\"II\":\r\n\t\tchargen (5, 20, 2, 6, 2, 4, 1, 3, 1, 2)\r\n\telif market==\"I\":\r\n\t\tchargen (4, 100, 5, 10, 3, 10, 1, 10, 1, 6)\r\n\telse:\r\n\t\tprint (\"Unknown market type\")","def uCSIsCurrencySymbols(code):\n ret = libxml2mod.xmlUCSIsCurrencySymbols(code)\n return ret","def factory(container, name, factory):","def uCSIsCatZp(code):\n ret = libxml2mod.xmlUCSIsCatZp(code)\n return ret","def area_code(self):\n return self.number[:3]","def uCSIsGeorgian(code):\n ret = libxml2mod.xmlUCSIsGeorgian(code)\n return ret","def _generate_cart_id():\n cart_id = ''\n characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()'\n cart_id_length = 50\n for y in range(cart_id_length):\n cart_id += characters[random.randint(0, len(characters) - 1)]\n return cart_id","def create_phone_signup_code(self, phone, password):\r\n code = self.random_code(settings.CODE_LENGTH)\r\n # if phone in [\"+77753721232\", \"+77752470125\", \"+77074443333\", \"+77076799939\"]:\r\n # code = \"4512\"\r\n # else:\r\n # code = \"%0.4d\" % random.randint(0, 9999)\r\n\r\n # mobizonproxy.send_sms(phone, text=u\"{} - Код активации для Pillowz365\".format(code))\r\n activation = Activation(phone=phone,\r\n to_reset=False,\r\n password=make_password(password),\r\n code=code)\r\n activation.save()\r\n return activation","def create_phone_number(n):","def uCSIsUnifiedCanadianAboriginalSyllabics(code):\n ret = libxml2mod.xmlUCSIsUnifiedCanadianAboriginalSyllabics(code)\n return ret","def test_create_contract(token, carrier):\n assert token.call().dividendsCarrier() == carrier.address","def _generate_windows_code(self, description):\r\n version_check = re.search(r'Windows Server (\\d+)', description)\r\n version = version_check.group(1)\r\n\r\n os_code = 'WIN_' + version\r\n\r\n if 'Datacenter' in description:\r\n os_code += '-DC'\r\n elif 'Enterprise' in description:\r\n os_code += '-ENT'\r\n else:\r\n os_code += '-STD'\r\n\r\n if 'ith R2' in description:\r\n os_code += '-R2'\r\n elif 'ith Hyper-V' in description:\r\n os_code += '-HYPERV'\r\n\r\n bit_check = re.search(r'\\((\\d+)\\s*bit', description)\r\n if bit_check:\r\n os_code += '_' + bit_check.group(1)\r\n\r\n return os_code","def make_ticket_code(prefix, code_dict):\r\n while (True): # continue until we find a unique code\r\n letters = random.sample(_CHAR_LIST, 4) # generate 4 random letters\r\n code = prefix + ''.join(letters) # turn letters to string\r\n if not code_dict.has_key(code): # code is unique\r\n return code","def __init__(self, species, qty, country_code=None):\n\n self.species = species\n self.qty = qty\n self.country_code = country_code\n self.shipped = False\n #if country_code:\n # self.country_code = country_code","def get_centering_code(sg_number, sg_symbol):\n lattice_type = get_lattice_type(sg_number)\n\n if \"P\" in sg_symbol or lattice_type == \"hexagonal\":\n return 1\n elif lattice_type == \"rhombohedral\":\n # can also be P_R (if a_length == c_length in conventional cell),\n # but crystal doesn't appear to use that anyway\n return 1\n elif \"I\" in sg_symbol:\n return 6\n elif \"F\" in sg_symbol:\n return 5\n elif \"C\" in sg_symbol:\n crystal_system = get_crystal_system(sg_number, as_number=False)\n if crystal_system == \"monoclinic\":\n return 4 # TODO this is P_C but don't know what code it is, maybe 3?\n # [[1.0, -1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 1.0]]\n return 4\n # elif \"A\" in sg_symbol:\n # return 2 # TODO check this is always correct (not in original function)\n\n return 1","def cp_name(cp):\n return '%s%04X' % ('u' if cp > 0xffff else 'uni', cp)","def create_product_codes_reg(self, box, new_filename=\"static/product_codes.txt\"):\n product_code_lines = str(box)\n with open(new_filename, \"a\") as f:\n f.write(product_code_lines + \"\\n\")","def get_four_digit_code(self):\n return (\n self.subhead[\"New_Code\"].str[0:2] + \".\" + self.subhead[\"New_Code\"].str[2:4]\n )","def instruction_code_23E(self):\n if self.use_operations_xml:\n instruction_code = FSwiftWriterUtils.get_value_from_xml_tag(self.swift_metadata_xml_dom,\n ['SWIFT', 'INSTRUCTION_CODE'],\n ignore_absence=True)\n else:\n instruction_code = get_instruction_code() # code\n return instruction_code","def build_creative_name(bidder_code, order_name, creative_num):\n return '{bidder_code}: HB {order_name}, #{num}'.format(\n bidder_code=bidder_code, order_name=order_name, num=creative_num)","def from_sk(cls, sk):\n assert isinstance(sk, (int, str))\n sk = int(sk, 16) if isinstance(sk, str) else sk\n pk = sk * BITCOIN.gen.G\n return cls.from_point(pk)","def encode(self):\n\n packet = (\n\n str(self.pos_number) + # 2 octets\n\n str(self.transaction_result) + # 1 octet\n\n ('%.0f' % (self.amount * 100)).zfill(8) + # 8 octets\n\n str(self.payment_mode) + # 1 octet\n\n str(self.repport) + # 55 octets\n\n str(self.currency_numeric) + # 3 octets\n\n str(self.private) # 10 octets\n\n )\n\n packet_len = len(packet)\n\n if packet_len not in [TERMINAL_ANSWER_COMPLETE_SIZE - 3, TERMINAL_ANSWER_LIMITED_SIZE - 3]:\n raise SequenceDoesNotMatchLengthException(\n 'Cannot create response payment sequence with len != {0} or {1} octet(s) '\n 'Currently have {2} octet(s).'\n .format(TERMINAL_ANSWER_COMPLETE_SIZE - 3, TERMINAL_ANSWER_LIMITED_SIZE - 3, packet_len))\n\n return TeliumData.framing(packet)","def get_country_code(self):\n\n try:\n sub_div = next(sub_div for sub_div in pycountry.subdivisions if sub_div.name == self.location)\n country = next(country for country in pycountry.countries if country.alpha_2 == sub_div.country_code)\n return country.alpha_3\n except StopIteration as exc:\n print(\"Cannot find subdivision in\" + str(exc))\n return 'XXX'","def short_code(self, sid):\r\n return ShortCode(self, sid)","def _get_det_id(self, source):\n match = re.match(r\"Camp\\.0:pnCCD\\.(\\d)\", source)\n number = str.zfill(match.groups()[0], 4)\n return \"pnccd_\" + number","def generate_cali_interface_name(prefix, ep_id):\n if len(prefix) > 4:\n raise ValueError('Prefix must be 4 characters or less.')\n return prefix + ep_id[:11]","def calling_code_with_country(formatting=''):\r\n\r\n cursor.execute('select * from countries_and_calling_codes \\\r\n order by random() limit 1;')\r\n (country, calling_code) = cursor.fetchone()\r\n if formatting is dict:\r\n return formatting({country: calling_code})\r\n return (formatting([country,\r\n calling_code]) if formatting else '{} {}'.format(country,\r\n calling_code))","def postcode(full_address):\n return capture_address_element(POSTCODE_PATTERN, full_address)","def create_apdu(self, frame, asdu_type, sequence, cause_of_transmission, common_address, message, ssn = 0, rsn = 0, originator_address = 0):\n apci = self.wrap_frame(frame, ssn, rsn)\n if type(apci) is str:\n return apci\n asdu = self.wrap_asdu(asdu_type, sequence, cause_of_transmission, common_address, message, originator_address)\n if type(asdu) is str:\n return asdu\n return apci + asdu","def card_factory(rank,suit):\n pass","def block_pop_2000():\n\n nhgis_path = src_path('demographics', 'nhgis0009_ds147_2000_block.csv')\n\n usecols = ['STATEA', 'COUNTYA', 'TRACTA', 'BLOCKA', 'FXS001']\n df = pd.read_csv(nhgis_path, usecols=usecols, header=0)\n\n df = df.rename(columns={'FXS001': 'pop2000'})\n\n df = df.rename(columns=lambda x: x.lower())\n\n df['fips'] = (df['statea'].astype(str).str.zfill(2)\n + df['countya'].astype(str).str.zfill(3))\n df['block_id'] = (df['fips']\n + df['tracta'].astype(str).str.zfill(6)\n + df['blocka'].astype(str).str.zfill(4))\n\n df = df.drop(['statea', 'countya', 'tracta', 'blocka', 'fips'])\n\n df = df.set_index('block_id')\n\n return df","def _get_iso_code(cls, language):\n iso = cls._SPECIAL_ISO_CODES.get(language, language[:3])\n return iso if language in cls._SUPPORTED_LANGUAGES else None","def add_zeros(zipcode):\n return '0' * (5 - len(zipcode)) + zipcode","def add_zeros(zipcode):\n return '0' * (5 - len(zipcode)) + zipcode","def gen_a_code(self, address):\r\n return '0' + self._bits(address).zfill(15)","def createCornerPin():\n i = b.createNode('CornerPinMI')\n i['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\n if cc:\n i = gU(i)\n return i","def uCSIsCatZ(code):\n ret = libxml2mod.xmlUCSIsCatZ(code)\n return ret","def get_shipping(container) -> str:\r\n shipping_container = container.findAll(\"li\", {\"class\": \"price-ship\"})\r\n # product_shipping: List[] = shipping_container[0].text.strip()\r\n return shipping_container[0].text.strip()","def getCurrencySymbol():","def create_uno_deck():\r\n pass","def create_code(node):\n code = []\n for i in range(256):\n code.append(i)\n _create_code_helper(node, '', code)\n return code","def uCSIsLatinExtendedAdditional(code):\n ret = libxml2mod.xmlUCSIsLatinExtendedAdditional(code)\n return ret","def create_instance(c_instance):\n return AumPC40(c_instance)","def _build_name(name_id):\n return \"xp_%08d\" % name_id","def uCSIsLatinExtendedB(code):\n ret = libxml2mod.xmlUCSIsLatinExtendedB(code)\n return ret","def uCSIsCJKCompatibilityIdeographsSupplement(code):\n ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographsSupplement(code)\n return ret","def test_retrieve_iso20022_payment_instruction(self):\n pass","def create(self):\n item = BasketItem.create()\n self._baskets[item.code] = item\n return item.code","def ship_new(name):\n click.echo('Created ship %s' % name)","def __generate_code(self):\n vouels = [\"A\", \"E\", \"I\", \"O\", \"U\"]\n coding = self.surname\n fiscal_code = \"\"\n\n # Generate first 6 letters of surname and name\n for i in range(2):\n for letter in coding:\n if len(fiscal_code) == 3 * (i+1):\n break\n elif not letter in vouels:\n #Use all upper letters\n fiscal_code += letter.upper()\n for letter in coding:\n if len(fiscal_code) == 3 * (i+1):\n break\n elif letter in vouels:\n fiscal_code += letter\n while len(fiscal_code) < 3 * (i+1):\n fiscal_code += \"X\"\n coding = self.name\n\n # Add last 2 digits of year\n fiscal_code += str(self.date.year)[-2:]\n\n # Associate month and letter\n months = [\"A\", \"B\", \"C\", \"D\", \"E\",\n \"H\", \"L\", \"M\", \"P\", \"R\", \"S\", \"T\"]\n fiscal_code += months[self.date.month - 1]\n\n # Add day, plus 40 if female\n if self.sex == \"FEMALE\":\n fiscal_code += str(self.date.day + 40)\n elif self.date.day < 10:\n fiscal_code += \"0\" + str(self.date.day)\n else:\n fiscal_code += str(self.date.day)\n\n # Add some other characters to rappresent\n fiscal_code += \"X\"\n for i in range(3):\n fiscal_code += str(i)\n fiscal_code += \"X\"\n\n self.value = fiscal_code","def default_code():\n return uuid.uuid4().hex","def buildInstruction(ops: List[ghidra.program.model.pcode.PcodeOp], fallthruoffset: int, paramshift: int, addrFactory: ghidra.program.model.address.AddressFactory) -> unicode:\n ...","def _create_encoding(font, format, base):\n font = font.label(codepoint_from=font.encoding)\n enc = base.Struct(**_ENCODING_TABLE)(\n default_char=int(font.get_default_glyph().codepoint or 0)\n )\n codepoints = font.get_codepoints()\n if not codepoints:\n raise ValueError('No storable code points in font.')\n byte_length = len(max(codepoints))\n if byte_length > 2:\n logging.warning(\n 'Code points greater than 2 bytes cannot be stored in PCF.'\n )\n elif byte_length == 1:\n enc.min_byte1 = enc.max_byte1 = 0\n enc.min_char_or_byte2 = ord(min(codepoints))\n enc.max_char_or_byte2 = ord(max(codepoints))\n elif byte_length == 2:\n byte2 = [_cp[0] for _cp in codepoints if len(_cp) == 2]\n if any(len(_cp) == 1 for _cp in codepoints):\n byte2.append(0)\n enc.min_char_or_byte2 = min(byte2)\n enc.max_char_or_byte2 = max(byte2)\n byte1 = tuple(_cp[-1] for _cp in codepoints)\n enc.min_byte1 = min(byte1)\n enc.max_byte1 = max(byte1)\n glyph_indices = []\n for cp in _generate_codepoints(enc):\n try:\n index = font.get_index(cp)\n except KeyError:\n # -1 means 'not used'\n index = -1\n glyph_indices.append(index)\n glyph_indices = (base.int16 * len(glyph_indices))(*glyph_indices)\n table_bytes = (\n bytes(le.uint32(format))\n + bytes(enc)\n + bytes(glyph_indices)\n )\n return table_bytes, format","def get_austria_crop_geopedia_idx_to_crop_id_mapping():\n gpd_session = GeopediaSession()\n to_crop_id = list(GeopediaFeatureIterator(layer='2032', gpd_session=gpd_session))\n to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]\n to_crop_id = pd.DataFrame(to_crop_id)\n to_crop_id['crop_geopedia_idx'] = pd.to_numeric(to_crop_id.crop_geopedia_idx)\n to_crop_id.rename(index=str, columns={\"SNAR_BEZEI\": \"SNAR_BEZEI_NAME\"}, inplace=True)\n to_crop_id.rename(index=str, columns={\"crop_geopedia_idx\": \"SNAR_BEZEI\"}, inplace=True)\n\n return to_crop_id","def Get_LonghurstProvinceName4Num(input):\n LonghurstProvinceDict = {\n 'ALSK': 'AlaskaDownwellingCoastalProvince',\n 'ANTA': 'AntarcticProvince',\n 'APLR': 'AustralPolarProvince',\n 'ARAB': 'NWArabianUpwellingProvince',\n 'ARCH': 'ArchipelagicDeepBasinsProvince',\n 'ARCT': 'AtlanticArcticProvince',\n 'AUSE': 'EastAustralianCoastalProvince',\n 'AUSW': 'AustraliaIndonesiaCoastalProvince',\n 'BENG': 'BenguelaCurrentCoastalProvince',\n 'BERS': 'N.PacificEpicontinentalProvince',\n 'BPLR': 'BorealPolarProvince(POLR)',\n 'BRAZ': 'BrazilCurrentCoastalProvince',\n 'CAMR': 'CentralAmericanCoastalProvince',\n 'CARB': 'CaribbeanProvince',\n 'CCAL': 'CaliforniaUpwellingCoastalProvince',\n 'CHIL': 'ChilePeruCurrentCoastalProvince',\n 'CHIN': 'ChinaSeaCoastalProvince',\n 'CHSB': 'CheasapeakeBayProvince',\n 'CNRY': 'CanaryCoastalProvince(EACB)',\n 'EAFR': 'E.AfricaCoastalProvince',\n 'ETRA': 'EasternTropicalAtlanticProvince',\n 'FKLD': 'SWAtlanticShelvesProvince',\n 'GFST': 'GulfStreamProvince',\n 'GUIA': 'GuianasCoastalProvince',\n 'GUIN': 'GuineaCurrentCoastalProvince',\n 'INDE': 'E.IndiaCoastalProvince',\n 'INDW': 'W.IndiaCoastalProvince',\n 'ISSG': 'IndianS.SubtropicalGyreProvince',\n 'KURO': 'KuroshioCurrentProvince',\n 'LAKE': 'CaspianSea,AralSea',\n 'MEDI': 'MediterraneanSea,BlackSeaProvince',\n 'MONS': 'IndianMonsoonGyresProvince',\n 'NADR': 'N.AtlanticDriftProvince(WWDR)',\n 'NASE': 'N.AtlanticSubtropicalGyralProvince(East)(STGE)',\n 'NASW': 'N.AtlanticSubtropicalGyralProvince(West)(STGW)',\n 'NATR': 'N.AtlanticTropicalGyralProvince(TRPG)',\n 'NECS': 'NEAtlanticShelvesProvince',\n 'NEWZ': 'NewZealandCoastalProvince',\n 'NPPF': 'N.PacificPolarFrontProvince',\n 'NPSE': 'N.PacificSubtropicalGyreProvince(East)',\n 'NPSW': 'N.PacificSubtropicalGyreProvince(West)',\n 'NPTG': 'N.PacificTropicalGyreProvince',\n 'NWCS': 'NWAtlanticShelvesProvince',\n 'OCAL': 'OffshoreCaliforniaCurrentProvince',\n 'PEQD': 'PacificEquatorialDivergenceProvince',\n 'PNEC': 'N.PacificEquatorialCountercurrentProvince',\n 'PSAE': 'PacificSubarcticGyresProvince(East)',\n 'PSAW': 'PacificSubarcticGyresProvince(West)',\n 'REDS': 'RedSea,PersianGulfProvince',\n 'SANT': 'SubantarcticProvince',\n 'SARC': 'AtlanticSubarcticProvince',\n 'SATL': 'SouthAtlanticGyralProvince(SATG)',\n 'SPSG': 'S.PacificSubtropicalGyreProvince',\n 'SSTC': 'S.SubtropicalConvergenceProvince',\n 'SUND': 'SundaArafuraShelvesProvince',\n 'TASM': 'TasmanSeaProvince',\n 'WARM': 'W.PacificWarmPoolProvince',\n 'WTRA': 'WesternTropicalAtlanticProvince'\n }\n return LonghurstProvinceDict[input]","def make_codes(self):\n\t\troot = heapq.heappop(self.heap)#obtenemos la raiz del arbol\n\t\tcurrent_code = \"\"\n\t\tself.make_codes_helper(root, current_code)","def genSCID():\n scid_hex = getRandomBytes(8)\n scid_hex = getSHA256Hex(scid_hex)\n scid_hex = scid_hex[0:8]\n return scid_hex","def build_city(self, logs=None) -> str:\n if self.is_cart():\n raise ValueError(f\"Unit {self.id} is a cart; cannot build a city!\")\n if logs is not None:\n logs.append((self.id, ValidActions.BUILD, self.pos))\n return \"bcity {}\".format(self.id)","def isoformat(self):\n return \"\""],"string":"[\n \"def USCode(self, short):\\n states = {\\n 'AK': 'Alaska',\\n 'AL': 'Alabama',\\n 'AR': 'Arkansas',\\n 'AS': 'American Samoa',\\n 'AZ': 'Arizona',\\n 'CA': 'California',\\n 'CO': 'Colorado',\\n 'CT': 'Connecticut',\\n 'DC': 'District of Columbia',\\n 'DE': 'Delaware',\\n 'FL': 'Florida',\\n 'GA': 'Georgia',\\n 'GU': 'Guam',\\n 'HI': 'Hawaii',\\n 'IA': 'Iowa',\\n 'ID': 'Idaho',\\n 'IL': 'Illinois',\\n 'IN': 'Indiana',\\n 'KS': 'Kansas',\\n 'KY': 'Kentucky',\\n 'LA': 'Louisiana',\\n 'MA': 'Massachusetts',\\n 'MD': 'Maryland',\\n 'ME': 'Maine',\\n 'MI': 'Michigan',\\n 'MN': 'Minnesota',\\n 'MO': 'Missouri',\\n 'MP': 'Northern Mariana Islands',\\n 'MS': 'Mississippi',\\n 'MT': 'Montana',\\n 'NA': 'National',\\n 'NC': 'North Carolina',\\n 'ND': 'North Dakota',\\n 'NE': 'Nebraska',\\n 'NH': 'New Hampshire',\\n 'NJ': 'New Jersey',\\n 'NM': 'New Mexico',\\n 'NV': 'Nevada',\\n 'NY': 'New York',\\n 'OH': 'Ohio',\\n 'OK': 'Oklahoma',\\n 'OR': 'Oregon',\\n 'PA': 'Pennsylvania',\\n 'PR': 'Puerto Rico',\\n 'RI': 'Rhode Island',\\n 'SC': 'South Carolina',\\n 'SD': 'South Dakota',\\n 'TN': 'Tennessee',\\n 'TX': 'Texas',\\n 'UT': 'Utah',\\n 'VA': 'Virginia',\\n 'VI': 'Virgin Islands',\\n 'VT': 'Vermont',\\n 'WA': 'Washington',\\n 'WI': 'Wisconsin',\\n 'WV': 'West Virginia',\\n 'WY': 'Wyoming'\\n }\\n return states.get(short)\",\n \"def getCurrencyIsoCode(id=None):\",\n \"def create_currency_from_ISO(isocode):\\n from .commodity import Commodity\\n\\n # if self.get_session().query(Commodity).filter_by(isocode=isocode).first():\\n # raise GncCommodityError(\\\"Currency '{}' already exists\\\".format(isocode))\\n\\n from .currency_ISO import ISO_currencies\\n\\n cur = ISO_currencies.get(isocode)\\n\\n if cur is None:\\n raise ValueError(\\n \\\"Could not find the ISO code '{}' in the ISO table\\\".format(isocode)\\n )\\n\\n # create the currency\\n cdty = Commodity(\\n mnemonic=cur.mnemonic,\\n fullname=cur.currency,\\n fraction=10 ** int(cur.fraction),\\n cusip=cur.cusip,\\n namespace=\\\"CURRENCY\\\",\\n quote_flag=1,\\n )\\n\\n # self.gnc_session.add(cdty)\\n return cdty\",\n \"def country(alpha_2_code: str) -> None:\",\n \"def create_code(root_node):\\r\\n huff_list = [\\\"\\\"] * 256\\r\\n code = \\\"\\\"\\r\\n return create_code_helper(root_node, code, huff_list)\",\n \"def add_city(g, code, name, country, continent, timezone, coordinates, population, region):\\n port = Ports(code, name, country, continent, timezone, coordinates, population, region)\\n g.city_dict[code] = port\\n g.convert[name] = code \\n return g\",\n \"def getAAAZZZSId(self):\\n if self.element.symbol == \\\"C\\\":\\n return \\\"120060\\\"\\n elif self.element.symbol == \\\"V\\\":\\n return \\\"510230\\\"\\n else:\\n return None\",\n \"def create_symbol(self, base_ccy, asset):\\n asset = self.user_to_exchange(self.name, asset)\\n return (asset+base_ccy).upper()\",\n \"def encode_v33_ce(geometry: GeomDict, identifier: str) -> Element:\\n\\n return GML33CE_ENCODER.encode(geometry, identifier)\",\n \"def build_cart(self) -> str:\\n return \\\"bc {} {}\\\".format(self.pos.x, self.pos.y)\",\n \"def getSerpentId(self):\\n return \\\"{}-nat\\\".format(self.element.symbol.capitalize())\",\n \"def card_factory(value: str, base: str, is_hidden: bool = False) -> str:\\n if 1 <= len(value) <= 2:\\n card = list(base)\\n card[13:15] = f\\\"{value} \\\" if len(value) == 1 else f\\\"{value}\\\"\\n card[74:76] = f\\\" {value}\\\" if len(value) == 1 else f\\\"{value}\\\"\\n else:\\n raise Exception(\\\"Invalid value lenght. Must be 1 or 2 charaters\\\")\\n\\n return hidden_face if is_hidden else \\\"\\\".join(card)\",\n \"def create_dgp_contract(self):\\n contract_data = self.node.createcontract(\\\"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\\\", 4000000)\\n self.contract_address = contract_data['address']\\n self.node.generate(1)\",\n \"def create_proposal_contract(self):\\n contract_data = self.node.createcontract(\\\"60806040526104e060405190810160405280600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001600a62ffffff168152602001603262ffffff168152602001601e62ffffff168152602001600662ffffff16815260200160c862ffffff16815260200160c962ffffff16815260200161138862ffffff168152602001613a9862ffffff168152602001600162ffffff1681526020016205b4f062ffffff168152602001600862ffffff16815260200161017762ffffff168152602001617d0062ffffff1681526020016102bc62ffffff1681526020016108fc62ffffff16815260200161232862ffffff1681526020016161a862ffffff168152602001615dc062ffffff168152602001600362ffffff16815260200161020062ffffff16815260200160c862ffffff16815260200161520862ffffff16815260200161cf0862ffffff168152602001600462ffffff168152602001604462ffffff168152602001600362ffffff1681526020016102bc62ffffff1681526020016102bc62ffffff16815260200161019062ffffff16815260200161138862ffffff16815260200161600062ffffff168152506000906027610206929190610219565b5034801561021357600080fd5b506102ee565b8260276007016008900481019282156102aa5791602002820160005b8382111561027857835183826101000a81548163ffffffff021916908362ffffff1602179055509260200192600401602081600301049283019260010302610235565b80156102a85782816101000a81549063ffffffff0219169055600401602081600301049283019260010302610278565b505b5090506102b791906102bb565b5090565b6102eb91905b808211156102e757600081816101000a81549063ffffffff0219169055506001016102c1565b5090565b90565b610160806102fd6000396000f300608060405260043610610041576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806326fadbe214610046575b600080fd5b34801561005257600080fd5b5061005b610099565b6040518082602760200280838360005b8381101561008657808201518184015260208101905061006b565b5050505090500191505060405180910390f35b6100a1610110565b6000602780602002604051908101604052809291908260278015610106576020028201916000905b82829054906101000a900463ffffffff1663ffffffff16815260200190600401906020826003010492830192600103820291508084116100c95790505b5050505050905090565b6104e0604051908101604052806027906020820280388339808201915050905050905600a165627a7a723058205e249731b14c9492ca6a161a7342bd0796c89a7eea6a30255be7fe5c0ee8995a0029\\\", 10000000)\\n self.proposal_address = contract_data['address']\\n self.abiGetSchedule = \\\"26fadbe2\\\"\",\n \"def build(self, definition_id, to_format, container_name):\\n url = f\\\"{self.base_url}/build\\\"\\n payload = {\\\"definition_id\\\": definition_id, \\\"to_format\\\": to_format, \\\"container_name\\\": container_name}\\n response = requests.post(url, json=payload, headers=self.headers)\\n build_id = response.text\\n\\n return build_id\",\n \"def _mk_coref_id():\\n num, alpha = int(_mk_coref_id.id[:-1]), _mk_coref_id.id[-1]\\n if alpha == 'Z':\\n alpha = 'A'\\n num += 1\\n else:\\n alpha = chr(ord(alpha) + 1)\\n\\n _mk_coref_id.id = '%s%s' % (num, alpha)\\n return _mk_coref_id.id\",\n \"def uCSIsLatin1Supplement(code):\\n ret = libxml2mod.xmlUCSIsLatin1Supplement(code)\\n return ret\",\n \"def getAAAZZZSId(self):\\n return f\\\"{self.a}{self.z:>03d}{self.state}\\\"\",\n \"def card_html_id(card):\\n return f'c{card:02d}'\",\n \"def to_code(self, ipt_args_in_construct: str, variable_name: str, output_var: str, code_fragment):\",\n \"def COUNTRY_CODE():\\n COUNTRY_CODE = \\\"us/90210\\\"\\n return COUNTRY_CODE\",\n \"def reformat_tract_code(tract: str, state_code: str, county_code: str) -> str:\\n \\n # If the tract code contains a period, remove it, then prepend zeroes until length is 6\\n if \\\".\\\" in tract:\\n tract = tract.replace(\\\".\\\", \\\"\\\")\\n num_zeroes = 6 - len(tract)\\n tract = (\\\"0\\\" * num_zeroes) + tract\\n # Else prepend zeroes until the length is 4, then add 2 zeroes to the end\\n else:\\n num_zeroes = 4 - len(tract)\\n tract = (\\\"0\\\" * num_zeroes) + tract + \\\"00\\\"\\n \\n # Prepend state and county FIPS codes\\n geoid = state_code + county_code + tract\\n \\n return geoid\",\n \"def getSerpentId(self):\\n symbol = self.element.symbol.capitalize()\\n return \\\"{}-{}{}\\\".format(symbol, self.a, \\\"m\\\" if self.state else \\\"\\\")\",\n \"def gee_ic_id(self):\\n toa = 'COPERNICUS/S2'\\n sr = 'COPERNICUS/S2_SR'\\n return toa if self._isTOA() else sr\",\n \"def test_create_shipping_address(self):\\n self.cim.create_shipping_address(\\n customer_profile_id=100,\\n ship_phone=u'415-415-4154',\\n ship_first_name=u'valentino'\\n )\",\n \"def generate_new_code():\\n code = ''.join(random.choice(string.digits) for i in range(6))\\n return code\",\n \"def set_code_to_printings_key(printing):\\n return (\\n printing.set_integer or 0,\\n str(printing.set_variant),\\n printing.multiverseid or 0,\\n printing.card_name,\\n )\",\n \"def make_quantity(string):\\n pass\",\n \"def _generate_cart_id():\\n cart_id = ''\\n characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()'\\n cart_id_length = 50\\n cart_id = ''.join([ _generate(characters) for y in range(cart_id_length)])\\n\\n return cart_id\",\n \"def _format_intermediary_institution_56D(self, val):\\n account = val.get('ACCOUNT')\\n name = val.get('NAME')\\n address = val.get('ADDRESS')\\n if name and address:\\n name = FSwiftWriterUtils.split_text_and_prefix(name, 35)\\n address = FSwiftWriterUtils.split_text_and_prefix(address, 35)\\n val = FSwiftWriterUtils.allocate_space_for_name_address_without_constraint(name, address)\\n if account:\\n val = \\\"/\\\" + str(account) + \\\"\\\\n\\\" + str(val)\\n return val\",\n \"def create_isosj_instance( self, isoform_id ):\\n hash_pos = { 'chrom': self.snv_chrom, 'pos_oi': self.snv_start } #used to find the closest position for an isoform\\n bool_simulant_sj = False\\n group_sj = 0 #this means splicing events will NOT be grouped into 5' or 3' competitive splicing\\n iso_sj = IsoformSJ( isoform_id, [], -10, hash_pos, bool_simulant_sj, group_sj )\\n \\n return iso_sj\",\n \"def code() -> str:\\n return \\\"\\\"\\\"\\n G91 G17\\n G0 Y10 X-10\\n G0 Y0 X-5\\n G0 Y5 X0\\n G0 Y0 X5\\n G0 Y0 X-5\\n G0 Y-5 X0\\n G3 Y-5 X5 J0 I5\\n G0 Y0 X5\\n G0 Y5 X0\\n G3 Y5 X-5 J0 I-5\\n G0 Y-5 X0\\n G0 Y-10 X10\\n G0 Y0 X-5\\n G0 Y-15 X-15\\n G0 Y0 X5\\n G0 Y5 X0\\n G0 Y0 X-5\\n G0 Y-5 X0\\n G0 Y5 X0\\n G2 Y5 X5 J0 I5\\n G0 Y0 X5\\n G0 Y-5 X0\\n G2 Y-5 X-5 J0 I-5\\n G0 Y5 X0\\n G0 Y10 X10\\n G0 Y0 X-30\\n G3 Y0 X-10 J0 I-5\\n G3 Y0 X10 J0 I5\\n\\n G0 Y0 X5\\n G3 Y5 X5 J5 I0\\n G3 Y10 X-10 J0 I-10\\n G3 Y-5 X-5 J-5 I0\\n G0 Y-5 X0\\n\\n G0 Y5 X0\\n G3 Y5 X-5 J0 I-5\\n G3 Y-10 X-10 J-10 I0\\n G3 Y-5 X5 J0 I5\\n G0 Y0 X5\\n\\n G0 Y0 X-5\\n G3 Y-5 X-5 J-5 I0\\n G3 Y-10 X10 J0 I10\\n G3 Y5 X5 J5 I0\\n G0 Y5 X0\\n\\n G0 Y-5 X0\\n G3 Y-5 X5 J0 I5\\n G3 Y10 X10 J10 I0\\n G3 Y5 X-5 J0 I-5\\n G0 Y0 X-5\\n \\\"\\\"\\\"\",\n \"def bank_operation_code_23B(self):\\n if self.use_operations_xml:\\n bank_operation_code = FSwiftWriterUtils.get_value_from_xml_tag(self.swift_metadata_xml_dom,\\n ['SWIFT', 'BANK_OPERATION_CODE'])\\n else:\\n bank_operation_code = get_bank_operation_code()\\n return bank_operation_code\",\n \"def uCSIsTaiXuanJingSymbols(code):\\n ret = libxml2mod.xmlUCSIsTaiXuanJingSymbols(code)\\n return ret\",\n \"def country() -> str:\",\n \"def test_templatetags_search_tags_rfc_5646_locale_canada_first(self):\\n # Full ISO 15897 locales incl. region\\n self.assertEqual(rfc_5646_locale(\\\"fr_FR\\\"), \\\"fr-FR\\\")\\n self.assertEqual(rfc_5646_locale(\\\"fr_CA\\\"), \\\"fr-CA\\\")\\n\\n # Django style dash-separated lowercase language-region pairs\\n self.assertEqual(rfc_5646_locale(\\\"en-us\\\"), \\\"en-US\\\")\\n self.assertEqual(rfc_5646_locale(\\\"es-es\\\"), \\\"es-ES\\\")\\n\\n # Simple languages\\n self.assertEqual(rfc_5646_locale(\\\"en\\\"), \\\"en-US\\\")\\n self.assertEqual(rfc_5646_locale(\\\"es\\\"), \\\"es-ES\\\")\\n self.assertEqual(rfc_5646_locale(\\\"fr\\\"), \\\"fr-CA\\\")\",\n \"def encode(self):\\n packet = (\\n\\n str(self.pos_number) + # 2 octets 0:3\\n\\n ('%.0f' % (self.amount * 100)).zfill(8) + # 8 octets 3:11\\n\\n self.answer_flag + # 1 octet 11:12\\n\\n self.payment_mode + # 1 octet 12:13\\n\\n self.transaction_type + # 1 octet 13:14\\n\\n self.currency_numeric + # 3 octet 14:17\\n\\n self.private + # 10 octet 17:27\\n\\n self.delay + # 4 octet 27:31\\n\\n self.authorization) # 4 octet 31:35\\n\\n packet_len = len(packet)\\n\\n if packet_len != TERMINAL_ASK_REQUIRED_SIZE:\\n raise SequenceDoesNotMatchLengthException('Cannot create ask payment sequence with len != {0} octets. '\\n 'Currently have {1} octet(s).'.format\\n (TERMINAL_ASK_REQUIRED_SIZE, packet_len))\\n\\n return TeliumData.framing(packet)\",\n \"def padded_area_code(phone_number):\\r\\n area_code = grab_area_code(phone_number)\\r\\n return area_code + \\\"*******\\\"\",\n \"def _generate_os_code(self, name, version, bits, extra_info):\\r\\n name = name.replace(' Linux', '')\\r\\n name = name.replace('Enterprise', '')\\r\\n name = name.replace('GNU/Linux', '')\\r\\n\\r\\n os_code = name.strip().replace(' ', '_').upper()\\r\\n\\r\\n if os_code.startswith('RED_HAT'):\\r\\n os_code = 'REDHAT'\\r\\n\\r\\n if 'UBUNTU' in os_code:\\r\\n version = re.sub(r'\\\\.\\\\d+', '', version)\\r\\n\\r\\n os_code += '_' + version.replace('.0', '')\\r\\n\\r\\n if bits:\\r\\n os_code += '_' + bits\\r\\n\\r\\n if extra_info:\\r\\n garbage = ['Install', '(32 bit)', '(64 bit)']\\r\\n\\r\\n for obj in garbage:\\r\\n extra_info = extra_info.replace(obj, '')\\r\\n\\r\\n os_code += '_' + extra_info.strip().replace(' ', '_').upper()\\r\\n\\r\\n return os_code\",\n \"def register_shape_i_c_code(typ, code, version=()):\\r\\n Shape_i.c_code_and_version[typ] = (code, version)\",\n \"def new_barcode(num_digits=5, chars=string.digits+string.uppercase):\\n return 'FLIM-'+(''.join([random.choice(chars) for _ in xrange(num_digits)]))\",\n \"def market_gen (market): #input ACKS market class\\r\\n\\tif market==\\\"VI\\\":\\r\\n\\t\\tchargen (1, 2, 1, 1, 1, 1, 0, 0, 0, 0)\\r\\n\\telif market==\\\"V\\\":\\r\\n\\t\\tchargen (1, 6, 1, 1, 1, 1, 1, 1, 0, 0)\\r\\n\\telif market==\\\"IV\\\":\\r\\n\\t\\tchargen (3, 4, 1, 2, 1, 1, 1, 1, 0, 0)\\r\\n\\telif market==\\\"III\\\":\\r\\n\\t\\tchargen (4, 8, 1, 4, 1, 3, 1, 1, 1, 1)\\r\\n\\telif market==\\\"II\\\":\\r\\n\\t\\tchargen (5, 20, 2, 6, 2, 4, 1, 3, 1, 2)\\r\\n\\telif market==\\\"I\\\":\\r\\n\\t\\tchargen (4, 100, 5, 10, 3, 10, 1, 10, 1, 6)\\r\\n\\telse:\\r\\n\\t\\tprint (\\\"Unknown market type\\\")\",\n \"def uCSIsCurrencySymbols(code):\\n ret = libxml2mod.xmlUCSIsCurrencySymbols(code)\\n return ret\",\n \"def factory(container, name, factory):\",\n \"def uCSIsCatZp(code):\\n ret = libxml2mod.xmlUCSIsCatZp(code)\\n return ret\",\n \"def area_code(self):\\n return self.number[:3]\",\n \"def uCSIsGeorgian(code):\\n ret = libxml2mod.xmlUCSIsGeorgian(code)\\n return ret\",\n \"def _generate_cart_id():\\n cart_id = ''\\n characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()'\\n cart_id_length = 50\\n for y in range(cart_id_length):\\n cart_id += characters[random.randint(0, len(characters) - 1)]\\n return cart_id\",\n \"def create_phone_signup_code(self, phone, password):\\r\\n code = self.random_code(settings.CODE_LENGTH)\\r\\n # if phone in [\\\"+77753721232\\\", \\\"+77752470125\\\", \\\"+77074443333\\\", \\\"+77076799939\\\"]:\\r\\n # code = \\\"4512\\\"\\r\\n # else:\\r\\n # code = \\\"%0.4d\\\" % random.randint(0, 9999)\\r\\n\\r\\n # mobizonproxy.send_sms(phone, text=u\\\"{} - Код активации для Pillowz365\\\".format(code))\\r\\n activation = Activation(phone=phone,\\r\\n to_reset=False,\\r\\n password=make_password(password),\\r\\n code=code)\\r\\n activation.save()\\r\\n return activation\",\n \"def create_phone_number(n):\",\n \"def uCSIsUnifiedCanadianAboriginalSyllabics(code):\\n ret = libxml2mod.xmlUCSIsUnifiedCanadianAboriginalSyllabics(code)\\n return ret\",\n \"def test_create_contract(token, carrier):\\n assert token.call().dividendsCarrier() == carrier.address\",\n \"def _generate_windows_code(self, description):\\r\\n version_check = re.search(r'Windows Server (\\\\d+)', description)\\r\\n version = version_check.group(1)\\r\\n\\r\\n os_code = 'WIN_' + version\\r\\n\\r\\n if 'Datacenter' in description:\\r\\n os_code += '-DC'\\r\\n elif 'Enterprise' in description:\\r\\n os_code += '-ENT'\\r\\n else:\\r\\n os_code += '-STD'\\r\\n\\r\\n if 'ith R2' in description:\\r\\n os_code += '-R2'\\r\\n elif 'ith Hyper-V' in description:\\r\\n os_code += '-HYPERV'\\r\\n\\r\\n bit_check = re.search(r'\\\\((\\\\d+)\\\\s*bit', description)\\r\\n if bit_check:\\r\\n os_code += '_' + bit_check.group(1)\\r\\n\\r\\n return os_code\",\n \"def make_ticket_code(prefix, code_dict):\\r\\n while (True): # continue until we find a unique code\\r\\n letters = random.sample(_CHAR_LIST, 4) # generate 4 random letters\\r\\n code = prefix + ''.join(letters) # turn letters to string\\r\\n if not code_dict.has_key(code): # code is unique\\r\\n return code\",\n \"def __init__(self, species, qty, country_code=None):\\n\\n self.species = species\\n self.qty = qty\\n self.country_code = country_code\\n self.shipped = False\\n #if country_code:\\n # self.country_code = country_code\",\n \"def get_centering_code(sg_number, sg_symbol):\\n lattice_type = get_lattice_type(sg_number)\\n\\n if \\\"P\\\" in sg_symbol or lattice_type == \\\"hexagonal\\\":\\n return 1\\n elif lattice_type == \\\"rhombohedral\\\":\\n # can also be P_R (if a_length == c_length in conventional cell),\\n # but crystal doesn't appear to use that anyway\\n return 1\\n elif \\\"I\\\" in sg_symbol:\\n return 6\\n elif \\\"F\\\" in sg_symbol:\\n return 5\\n elif \\\"C\\\" in sg_symbol:\\n crystal_system = get_crystal_system(sg_number, as_number=False)\\n if crystal_system == \\\"monoclinic\\\":\\n return 4 # TODO this is P_C but don't know what code it is, maybe 3?\\n # [[1.0, -1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 1.0]]\\n return 4\\n # elif \\\"A\\\" in sg_symbol:\\n # return 2 # TODO check this is always correct (not in original function)\\n\\n return 1\",\n \"def cp_name(cp):\\n return '%s%04X' % ('u' if cp > 0xffff else 'uni', cp)\",\n \"def create_product_codes_reg(self, box, new_filename=\\\"static/product_codes.txt\\\"):\\n product_code_lines = str(box)\\n with open(new_filename, \\\"a\\\") as f:\\n f.write(product_code_lines + \\\"\\\\n\\\")\",\n \"def get_four_digit_code(self):\\n return (\\n self.subhead[\\\"New_Code\\\"].str[0:2] + \\\".\\\" + self.subhead[\\\"New_Code\\\"].str[2:4]\\n )\",\n \"def instruction_code_23E(self):\\n if self.use_operations_xml:\\n instruction_code = FSwiftWriterUtils.get_value_from_xml_tag(self.swift_metadata_xml_dom,\\n ['SWIFT', 'INSTRUCTION_CODE'],\\n ignore_absence=True)\\n else:\\n instruction_code = get_instruction_code() # code\\n return instruction_code\",\n \"def build_creative_name(bidder_code, order_name, creative_num):\\n return '{bidder_code}: HB {order_name}, #{num}'.format(\\n bidder_code=bidder_code, order_name=order_name, num=creative_num)\",\n \"def from_sk(cls, sk):\\n assert isinstance(sk, (int, str))\\n sk = int(sk, 16) if isinstance(sk, str) else sk\\n pk = sk * BITCOIN.gen.G\\n return cls.from_point(pk)\",\n \"def encode(self):\\n\\n packet = (\\n\\n str(self.pos_number) + # 2 octets\\n\\n str(self.transaction_result) + # 1 octet\\n\\n ('%.0f' % (self.amount * 100)).zfill(8) + # 8 octets\\n\\n str(self.payment_mode) + # 1 octet\\n\\n str(self.repport) + # 55 octets\\n\\n str(self.currency_numeric) + # 3 octets\\n\\n str(self.private) # 10 octets\\n\\n )\\n\\n packet_len = len(packet)\\n\\n if packet_len not in [TERMINAL_ANSWER_COMPLETE_SIZE - 3, TERMINAL_ANSWER_LIMITED_SIZE - 3]:\\n raise SequenceDoesNotMatchLengthException(\\n 'Cannot create response payment sequence with len != {0} or {1} octet(s) '\\n 'Currently have {2} octet(s).'\\n .format(TERMINAL_ANSWER_COMPLETE_SIZE - 3, TERMINAL_ANSWER_LIMITED_SIZE - 3, packet_len))\\n\\n return TeliumData.framing(packet)\",\n \"def get_country_code(self):\\n\\n try:\\n sub_div = next(sub_div for sub_div in pycountry.subdivisions if sub_div.name == self.location)\\n country = next(country for country in pycountry.countries if country.alpha_2 == sub_div.country_code)\\n return country.alpha_3\\n except StopIteration as exc:\\n print(\\\"Cannot find subdivision in\\\" + str(exc))\\n return 'XXX'\",\n \"def short_code(self, sid):\\r\\n return ShortCode(self, sid)\",\n \"def _get_det_id(self, source):\\n match = re.match(r\\\"Camp\\\\.0:pnCCD\\\\.(\\\\d)\\\", source)\\n number = str.zfill(match.groups()[0], 4)\\n return \\\"pnccd_\\\" + number\",\n \"def generate_cali_interface_name(prefix, ep_id):\\n if len(prefix) > 4:\\n raise ValueError('Prefix must be 4 characters or less.')\\n return prefix + ep_id[:11]\",\n \"def calling_code_with_country(formatting=''):\\r\\n\\r\\n cursor.execute('select * from countries_and_calling_codes \\\\\\r\\n order by random() limit 1;')\\r\\n (country, calling_code) = cursor.fetchone()\\r\\n if formatting is dict:\\r\\n return formatting({country: calling_code})\\r\\n return (formatting([country,\\r\\n calling_code]) if formatting else '{} {}'.format(country,\\r\\n calling_code))\",\n \"def postcode(full_address):\\n return capture_address_element(POSTCODE_PATTERN, full_address)\",\n \"def create_apdu(self, frame, asdu_type, sequence, cause_of_transmission, common_address, message, ssn = 0, rsn = 0, originator_address = 0):\\n apci = self.wrap_frame(frame, ssn, rsn)\\n if type(apci) is str:\\n return apci\\n asdu = self.wrap_asdu(asdu_type, sequence, cause_of_transmission, common_address, message, originator_address)\\n if type(asdu) is str:\\n return asdu\\n return apci + asdu\",\n \"def card_factory(rank,suit):\\n pass\",\n \"def block_pop_2000():\\n\\n nhgis_path = src_path('demographics', 'nhgis0009_ds147_2000_block.csv')\\n\\n usecols = ['STATEA', 'COUNTYA', 'TRACTA', 'BLOCKA', 'FXS001']\\n df = pd.read_csv(nhgis_path, usecols=usecols, header=0)\\n\\n df = df.rename(columns={'FXS001': 'pop2000'})\\n\\n df = df.rename(columns=lambda x: x.lower())\\n\\n df['fips'] = (df['statea'].astype(str).str.zfill(2)\\n + df['countya'].astype(str).str.zfill(3))\\n df['block_id'] = (df['fips']\\n + df['tracta'].astype(str).str.zfill(6)\\n + df['blocka'].astype(str).str.zfill(4))\\n\\n df = df.drop(['statea', 'countya', 'tracta', 'blocka', 'fips'])\\n\\n df = df.set_index('block_id')\\n\\n return df\",\n \"def _get_iso_code(cls, language):\\n iso = cls._SPECIAL_ISO_CODES.get(language, language[:3])\\n return iso if language in cls._SUPPORTED_LANGUAGES else None\",\n \"def add_zeros(zipcode):\\n return '0' * (5 - len(zipcode)) + zipcode\",\n \"def add_zeros(zipcode):\\n return '0' * (5 - len(zipcode)) + zipcode\",\n \"def gen_a_code(self, address):\\r\\n return '0' + self._bits(address).zfill(15)\",\n \"def createCornerPin():\\n i = b.createNode('CornerPinMI')\\n i['tile_color'].setValue(int('%02x%02x%02x%02x' % (232.05, 145.095, 0, 255), 16))\\n if cc:\\n i = gU(i)\\n return i\",\n \"def uCSIsCatZ(code):\\n ret = libxml2mod.xmlUCSIsCatZ(code)\\n return ret\",\n \"def get_shipping(container) -> str:\\r\\n shipping_container = container.findAll(\\\"li\\\", {\\\"class\\\": \\\"price-ship\\\"})\\r\\n # product_shipping: List[] = shipping_container[0].text.strip()\\r\\n return shipping_container[0].text.strip()\",\n \"def getCurrencySymbol():\",\n \"def create_uno_deck():\\r\\n pass\",\n \"def create_code(node):\\n code = []\\n for i in range(256):\\n code.append(i)\\n _create_code_helper(node, '', code)\\n return code\",\n \"def uCSIsLatinExtendedAdditional(code):\\n ret = libxml2mod.xmlUCSIsLatinExtendedAdditional(code)\\n return ret\",\n \"def create_instance(c_instance):\\n return AumPC40(c_instance)\",\n \"def _build_name(name_id):\\n return \\\"xp_%08d\\\" % name_id\",\n \"def uCSIsLatinExtendedB(code):\\n ret = libxml2mod.xmlUCSIsLatinExtendedB(code)\\n return ret\",\n \"def uCSIsCJKCompatibilityIdeographsSupplement(code):\\n ret = libxml2mod.xmlUCSIsCJKCompatibilityIdeographsSupplement(code)\\n return ret\",\n \"def test_retrieve_iso20022_payment_instruction(self):\\n pass\",\n \"def create(self):\\n item = BasketItem.create()\\n self._baskets[item.code] = item\\n return item.code\",\n \"def ship_new(name):\\n click.echo('Created ship %s' % name)\",\n \"def __generate_code(self):\\n vouels = [\\\"A\\\", \\\"E\\\", \\\"I\\\", \\\"O\\\", \\\"U\\\"]\\n coding = self.surname\\n fiscal_code = \\\"\\\"\\n\\n # Generate first 6 letters of surname and name\\n for i in range(2):\\n for letter in coding:\\n if len(fiscal_code) == 3 * (i+1):\\n break\\n elif not letter in vouels:\\n #Use all upper letters\\n fiscal_code += letter.upper()\\n for letter in coding:\\n if len(fiscal_code) == 3 * (i+1):\\n break\\n elif letter in vouels:\\n fiscal_code += letter\\n while len(fiscal_code) < 3 * (i+1):\\n fiscal_code += \\\"X\\\"\\n coding = self.name\\n\\n # Add last 2 digits of year\\n fiscal_code += str(self.date.year)[-2:]\\n\\n # Associate month and letter\\n months = [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"E\\\",\\n \\\"H\\\", \\\"L\\\", \\\"M\\\", \\\"P\\\", \\\"R\\\", \\\"S\\\", \\\"T\\\"]\\n fiscal_code += months[self.date.month - 1]\\n\\n # Add day, plus 40 if female\\n if self.sex == \\\"FEMALE\\\":\\n fiscal_code += str(self.date.day + 40)\\n elif self.date.day < 10:\\n fiscal_code += \\\"0\\\" + str(self.date.day)\\n else:\\n fiscal_code += str(self.date.day)\\n\\n # Add some other characters to rappresent\\n fiscal_code += \\\"X\\\"\\n for i in range(3):\\n fiscal_code += str(i)\\n fiscal_code += \\\"X\\\"\\n\\n self.value = fiscal_code\",\n \"def default_code():\\n return uuid.uuid4().hex\",\n \"def buildInstruction(ops: List[ghidra.program.model.pcode.PcodeOp], fallthruoffset: int, paramshift: int, addrFactory: ghidra.program.model.address.AddressFactory) -> unicode:\\n ...\",\n \"def _create_encoding(font, format, base):\\n font = font.label(codepoint_from=font.encoding)\\n enc = base.Struct(**_ENCODING_TABLE)(\\n default_char=int(font.get_default_glyph().codepoint or 0)\\n )\\n codepoints = font.get_codepoints()\\n if not codepoints:\\n raise ValueError('No storable code points in font.')\\n byte_length = len(max(codepoints))\\n if byte_length > 2:\\n logging.warning(\\n 'Code points greater than 2 bytes cannot be stored in PCF.'\\n )\\n elif byte_length == 1:\\n enc.min_byte1 = enc.max_byte1 = 0\\n enc.min_char_or_byte2 = ord(min(codepoints))\\n enc.max_char_or_byte2 = ord(max(codepoints))\\n elif byte_length == 2:\\n byte2 = [_cp[0] for _cp in codepoints if len(_cp) == 2]\\n if any(len(_cp) == 1 for _cp in codepoints):\\n byte2.append(0)\\n enc.min_char_or_byte2 = min(byte2)\\n enc.max_char_or_byte2 = max(byte2)\\n byte1 = tuple(_cp[-1] for _cp in codepoints)\\n enc.min_byte1 = min(byte1)\\n enc.max_byte1 = max(byte1)\\n glyph_indices = []\\n for cp in _generate_codepoints(enc):\\n try:\\n index = font.get_index(cp)\\n except KeyError:\\n # -1 means 'not used'\\n index = -1\\n glyph_indices.append(index)\\n glyph_indices = (base.int16 * len(glyph_indices))(*glyph_indices)\\n table_bytes = (\\n bytes(le.uint32(format))\\n + bytes(enc)\\n + bytes(glyph_indices)\\n )\\n return table_bytes, format\",\n \"def get_austria_crop_geopedia_idx_to_crop_id_mapping():\\n gpd_session = GeopediaSession()\\n to_crop_id = list(GeopediaFeatureIterator(layer='2032', gpd_session=gpd_session))\\n to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]\\n to_crop_id = pd.DataFrame(to_crop_id)\\n to_crop_id['crop_geopedia_idx'] = pd.to_numeric(to_crop_id.crop_geopedia_idx)\\n to_crop_id.rename(index=str, columns={\\\"SNAR_BEZEI\\\": \\\"SNAR_BEZEI_NAME\\\"}, inplace=True)\\n to_crop_id.rename(index=str, columns={\\\"crop_geopedia_idx\\\": \\\"SNAR_BEZEI\\\"}, inplace=True)\\n\\n return to_crop_id\",\n \"def Get_LonghurstProvinceName4Num(input):\\n LonghurstProvinceDict = {\\n 'ALSK': 'AlaskaDownwellingCoastalProvince',\\n 'ANTA': 'AntarcticProvince',\\n 'APLR': 'AustralPolarProvince',\\n 'ARAB': 'NWArabianUpwellingProvince',\\n 'ARCH': 'ArchipelagicDeepBasinsProvince',\\n 'ARCT': 'AtlanticArcticProvince',\\n 'AUSE': 'EastAustralianCoastalProvince',\\n 'AUSW': 'AustraliaIndonesiaCoastalProvince',\\n 'BENG': 'BenguelaCurrentCoastalProvince',\\n 'BERS': 'N.PacificEpicontinentalProvince',\\n 'BPLR': 'BorealPolarProvince(POLR)',\\n 'BRAZ': 'BrazilCurrentCoastalProvince',\\n 'CAMR': 'CentralAmericanCoastalProvince',\\n 'CARB': 'CaribbeanProvince',\\n 'CCAL': 'CaliforniaUpwellingCoastalProvince',\\n 'CHIL': 'ChilePeruCurrentCoastalProvince',\\n 'CHIN': 'ChinaSeaCoastalProvince',\\n 'CHSB': 'CheasapeakeBayProvince',\\n 'CNRY': 'CanaryCoastalProvince(EACB)',\\n 'EAFR': 'E.AfricaCoastalProvince',\\n 'ETRA': 'EasternTropicalAtlanticProvince',\\n 'FKLD': 'SWAtlanticShelvesProvince',\\n 'GFST': 'GulfStreamProvince',\\n 'GUIA': 'GuianasCoastalProvince',\\n 'GUIN': 'GuineaCurrentCoastalProvince',\\n 'INDE': 'E.IndiaCoastalProvince',\\n 'INDW': 'W.IndiaCoastalProvince',\\n 'ISSG': 'IndianS.SubtropicalGyreProvince',\\n 'KURO': 'KuroshioCurrentProvince',\\n 'LAKE': 'CaspianSea,AralSea',\\n 'MEDI': 'MediterraneanSea,BlackSeaProvince',\\n 'MONS': 'IndianMonsoonGyresProvince',\\n 'NADR': 'N.AtlanticDriftProvince(WWDR)',\\n 'NASE': 'N.AtlanticSubtropicalGyralProvince(East)(STGE)',\\n 'NASW': 'N.AtlanticSubtropicalGyralProvince(West)(STGW)',\\n 'NATR': 'N.AtlanticTropicalGyralProvince(TRPG)',\\n 'NECS': 'NEAtlanticShelvesProvince',\\n 'NEWZ': 'NewZealandCoastalProvince',\\n 'NPPF': 'N.PacificPolarFrontProvince',\\n 'NPSE': 'N.PacificSubtropicalGyreProvince(East)',\\n 'NPSW': 'N.PacificSubtropicalGyreProvince(West)',\\n 'NPTG': 'N.PacificTropicalGyreProvince',\\n 'NWCS': 'NWAtlanticShelvesProvince',\\n 'OCAL': 'OffshoreCaliforniaCurrentProvince',\\n 'PEQD': 'PacificEquatorialDivergenceProvince',\\n 'PNEC': 'N.PacificEquatorialCountercurrentProvince',\\n 'PSAE': 'PacificSubarcticGyresProvince(East)',\\n 'PSAW': 'PacificSubarcticGyresProvince(West)',\\n 'REDS': 'RedSea,PersianGulfProvince',\\n 'SANT': 'SubantarcticProvince',\\n 'SARC': 'AtlanticSubarcticProvince',\\n 'SATL': 'SouthAtlanticGyralProvince(SATG)',\\n 'SPSG': 'S.PacificSubtropicalGyreProvince',\\n 'SSTC': 'S.SubtropicalConvergenceProvince',\\n 'SUND': 'SundaArafuraShelvesProvince',\\n 'TASM': 'TasmanSeaProvince',\\n 'WARM': 'W.PacificWarmPoolProvince',\\n 'WTRA': 'WesternTropicalAtlanticProvince'\\n }\\n return LonghurstProvinceDict[input]\",\n \"def make_codes(self):\\n\\t\\troot = heapq.heappop(self.heap)#obtenemos la raiz del arbol\\n\\t\\tcurrent_code = \\\"\\\"\\n\\t\\tself.make_codes_helper(root, current_code)\",\n \"def genSCID():\\n scid_hex = getRandomBytes(8)\\n scid_hex = getSHA256Hex(scid_hex)\\n scid_hex = scid_hex[0:8]\\n return scid_hex\",\n \"def build_city(self, logs=None) -> str:\\n if self.is_cart():\\n raise ValueError(f\\\"Unit {self.id} is a cart; cannot build a city!\\\")\\n if logs is not None:\\n logs.append((self.id, ValidActions.BUILD, self.pos))\\n return \\\"bcity {}\\\".format(self.id)\",\n \"def isoformat(self):\\n return \\\"\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5175448","0.5125011","0.50932604","0.49715528","0.49012083","0.48026282","0.48011735","0.47937286","0.47771695","0.47705403","0.47160998","0.47139278","0.47057864","0.47034556","0.46948606","0.46944666","0.4689189","0.4687901","0.46823987","0.46695173","0.46665677","0.46463287","0.463197","0.46269512","0.4620182","0.46178904","0.45858875","0.45800152","0.45725527","0.4569992","0.45544326","0.45480514","0.45269108","0.4525998","0.45201433","0.45127243","0.45118624","0.45112488","0.45078596","0.44948262","0.44833893","0.44823077","0.44818032","0.44817612","0.4473151","0.44662607","0.4458843","0.44405934","0.4435481","0.44307458","0.44301102","0.4429004","0.442173","0.44203722","0.4416991","0.44120565","0.44036326","0.43993536","0.43989527","0.43977252","0.43953997","0.43872645","0.43844867","0.43843687","0.43803078","0.4377362","0.4372428","0.43720967","0.4370016","0.436922","0.4364599","0.43645748","0.43563122","0.43547317","0.43547317","0.43541202","0.43519944","0.43463445","0.43445992","0.4343251","0.4333189","0.43227306","0.43202025","0.4318961","0.43172774","0.43112725","0.4310406","0.43090057","0.43087313","0.4293852","0.42901105","0.42877117","0.4285546","0.4281502","0.4281165","0.42775962","0.42761612","0.42747328","0.4272581","0.42700475"],"string":"[\n \"0.5175448\",\n \"0.5125011\",\n \"0.50932604\",\n \"0.49715528\",\n \"0.49012083\",\n \"0.48026282\",\n \"0.48011735\",\n \"0.47937286\",\n \"0.47771695\",\n \"0.47705403\",\n \"0.47160998\",\n \"0.47139278\",\n \"0.47057864\",\n \"0.47034556\",\n \"0.46948606\",\n \"0.46944666\",\n \"0.4689189\",\n \"0.4687901\",\n \"0.46823987\",\n \"0.46695173\",\n \"0.46665677\",\n \"0.46463287\",\n \"0.463197\",\n \"0.46269512\",\n \"0.4620182\",\n \"0.46178904\",\n \"0.45858875\",\n \"0.45800152\",\n \"0.45725527\",\n \"0.4569992\",\n \"0.45544326\",\n \"0.45480514\",\n \"0.45269108\",\n \"0.4525998\",\n \"0.45201433\",\n \"0.45127243\",\n \"0.45118624\",\n \"0.45112488\",\n \"0.45078596\",\n \"0.44948262\",\n \"0.44833893\",\n \"0.44823077\",\n \"0.44818032\",\n \"0.44817612\",\n \"0.4473151\",\n \"0.44662607\",\n \"0.4458843\",\n \"0.44405934\",\n \"0.4435481\",\n \"0.44307458\",\n \"0.44301102\",\n \"0.4429004\",\n \"0.442173\",\n \"0.44203722\",\n \"0.4416991\",\n \"0.44120565\",\n \"0.44036326\",\n \"0.43993536\",\n \"0.43989527\",\n \"0.43977252\",\n \"0.43953997\",\n \"0.43872645\",\n \"0.43844867\",\n \"0.43843687\",\n \"0.43803078\",\n \"0.4377362\",\n \"0.4372428\",\n \"0.43720967\",\n \"0.4370016\",\n \"0.436922\",\n \"0.4364599\",\n \"0.43645748\",\n \"0.43563122\",\n \"0.43547317\",\n \"0.43547317\",\n \"0.43541202\",\n \"0.43519944\",\n \"0.43463445\",\n \"0.43445992\",\n \"0.4343251\",\n \"0.4333189\",\n \"0.43227306\",\n \"0.43202025\",\n \"0.4318961\",\n \"0.43172774\",\n \"0.43112725\",\n \"0.4310406\",\n \"0.43090057\",\n \"0.43087313\",\n \"0.4293852\",\n \"0.42901105\",\n \"0.42877117\",\n \"0.4285546\",\n \"0.4281502\",\n \"0.4281165\",\n \"0.42775962\",\n \"0.42761612\",\n \"0.42747328\",\n \"0.4272581\",\n \"0.42700475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5852458"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14799,"cells":{"query":{"kind":"string","value":"Compute the check digit for an ISO 6346 code without that digit"},"document":{"kind":"string","value":"def check_digit(raw_code):\n s = sum(code(char) * 2**index for index, char in enumerate(raw_code))\n return s % 11 % 10"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def checkdigit(code):\n check = sum((i+1)*int(code[i]) for i in range(9)) % 11\n return 'X' if check == 10 else str(check)","def calc_check_digit_issn(issn):\n\n total = 0\n lissn = list(issn.replace('-', ''))\n\n for i, v in enumerate(lissn[:-1]):\n total = total + ((8-i) * int(v))\n\n remainder = total % 11\n\n if not remainder:\n check_digit = 0\n else:\n check_digit = 11 - remainder\n\n return 'X' if check_digit == 10 else str(check_digit)","def calculate_issn_checkdigit(s):\n if len(s) != 7:\n raise ValueError('seven digits required')\n ss = sum([int(digit) * f for digit, f in zip(s, range(8, 1, -1))])\n _, mod = divmod(ss, 11)\n checkdigit = 0 if mod == 0 else 11 - mod\n if checkdigit == 10:\n checkdigit = 'X'\n return '{}'.format(checkdigit)","def evalute_number(dialed):\n if (len(dialed) == 11 or len(dialed) == 10) and str(dialed).startswith(\"0\"):\n # UK Number\n return \"+44%s\" % (dialed[1:])\n elif len(dialed) == 6:\n # Local Fishguard numbers\n return \"+441348%s\" % (dialed)\n return None","def calc_check_digit(number):\n number = compact(number)\n alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n weights = (29, 23, 19, 17, 13, 7, 5, 3)\n if not isdigits(number):\n number = number[0] + str('ABCEHKMOPT'.index(number[1])) + number[2:]\n c = sum(w * alphabet.index(n) for w, n in zip(weights, number)) % 11\n if c > 9:\n raise InvalidChecksum()\n return str(c)","def issuer(number):\n res = \"unknown\"\n num = str(number)\n if num[:1]==\"4\":\n res = \"Visa\"\n elif num[:2] in (\"34\",\"37\"):\n res = \"American Express\"\n elif num[:2] in (\"51\",\"55\"):\n res = \"MasterCard\"\n elif num[:4]==\"6011\":\n res = \"Discover/Novus\"\n return res","def mpc2internal(self,Code):\n if (Code.isdigit()):\n internal_code=int(Code)\n else:\n internal_code=(ord(Code[0])-55)*100+int(Code[1:])\n internal_code = -internal_code\n return (internal_code)","def _orcid_checksum_digit(orcid):\n total = 0\n digits = [int(ch) for ch in orcid.replace(\"-\", \"\")]\n for digit in digits:\n total = (total + digit) * 2\n remainder = total % 11\n result = (12 - remainder) % 11\n\n if result == 10:\n return \"X\"\n\n return str(result)","def _select_market_code(code):\n code = str(code)\n if code[0] in ['5', '6', '9'] or code[:3] in [\"009\", \"126\", \"110\", \"201\", \"202\", \"203\", \"204\"]:\n return 1\n return 0","def mpc2internal(self,Code):\n \n if (Code.isdigit()):\n internal_code=int(Code)\n\n else:\n internal_code=(ord(Code[0])-55)*100+int(Code[1:])\n\n internal_code = -internal_code\n return (internal_code)","def check_digits_cpf(x: str, n: int) -> int:\n check_vec = np.flip(np.arange(2, 10 + n))\n digits = np.array(list(x[: 8 + n])).astype(\"int\")\n result = np.dot(check_vec, digits) % 11\n\n return 0 if result < 2 else 11 - result","def code_format(self):\n return \"^\\\\d{%s}$\" % self._digits","def test_luhn_checksum(self):\n check_digit = calculate_luhn(\"7992739871\")\n assert check_digit == 3","def calculate_luhn_check_digit(partial_card_number):\n checksum = luhn_checksum(int(partial_card_number) * 10)\n if checksum == 0:\n check_digit = 0\n else:\n check_digit = 10 - checksum\n return check_digit","def safe_number(self):\n mask = '*' * (len(self.card_number) - 4)\n return '{0}{1}'.format(mask, self.card_number[-4:])","def check_converted_account(converted_account):\r\n checksum = 0\r\n if \"?\" in converted_account:\r\n return str(converted_account) + \" ILL\"\r\n else:\r\n for i,j in zip(converted_account, range(1,10)):\r\n checksum += int(i) * j\r\n if (checksum % 11) == 0:\r\n return str(converted_account)\r\n else:\r\n return str(converted_account) + \" ERR\"","def check_and_repair_right_format(self, digit):\n if digit in one_digit_number:\n digit = '0' + digit\n return digit","def ean_check_digit(ean):\n return (10 - (sum((2 + (-1) ** x) * y for (x, y) in enumerate(ean,\n start=1)) % 10)) % 10","def istele(number):\n if number[:3] == '140':\n return True\n return False","def _validate_bank_operation_code_23B(self, val):\n return val","def _validate_intermediary_institution_56D(self, val):\n return val","def valid_checkdigit(ccnum):\n\n sum = 0\n num_digits = len(ccnum)\n oddeven = num_digits & 1\n\n for count in range(0, num_digits):\n digit = int(ccnum[count])\n\n if not ((count & 1) ^ oddeven):\n digit = digit * 2\n if digit > 9:\n digit = digit - 9\n\n sum = sum + digit\n\n return ((sum % 10) == 0)","def is_istc(val):\n val = val.replace(\"-\", \"\").replace(\" \", \"\").upper()\n if len(val) != 16:\n return False\n sequence = [11, 9, 3, 1]\n try:\n r = sum([int(x, 16) * sequence[i % 4] for i, x in enumerate(val[:-1])])\n ck = hex(r % 16)[2:].upper()\n return ck == val[-1]\n except ValueError:\n return False","def is_code_has_unknown_digit(processed_code):\n return True if list(processed_code).count(\"?\") == 0 else False","def test_valid_luhn(self):\n assert luhn_checksum(\"79927398713\") == 0","def fn(c):\n ans = 0\n for k in range(1, 16): \n ans = min(ans, k*16+k, key=lambda x: abs(x - int(c, 16)))\n return hex(ans)[2:].zfill(2)","def check_digit(tracking_number):\n check_digit = 10 - ((sum(itertools.starmap(operator.mul, zip(itertools.cycle((3, 1)), map(int, str(tracking_number))))) + 1) % 10)\n if check_digit == 10:\n check_digit = 0\n return check_digit","def get_four_digit_code(self):\n return (\n self.subhead[\"New_Code\"].str[0:2] + \".\" + self.subhead[\"New_Code\"].str[2:4]\n )","def luhn_checksum(num: str) -> str:\n check = 0\n for i, s in enumerate(reversed(num)):\n sx = int(s)\n if i % 2 == 0:\n sx *= 2\n if sx > 9:\n sx -= 9\n check += sx\n return str(check * 9 % 10)","def isbn_10_check_digit(nine_digits):\r\n if len(nine_digits) != 9: return None\r\n try: int(nine_digits)\r\n except: return None\r\n remainder = int(sum((i + 2) * int(x) for i, x in enumerate(reversed(nine_digits))) % 11)\r\n if remainder == 0: tenth_digit = 0\r\n else: tenth_digit = 11 - remainder\r\n if tenth_digit == 10: tenth_digit = 'X'\r\n return str(tenth_digit)","def test_cpf_is_digit(self):\r\n form = self.make_validated_form(cpf='asdfesa1234')\r\n self.assertFormErrorCode(form, 'cpf', 'digits')","def isbn_check_digit(isbn):\n return (11 - (sum(x * y for (x, y) in enumerate(reversed(isbn), start=2))\n % 11)) % 11","def _remove_area_code(phone):\n\n if not phone.startswith('+46'):\n return phone\n else:\n return '0' + phone[3:]","def isbn_13_check_digit(twelve_digits):\r\n if len(twelve_digits) != 12: return None\r\n try: int(twelve_digits)\r\n except: return None\r\n thirteenth_digit = 10 - int(sum((i % 2 * 2 + 1) * int(x) for i, x in enumerate(twelve_digits)) % 10)\r\n if thirteenth_digit == 10: thirteenth_digit = '0'\r\n return str(thirteenth_digit)","def convert_physician_diagnoses_code(diagnoses_code):\n if diagnoses_code in ICD_9_DEFAULT_CODES_FOR_DIAGNOSIS:\n diagnoses_icd_9_code = \\\n ICD_9_DEFAULT_CODES_FOR_DIAGNOSIS.get(diagnoses_code)\n if diagnoses_icd_9_code in \\\n (\"Blank\", \"Blank diagnosis\", \"Diagnosis of 'none'\",\n \"Noncodable diagnosis\", \"Noncodable\", \"Illegible diagnosis\"):\n return \"\"\n return diagnoses_icd_9_code\n\n # 1975-76 - Instead of a \"Y\" to prefix codes in the supplementary\n # classification, an ampersand (&) was used\n # 1977 - 78 - Same as above, except that the prefix character is a dash(-)\n # For year 1973 till 1978 `diagnoses_code` is 4 length character\n if len(diagnoses_code) < 5 and (\n diagnoses_code.startswith(\"&\") or diagnoses_code.startswith(\"-\")\n or diagnoses_code.startswith(\"Y\")\n ):\n diagnoses_code = \"V{}\".format(diagnoses_code[1:])\n\n # Character format\n # For inapplicable fourth or fifth digits, a dash is inserted.\n # 0010[-] - V829[-] = 001.0[0]-V82.9[0]\n elif \"-\" in diagnoses_code[3:]:\n diagnoses_code = diagnoses_code.replace(\"-\", \"0\")\n # Reference from documentation:\n # -9 = Blank\n elif \"-00009\" in diagnoses_code:\n return \"\"\n\n # The prefix “1” preceding the 3-digit diagnostic codes represents\n # diagnoses 001-999, e.g. ‘1381’=’381’=otitis media. And “138100”=”381.00”\n if diagnoses_code.startswith(\"1\"):\n diagnoses_code = diagnoses_code.lstrip(\"1\")\n\n # The prefix “2” preceding the 3 - digit diagnostic codes represents \"V\"\n # code diagnoses VO1 - V82, e.g., ‘2010’=’V10’ and “201081” = “V10.81”\n elif diagnoses_code.startswith(\"2\"):\n if diagnoses_code.startswith(\"20\"):\n diagnoses_code = \"V{}\".format(diagnoses_code[2:])\n else:\n diagnoses_code = \"V{}\".format(diagnoses_code[1:])\n\n # There is an implied decimal between the third and fourth digits\n diagnoses_icd_9_code = \"{}.{}\".format(\n diagnoses_code[:3], diagnoses_code[3:]\n )\n\n return diagnoses_icd_9_code","def issn2int(issn_str):\n\n pat = r\"^\\d{4}-\\d{3}[\\dxX]$\"\n p = compile(pat)\n if p.match(issn_str):\n res = 0\n check = map(lambda x: int(x), issn_str[:4] + issn_str[5:8])\n check_bit = int(issn_str[-1]) if is_int(issn_str[-1]) else issn_str[-1]\n for pp in zip(check, range(8, 1, -1)):\n res += pp[0] * pp[1]\n\n rem = (11 - res) % 11\n rem = \"X\" if rem == 10 else rem\n\n if rem == check_bit:\n return int(issn_str[0:4] + issn_str[5:8])\n else:\n logging.error(\n \" issn2int() : in issn {0} \" \"check bit is corrupt\".format(issn_str)\n )\n logging.error(\" equal to {0}, should be {1}\".format(check_bit, rem))\n # raise ValueError(' issn2int(): invalid check digit'.format(check_bit, rem))\n return int(issn_str[0:4] + issn_str[5:8])\n\n else:\n logging.error(\n \" issn2int() : issn {0} : does not match \"\n \"the pattern {1}\".format(issn_str, pat)\n )\n\n raise ValueError(\" issn2int(): invalid issn string\")","def test_invalid_luhn(self):\n assert luhn_checksum(\"79927398714\") != 0","def sanitize_ean13(ean13):\n if not ean13:\n return \"0000000000000\"\n ean13 = re.sub(\"[A-Za-z]\",\"0\",ean13);\n ean13 = re.sub(\"[^0-9]\",\"\",ean13);\n ean13 = ean13[:13]\n if len(ean13) < 13:\n ean13 = ean13 + '0' * (13-len(ean13))\n return ean13[:-1] + str(ean_checksum(ean13))","def clean_number_plate(self, vrn):\n cleaned = re.sub(r'[^\\dA-Z]', '', vrn)\n\n if re.match(r'^[A-Z]{2}', cleaned) and len(cleaned) == 7:\n if cleaned[2] == 'O':\n cleaned = cleaned[:2] + '0' + cleaned[3:]\n if cleaned[2] == 'I':\n cleaned = cleaned[:2] + '1' + cleaned[3:]\n if cleaned[3] == 'O':\n cleaned = cleaned[:3] + '0' + cleaned[4:]\n if cleaned[3] == 'I':\n cleaned = cleaned[:3] + '1' + cleaned[4:]\n\n if re.match(r'^B', cleaned) and len(cleaned) == 7:\n if cleaned[1] == 'O':\n cleaned = cleaned[:1] + '0' + cleaned[2:]\n if cleaned[1] == 'I':\n cleaned = cleaned[:1] + '1' + cleaned[2:]\n if cleaned[2] == 'O':\n cleaned = cleaned[:2] + '0' + cleaned[3:]\n if cleaned[2] == 'I':\n cleaned = cleaned[:2] + '1' + cleaned[3:]\n if cleaned[3] == 'O':\n cleaned = cleaned[:3] + '0' + cleaned[4:]\n if cleaned[3] == 'I':\n cleaned = cleaned[:3] + '1' + cleaned[4:]\n\n if re.match(r'^[A-Z]{2}', cleaned) and len(cleaned) == 8:\n if cleaned[0] == 'Y':\n cleaned = 'V' + cleaned[1:]\n if cleaned[1] == 'Y':\n cleaned = cleaned[0] + 'V' + cleaned[2:]\n\n return cleaned","def is_isni(val):\n val = val.replace(\"-\", \"\").replace(\" \", \"\").upper()\n if len(val) != 16:\n return False\n try:\n r = 0\n for x in val[:-1]:\n r = (r + int(x)) * 2\n ck = (12 - r % 11) % 11\n return ck == _convert_x_to_10(val[-1])\n except ValueError:\n return False","def enc_suffix(suf):\n if len(suf) == 0:\n return 0\n r0 = base34.find(suf[0])\n if len(suf) == 1:\n r1 = 0\n else:\n r1 = base34.find(suf[1]) + 1\n if r0 < 24: # first char is a letter, use base 25\n return r0 * 25 + r1 + 1\n else: # first is a number -- base 35.\n return r0 * 35 + r1 - 239","def safe_number(self):\n mask = '*' * (len(self.account_number) - 4)\n return '{0}{1}'.format(mask, self.account_number[-4:])","def checkio(str_number, radix):\n list_str_num = list(str_number)\n power = 0\n result = 0\n for i in range(len(list_str_num)):\n str_num = list_str_num[len(list_str_num) -1 - i]\n if str_num.isdigit():\n num = int(str_num)\n else:\n num = (ord(str_num) - 55)\n if num >= radix:\n return -1\n result += num * (radix ** i)\n return result","def _validate_account_with_institution_57C(self, val):\n return val","def test_is_old_papernum(self):\n self.assertFalse(util.is_old_papernum(\"9106001\"))\n self.assertTrue(util.is_old_papernum(\"9107001\"))\n self.assertFalse(util.is_old_papernum(\"9200001\"))\n self.assertTrue(util.is_old_papernum(\"9201001\"))\n self.assertTrue(util.is_old_papernum(\"0703999\"))\n self.assertFalse(util.is_old_papernum(\"0704001\"))","def check_digits_cnpj(x: str, n: int) -> int:\n check_vec = np.array([6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2])\n digits = np.array(list(x[: -3 + n])).astype(\"int\")\n result = np.dot(check_vec[2 - n :], digits) % 11\n\n return 0 if result < 2 else 11 - result","def luhn_verifica(ccred):\n \n # Primeiro criamos uma nova cadeia, n, com os digitos do cartao de credito sem o de controle.\n # Usamos a funcao calc_soma para somar os digitos do cartao de acordo com o algoritmo de Luhn e juntamos o digito de controle. Caso este ultimo nao seja um algarismo, chamamos a atencao ao utilizador para o erro.\n # Caso o resto da divisao por 10 seja 0, a funcao devolve o valor logico True. \n \n\n n = ccred[:-1]\n dig_verificacao = ccred[-1]\n \n if '0' <= dig_verificacao <= '9':\n soma = calc_soma(n) + eval(dig_verificacao)\n \n else:\n raise ValueError ('function luhn_verifica() O string recebido apenas pode conter digitos') \n \n return soma % 10 == 0","def test_digit_14_min_base(self):\n expected = 6\n digit = 14\n\n assert expected == min_base(digit)","def convert_to_3digit_icd9(dx_str):\n\n if dx_str.startswith(\"E\"):\n if len(dx_str) > 4:\n return dx_str[:4]\n else:\n return dx_str\n else:\n if len(dx_str) > 3:\n return dx_str[:3]\n else:\n return dx_str","def utf8(num):\n # code de la prof louche\n if num < 8:\n return 1\n else:\n return num//6+1\n\n return binary","def _get_random_number_code(self):\r\n return \"str(random.randint(0, 1e9))\"","def card(n):\r\n assert type(n) == int and n > 0 and n <= 13, \"Bad card n\"\r\n specials = {1: 'A', 11: 'J', 12: 'Q', 13: 'K'}\r\n return specials.get(n, str(n))","def oracle(ct: int) -> bool:\n return rsa.dec(ct) & 1 == 0","def _get_checksum(code: str) -> int:\r\n total = 0\r\n\r\n for index, digit in enumerate(code):\r\n digit = int(digit)\r\n if (index + 1) % 2 != 0:\r\n digit *= 2\r\n if digit > 9:\r\n digit -= 9\r\n total += digit\r\n\r\n checksum = 10 - total % 10\r\n\r\n return checksum if checksum != 10 else 0","def _validate_contract_number_partyA_21N(self, val):\n return val","def is_valid_control_number(id_code: str) -> bool:\n sum = 1 * int(id_code[:1]) + 2 * int(id_code[1:2]) + 3 * int(id_code[2:3]) + 4 * int(id_code[3:4]) + 5 * \\\n int(id_code[4:5]) + 6 * int(id_code[5:6]) + 7 * int(id_code[6:7]) + 8 * int(id_code[7:8]) + 9 *\\\n int(id_code[8:9]) + 1 * int(id_code[9:10])\n control_number = sum % 11\n if int(control_number) == int(id_code[10:11]):\n return True\n elif int(control_number) == 10:\n sum = 3 * int(id_code[:1]) + 4 * int(id_code[1:2]) + 5 * int(id_code[2:3]) + 6 * int(id_code[3:4]) + 7 * \\\n int(id_code[4:5]) + 8 * int(id_code[5:6]) + 9 * int(id_code[6:7]) + 1 * int(id_code[7:8]) + 2 * \\\n int(id_code[8:9]) + 3 * int(id_code[9:10])\n control_number = sum % 11\n if control_number == int(id_code[10:11]):\n return True\n elif control_number == 10:\n if int(id_code[10:11]) == 0:\n return True\n else:\n return False\n else:\n return False","def calculate_checksum(code):\n\n sum_odd = reduce(sum_chars, code[::2])\n sum_even = reduce(sum_chars, code[1:-1:2])\n check = (sum_even + sum_odd * 3) % 10\n\n if check == 0:\n return 0\n else:\n return 10 - check","def _validate_details_of_charges_71A(self, val):\n return val","def _mpc_lookup(x,packed_date):\n\n try:\n x = int(x)\n except ValueError:\n x = ord(x) - 55\n if x < 0 or x > 31:\n print(packed_date)\n raise ValueError\n return x","def calc_check_digit(number):\n weights = (2, 4, 8, 5, 10, 9, 7, 3, 6)\n return str(sum(w * int(n) for w, n in zip(weights, number)) % 11 % 10)","def check_identity(input_string: str) -> str:\n n = input_string[2]\n if n == '6':\n return 'a foreigner with nationality'\n elif n == '7':\n return 'a national without household registration'\n elif n == '8':\n return 'from Hong Kong or Macau'\n elif n == '9':\n return 'from China'\n elif n == '0' \\\n or n == '1' \\\n or n == '2' \\\n or n == '3' \\\n or n == '4' \\\n or n == '5':\n return 'a normal national'\n else:\n # Should not happen\n return None","def get_country_dcid(country_code: str) -> str:\n numeric_code = int(country_code, 10)\n if numeric_code in UN_COUNTRY_CODES:\n return UN_COUNTRY_CODES[numeric_code]\n return None","def is_valid_two_digit_char(code: str) -> bool:\n\n return 10 <= int(code) <= 26","def area_code(self):\n return self.number[:3]","def CODE(string):\n return ord(string[0])","def validate(number):\n number = compact(number)\n if len(number) != 9:\n raise InvalidLength()\n if not isdigits(number[2:]):\n raise InvalidFormat()\n if not isdigits(number[:2]) and not all(x in 'ABCEHKMOPT' for x in number[:2]):\n raise InvalidFormat()\n if number[0] not in '1234567ABCEHKM':\n raise InvalidComponent()\n if number[-1] != calc_check_digit(number):\n raise InvalidChecksum()\n return number","def country(alpha_2_code: str) -> None:","def _validate_account_with_institution_57D(self, val):\n return val","def generate_game_code() -> int:\n while True:\n # code will only contain digits\n code_options = string.digits\n generated_game_code = ''.join(secrets.choice(code_options) for i in range(7))\n if Game.objects.filter(game_code=generated_game_code).count() == 0:\n break\n return int(generated_game_code)","def ck(value):\n return chr(value)","def _get_det_id(self, source):\n match = re.match(r\"Camp\\.0:pnCCD\\.(\\d)\", source)\n number = str.zfill(match.groups()[0], 4)\n return \"pnccd_\" + number","def fix_RFID(r):\n #f = str(r).strip()\n #while f[0] == '0':\n # f = f[1:]\n return int(r)","def _hexchar(c):\n if c == '1': return 1\n if c == '2': return 2\n if c == '3': return 3\n if c == '4': return 4\n if c == '5': return 5\n if c == '6': return 6\n if c == '7': return 7\n if c == '8': return 8\n if c == '9': return 9\n if c == 'A' or c == 'a': return 10\n if c == 'B' or c == 'b': return 11\n if c == 'C' or c == 'c': return 12\n if c == 'D' or c == 'd': return 13\n if c == 'E' or c == 'e': return 14\n if c == 'F' or c == 'f': return 15\n return 0","def verify(isbn):\n\n isbn = isbn.replace(\"-\", \"\")\n if not verify_format(isbn):\n return False\n\n isbn_sum = 0\n for digit, i in zip(isbn, range(10, 0, -1)):\n if digit == \"X\":\n isbn_sum += 10 * i\n else:\n isbn_sum += int(digit) * i\n\n return isbn_sum % 11 == 0","def is_sedol(value):\n return re.match(r'^[0-9BCDFGHJKLMNPQRSTVWXYZ]{6}\\d$', value)","def generate_new_code():\n code = ''.join(random.choice(string.digits) for i in range(6))\n return code","def checksum(n):\n\n # Compute the sum of the non-check digits.\n s = sum(luhn_digits(n * 10))\n\n # Multiply by 9.\n result = s * 9\n\n # The units digit is the check digit\n check_digit = result % 10\n\n m = int(str(n) + str(check_digit))\n assert(verify(m))\n\n return check_digit","def convert_UPCE_to_UPCA(upce_value):\n if len(upce_value) == 6:\n middle_digits = upce_value # assume we're getting just middle 6 digits\n elif len(upce_value) == 7:\n # truncate last digit, assume it is just check digit\n middle_digits = upce_value[:6]\n elif len(upce_value) == 8:\n # truncate first and last digit,\n # assume first digit is number system digit\n # last digit is check digit\n middle_digits = upce_value[1:7]\n else:\n return False\n d1, d2, d3, d4, d5, d6 = list(middle_digits)\n if d6 in [\"0\", \"1\", \"2\"]:\n mfrnum = d1 + d2 + d6 + \"00\"\n itemnum = \"00\" + d3 + d4 + d5\n elif d6 == \"3\":\n mfrnum = d1 + d2 + d3 + \"00\"\n itemnum = \"000\" + d4 + d5\n elif d6 == \"4\":\n mfrnum = d1 + d2 + d3 + d4 + \"0\"\n itemnum = \"0000\" + d5\n else:\n mfrnum = d1 + d2 + d3 + d4 + d5\n itemnum = \"0000\" + d6\n newmsg = \"0\" + mfrnum + itemnum\n # calculate check digit, they are the same for both UPCA and UPCE\n check_digit = calc_check_digit(newmsg)\n return newmsg + str(check_digit)","def decode(code):\n def h(x):\n hs = []\n for i in range(len(code)):\n if code[i] != '0' and (code[i] == '?' or code[i] == x[i]):\n hs.append(True)\n else:\n hs.append(False)\n return all(hs)\n return h","def _algorithm(self, rut):\n suma = 0\n multi = 2\n for r in rut[::-1]:\n suma += int(r) * multi\n multi += 1\n if multi == 8:\n multi = 2\n return u'0123456789K0'[11 - suma % 11]","def getAAAZZZSId(self):\n if self.element.symbol == \"C\":\n return \"120060\"\n elif self.element.symbol == \"V\":\n return \"510230\"\n else:\n return None","def get_seat_id(boarding_pass):\n return int(re.sub(\"[FL]\", \"0\", re.sub(\"[BR]\", \"1\", boarding_pass)), 2)","def clean_phone(number):\n numberlist = re.findall(\"\\d\",number)\n new_number = \"\".join(numberlist)\n if len(new_number) == 8:\n \tnew_number = \"010\" + new_number\n\tnew_number = new_number[-11:]\n\tif new_number.startswith('1'):\n\t\tnew_number = \"+86-\" + new_number\n\telse:\n\t\tnew_number = \"+86-10-\" + new_number[-8:]\n\treturn new_number","def test_cpf_has_11_digits(self):\r\n form = self.make_validated_form(cpf='1234')\r\n self.assertFormErrorCode(form, 'cpf', 'length')","def code(char):\n return int(char) if char.isdigit() else letter_code(char)","def octet(n):\n\t\n\treturn n & 0b11111111","def _format_bank_operation_code_23B(self, val):\n return val","def getCurrencyIsoCode(id=None):","def check_for_int(check):","def _validate_instruction_code_23E(self, val):\n validate_instruction_code(val)\n return val","def validate_CPF(value):\n\t\tif value in EMPTY_VALUES:\n\t\t\treturn u''\n\t\tif not value.isdigit():\n\t\t\tvalue = re.sub(\"[-\\.]\", \"\", value)\n\t\torig_value = value[:]\n\t\ttry:\n\t\t\tint(value)\n\t\texcept ValueError:\n\t\t\treturn False\n\t\tif len(value) != 11 or value == \"00000000000\" or value == \"11111111111\" or value == \"22222222222\" or value == \"33333333333\" or \\\n\t\t\tvalue == \"44444444444\" or value == \"55555555555\" or value == \"66666666666\" or value == \"77777777777\" or \\\n\t\t\tvalue == \"88888888888\" or value == \"99999999999\":\n\t\t\t\n\t\t\treturn False\n\n\t\torig_dv = value[-2:]\n\n\t\tnew_1dv = sum([i * int(value[idx]) for idx, i in enumerate(range(10, 1, -1))])\n\t\tnew_1dv = DV_maker(new_1dv % 11)\n\t\tvalue = value[:-2] + str(new_1dv) + value[-1]\n\t\tnew_2dv = sum([i * int(value[idx]) for idx, i in enumerate(range(11, 1, -1))])\n\t\tnew_2dv = DV_maker(new_2dv % 11)\n\t\tvalue = value[:-1] + str(new_2dv)\n\t\tif value[-2:] != orig_dv:\n\t\t\treturn False \n\n\n\t\treturn orig_value","def valid_barcode(s):\n # implement this function!\n odd_digits = 0\n even_digits = 0\n result = 0\n for i in range(len(s) - 1):\n if i % 2 == 0:\n odd_digits += int(s[i])\n else:\n even_digits += int(s[i])\n result = (3 * odd_digits + even_digits) % 10\n if result != 0:\n result = 10 - result\n\n try:\n if int(s[-1]) == result and len(s) == 12:\n return True\n else:\n return False\n except IndexError:\n return False","def encode_identifier(alphabet, n):\r\n c = alphabet[n & 0b1111]\r\n n>>=4\r\n while n > 0:\r\n c = c + alphabet[n & 0b111111]\r\n n>>=6\r\n return c","def Detect_network(num):\n\tif num.isdigit():\n\t\tif num.startswith(\"077\") or num.startswith(\"078\"):\n\t\t\treturn \"MTN\"\n\t\tif num.startswith(\"075\") or num.startswith(\"070\"):\n\t\t\treturn\"Airtel\"\n\t\tif num.startswith(\"079\"):\n\t\t\treturn \"Africel\"\n\t\tif num.startswith(\"074\"):\n\t\t\treturn \"Smart\"\n\t\tif num.startswith(\"071\"):\n\t\t\treturn \"UTL\"\n\t\tif num.startswith(\"073\"):\n\t\t\treturn \"K2\"\t\n\t\telse:\n\t\t\treturn \"Others\"\t\n\telse:\n\t\treturn \"Invalid\"","def test_mode_digit():\n print('Testing mode_digit')\n\n # Cases given to test this problem\n assert_equals(1, hw1.mode_digit(12121))\n assert_equals(0, hw1.mode_digit(0))\n assert_equals(2, hw1.mode_digit(-122))\n assert_equals(2, hw1.mode_digit(1211232231))\n\n # Additional cases to test numbers with same digit occurance numbers\n assert_equals(3, hw1.mode_digit(-333000221))\n assert_equals(4, hw1.mode_digit(440011))","def create_checksum(self, fifteen_digit):\n duplicate_odd_digits = [int(fifteen_digit[i - 1]) * 2 if i % 2 else\n int(fifteen_digit[i - 1]) for i in range(1, 16)]\n subtract_nine = [digit - 9 if digit > 9 else digit for digit in duplicate_odd_digits]\n sum_up = sum(subtract_nine)\n return (10 - sum_up % 10) % 10","def is_not_used(code):\n return 0 <= code <= 999","def alpha_number(alpha):\r\n if alpha.isupper() == False:\r\n num = ord(alpha) - 96\r\n return num\r\n elif alpha.isupper() == True:\r\n num = ord(alpha) - 64\r\n return num","def test_cpf_is_digit(self):\n form = self.make_validated_form(cpf='ABCD5678901')\n self.assertFormErrorMessage(form, 'cpf', 'digits')","def y2k_coding(n):\n if n < 60:\n return 2000 + n\n else:\n return 1900 + n"],"string":"[\n \"def checkdigit(code):\\n check = sum((i+1)*int(code[i]) for i in range(9)) % 11\\n return 'X' if check == 10 else str(check)\",\n \"def calc_check_digit_issn(issn):\\n\\n total = 0\\n lissn = list(issn.replace('-', ''))\\n\\n for i, v in enumerate(lissn[:-1]):\\n total = total + ((8-i) * int(v))\\n\\n remainder = total % 11\\n\\n if not remainder:\\n check_digit = 0\\n else:\\n check_digit = 11 - remainder\\n\\n return 'X' if check_digit == 10 else str(check_digit)\",\n \"def calculate_issn_checkdigit(s):\\n if len(s) != 7:\\n raise ValueError('seven digits required')\\n ss = sum([int(digit) * f for digit, f in zip(s, range(8, 1, -1))])\\n _, mod = divmod(ss, 11)\\n checkdigit = 0 if mod == 0 else 11 - mod\\n if checkdigit == 10:\\n checkdigit = 'X'\\n return '{}'.format(checkdigit)\",\n \"def evalute_number(dialed):\\n if (len(dialed) == 11 or len(dialed) == 10) and str(dialed).startswith(\\\"0\\\"):\\n # UK Number\\n return \\\"+44%s\\\" % (dialed[1:])\\n elif len(dialed) == 6:\\n # Local Fishguard numbers\\n return \\\"+441348%s\\\" % (dialed)\\n return None\",\n \"def calc_check_digit(number):\\n number = compact(number)\\n alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\\n weights = (29, 23, 19, 17, 13, 7, 5, 3)\\n if not isdigits(number):\\n number = number[0] + str('ABCEHKMOPT'.index(number[1])) + number[2:]\\n c = sum(w * alphabet.index(n) for w, n in zip(weights, number)) % 11\\n if c > 9:\\n raise InvalidChecksum()\\n return str(c)\",\n \"def issuer(number):\\n res = \\\"unknown\\\"\\n num = str(number)\\n if num[:1]==\\\"4\\\":\\n res = \\\"Visa\\\"\\n elif num[:2] in (\\\"34\\\",\\\"37\\\"):\\n res = \\\"American Express\\\"\\n elif num[:2] in (\\\"51\\\",\\\"55\\\"):\\n res = \\\"MasterCard\\\"\\n elif num[:4]==\\\"6011\\\":\\n res = \\\"Discover/Novus\\\"\\n return res\",\n \"def mpc2internal(self,Code):\\n if (Code.isdigit()):\\n internal_code=int(Code)\\n else:\\n internal_code=(ord(Code[0])-55)*100+int(Code[1:])\\n internal_code = -internal_code\\n return (internal_code)\",\n \"def _orcid_checksum_digit(orcid):\\n total = 0\\n digits = [int(ch) for ch in orcid.replace(\\\"-\\\", \\\"\\\")]\\n for digit in digits:\\n total = (total + digit) * 2\\n remainder = total % 11\\n result = (12 - remainder) % 11\\n\\n if result == 10:\\n return \\\"X\\\"\\n\\n return str(result)\",\n \"def _select_market_code(code):\\n code = str(code)\\n if code[0] in ['5', '6', '9'] or code[:3] in [\\\"009\\\", \\\"126\\\", \\\"110\\\", \\\"201\\\", \\\"202\\\", \\\"203\\\", \\\"204\\\"]:\\n return 1\\n return 0\",\n \"def mpc2internal(self,Code):\\n \\n if (Code.isdigit()):\\n internal_code=int(Code)\\n\\n else:\\n internal_code=(ord(Code[0])-55)*100+int(Code[1:])\\n\\n internal_code = -internal_code\\n return (internal_code)\",\n \"def check_digits_cpf(x: str, n: int) -> int:\\n check_vec = np.flip(np.arange(2, 10 + n))\\n digits = np.array(list(x[: 8 + n])).astype(\\\"int\\\")\\n result = np.dot(check_vec, digits) % 11\\n\\n return 0 if result < 2 else 11 - result\",\n \"def code_format(self):\\n return \\\"^\\\\\\\\d{%s}$\\\" % self._digits\",\n \"def test_luhn_checksum(self):\\n check_digit = calculate_luhn(\\\"7992739871\\\")\\n assert check_digit == 3\",\n \"def calculate_luhn_check_digit(partial_card_number):\\n checksum = luhn_checksum(int(partial_card_number) * 10)\\n if checksum == 0:\\n check_digit = 0\\n else:\\n check_digit = 10 - checksum\\n return check_digit\",\n \"def safe_number(self):\\n mask = '*' * (len(self.card_number) - 4)\\n return '{0}{1}'.format(mask, self.card_number[-4:])\",\n \"def check_converted_account(converted_account):\\r\\n checksum = 0\\r\\n if \\\"?\\\" in converted_account:\\r\\n return str(converted_account) + \\\" ILL\\\"\\r\\n else:\\r\\n for i,j in zip(converted_account, range(1,10)):\\r\\n checksum += int(i) * j\\r\\n if (checksum % 11) == 0:\\r\\n return str(converted_account)\\r\\n else:\\r\\n return str(converted_account) + \\\" ERR\\\"\",\n \"def check_and_repair_right_format(self, digit):\\n if digit in one_digit_number:\\n digit = '0' + digit\\n return digit\",\n \"def ean_check_digit(ean):\\n return (10 - (sum((2 + (-1) ** x) * y for (x, y) in enumerate(ean,\\n start=1)) % 10)) % 10\",\n \"def istele(number):\\n if number[:3] == '140':\\n return True\\n return False\",\n \"def _validate_bank_operation_code_23B(self, val):\\n return val\",\n \"def _validate_intermediary_institution_56D(self, val):\\n return val\",\n \"def valid_checkdigit(ccnum):\\n\\n sum = 0\\n num_digits = len(ccnum)\\n oddeven = num_digits & 1\\n\\n for count in range(0, num_digits):\\n digit = int(ccnum[count])\\n\\n if not ((count & 1) ^ oddeven):\\n digit = digit * 2\\n if digit > 9:\\n digit = digit - 9\\n\\n sum = sum + digit\\n\\n return ((sum % 10) == 0)\",\n \"def is_istc(val):\\n val = val.replace(\\\"-\\\", \\\"\\\").replace(\\\" \\\", \\\"\\\").upper()\\n if len(val) != 16:\\n return False\\n sequence = [11, 9, 3, 1]\\n try:\\n r = sum([int(x, 16) * sequence[i % 4] for i, x in enumerate(val[:-1])])\\n ck = hex(r % 16)[2:].upper()\\n return ck == val[-1]\\n except ValueError:\\n return False\",\n \"def is_code_has_unknown_digit(processed_code):\\n return True if list(processed_code).count(\\\"?\\\") == 0 else False\",\n \"def test_valid_luhn(self):\\n assert luhn_checksum(\\\"79927398713\\\") == 0\",\n \"def fn(c):\\n ans = 0\\n for k in range(1, 16): \\n ans = min(ans, k*16+k, key=lambda x: abs(x - int(c, 16)))\\n return hex(ans)[2:].zfill(2)\",\n \"def check_digit(tracking_number):\\n check_digit = 10 - ((sum(itertools.starmap(operator.mul, zip(itertools.cycle((3, 1)), map(int, str(tracking_number))))) + 1) % 10)\\n if check_digit == 10:\\n check_digit = 0\\n return check_digit\",\n \"def get_four_digit_code(self):\\n return (\\n self.subhead[\\\"New_Code\\\"].str[0:2] + \\\".\\\" + self.subhead[\\\"New_Code\\\"].str[2:4]\\n )\",\n \"def luhn_checksum(num: str) -> str:\\n check = 0\\n for i, s in enumerate(reversed(num)):\\n sx = int(s)\\n if i % 2 == 0:\\n sx *= 2\\n if sx > 9:\\n sx -= 9\\n check += sx\\n return str(check * 9 % 10)\",\n \"def isbn_10_check_digit(nine_digits):\\r\\n if len(nine_digits) != 9: return None\\r\\n try: int(nine_digits)\\r\\n except: return None\\r\\n remainder = int(sum((i + 2) * int(x) for i, x in enumerate(reversed(nine_digits))) % 11)\\r\\n if remainder == 0: tenth_digit = 0\\r\\n else: tenth_digit = 11 - remainder\\r\\n if tenth_digit == 10: tenth_digit = 'X'\\r\\n return str(tenth_digit)\",\n \"def test_cpf_is_digit(self):\\r\\n form = self.make_validated_form(cpf='asdfesa1234')\\r\\n self.assertFormErrorCode(form, 'cpf', 'digits')\",\n \"def isbn_check_digit(isbn):\\n return (11 - (sum(x * y for (x, y) in enumerate(reversed(isbn), start=2))\\n % 11)) % 11\",\n \"def _remove_area_code(phone):\\n\\n if not phone.startswith('+46'):\\n return phone\\n else:\\n return '0' + phone[3:]\",\n \"def isbn_13_check_digit(twelve_digits):\\r\\n if len(twelve_digits) != 12: return None\\r\\n try: int(twelve_digits)\\r\\n except: return None\\r\\n thirteenth_digit = 10 - int(sum((i % 2 * 2 + 1) * int(x) for i, x in enumerate(twelve_digits)) % 10)\\r\\n if thirteenth_digit == 10: thirteenth_digit = '0'\\r\\n return str(thirteenth_digit)\",\n \"def convert_physician_diagnoses_code(diagnoses_code):\\n if diagnoses_code in ICD_9_DEFAULT_CODES_FOR_DIAGNOSIS:\\n diagnoses_icd_9_code = \\\\\\n ICD_9_DEFAULT_CODES_FOR_DIAGNOSIS.get(diagnoses_code)\\n if diagnoses_icd_9_code in \\\\\\n (\\\"Blank\\\", \\\"Blank diagnosis\\\", \\\"Diagnosis of 'none'\\\",\\n \\\"Noncodable diagnosis\\\", \\\"Noncodable\\\", \\\"Illegible diagnosis\\\"):\\n return \\\"\\\"\\n return diagnoses_icd_9_code\\n\\n # 1975-76 - Instead of a \\\"Y\\\" to prefix codes in the supplementary\\n # classification, an ampersand (&) was used\\n # 1977 - 78 - Same as above, except that the prefix character is a dash(-)\\n # For year 1973 till 1978 `diagnoses_code` is 4 length character\\n if len(diagnoses_code) < 5 and (\\n diagnoses_code.startswith(\\\"&\\\") or diagnoses_code.startswith(\\\"-\\\")\\n or diagnoses_code.startswith(\\\"Y\\\")\\n ):\\n diagnoses_code = \\\"V{}\\\".format(diagnoses_code[1:])\\n\\n # Character format\\n # For inapplicable fourth or fifth digits, a dash is inserted.\\n # 0010[-] - V829[-] = 001.0[0]-V82.9[0]\\n elif \\\"-\\\" in diagnoses_code[3:]:\\n diagnoses_code = diagnoses_code.replace(\\\"-\\\", \\\"0\\\")\\n # Reference from documentation:\\n # -9 = Blank\\n elif \\\"-00009\\\" in diagnoses_code:\\n return \\\"\\\"\\n\\n # The prefix “1” preceding the 3-digit diagnostic codes represents\\n # diagnoses 001-999, e.g. ‘1381’=’381’=otitis media. And “138100”=”381.00”\\n if diagnoses_code.startswith(\\\"1\\\"):\\n diagnoses_code = diagnoses_code.lstrip(\\\"1\\\")\\n\\n # The prefix “2” preceding the 3 - digit diagnostic codes represents \\\"V\\\"\\n # code diagnoses VO1 - V82, e.g., ‘2010’=’V10’ and “201081” = “V10.81”\\n elif diagnoses_code.startswith(\\\"2\\\"):\\n if diagnoses_code.startswith(\\\"20\\\"):\\n diagnoses_code = \\\"V{}\\\".format(diagnoses_code[2:])\\n else:\\n diagnoses_code = \\\"V{}\\\".format(diagnoses_code[1:])\\n\\n # There is an implied decimal between the third and fourth digits\\n diagnoses_icd_9_code = \\\"{}.{}\\\".format(\\n diagnoses_code[:3], diagnoses_code[3:]\\n )\\n\\n return diagnoses_icd_9_code\",\n \"def issn2int(issn_str):\\n\\n pat = r\\\"^\\\\d{4}-\\\\d{3}[\\\\dxX]$\\\"\\n p = compile(pat)\\n if p.match(issn_str):\\n res = 0\\n check = map(lambda x: int(x), issn_str[:4] + issn_str[5:8])\\n check_bit = int(issn_str[-1]) if is_int(issn_str[-1]) else issn_str[-1]\\n for pp in zip(check, range(8, 1, -1)):\\n res += pp[0] * pp[1]\\n\\n rem = (11 - res) % 11\\n rem = \\\"X\\\" if rem == 10 else rem\\n\\n if rem == check_bit:\\n return int(issn_str[0:4] + issn_str[5:8])\\n else:\\n logging.error(\\n \\\" issn2int() : in issn {0} \\\" \\\"check bit is corrupt\\\".format(issn_str)\\n )\\n logging.error(\\\" equal to {0}, should be {1}\\\".format(check_bit, rem))\\n # raise ValueError(' issn2int(): invalid check digit'.format(check_bit, rem))\\n return int(issn_str[0:4] + issn_str[5:8])\\n\\n else:\\n logging.error(\\n \\\" issn2int() : issn {0} : does not match \\\"\\n \\\"the pattern {1}\\\".format(issn_str, pat)\\n )\\n\\n raise ValueError(\\\" issn2int(): invalid issn string\\\")\",\n \"def test_invalid_luhn(self):\\n assert luhn_checksum(\\\"79927398714\\\") != 0\",\n \"def sanitize_ean13(ean13):\\n if not ean13:\\n return \\\"0000000000000\\\"\\n ean13 = re.sub(\\\"[A-Za-z]\\\",\\\"0\\\",ean13);\\n ean13 = re.sub(\\\"[^0-9]\\\",\\\"\\\",ean13);\\n ean13 = ean13[:13]\\n if len(ean13) < 13:\\n ean13 = ean13 + '0' * (13-len(ean13))\\n return ean13[:-1] + str(ean_checksum(ean13))\",\n \"def clean_number_plate(self, vrn):\\n cleaned = re.sub(r'[^\\\\dA-Z]', '', vrn)\\n\\n if re.match(r'^[A-Z]{2}', cleaned) and len(cleaned) == 7:\\n if cleaned[2] == 'O':\\n cleaned = cleaned[:2] + '0' + cleaned[3:]\\n if cleaned[2] == 'I':\\n cleaned = cleaned[:2] + '1' + cleaned[3:]\\n if cleaned[3] == 'O':\\n cleaned = cleaned[:3] + '0' + cleaned[4:]\\n if cleaned[3] == 'I':\\n cleaned = cleaned[:3] + '1' + cleaned[4:]\\n\\n if re.match(r'^B', cleaned) and len(cleaned) == 7:\\n if cleaned[1] == 'O':\\n cleaned = cleaned[:1] + '0' + cleaned[2:]\\n if cleaned[1] == 'I':\\n cleaned = cleaned[:1] + '1' + cleaned[2:]\\n if cleaned[2] == 'O':\\n cleaned = cleaned[:2] + '0' + cleaned[3:]\\n if cleaned[2] == 'I':\\n cleaned = cleaned[:2] + '1' + cleaned[3:]\\n if cleaned[3] == 'O':\\n cleaned = cleaned[:3] + '0' + cleaned[4:]\\n if cleaned[3] == 'I':\\n cleaned = cleaned[:3] + '1' + cleaned[4:]\\n\\n if re.match(r'^[A-Z]{2}', cleaned) and len(cleaned) == 8:\\n if cleaned[0] == 'Y':\\n cleaned = 'V' + cleaned[1:]\\n if cleaned[1] == 'Y':\\n cleaned = cleaned[0] + 'V' + cleaned[2:]\\n\\n return cleaned\",\n \"def is_isni(val):\\n val = val.replace(\\\"-\\\", \\\"\\\").replace(\\\" \\\", \\\"\\\").upper()\\n if len(val) != 16:\\n return False\\n try:\\n r = 0\\n for x in val[:-1]:\\n r = (r + int(x)) * 2\\n ck = (12 - r % 11) % 11\\n return ck == _convert_x_to_10(val[-1])\\n except ValueError:\\n return False\",\n \"def enc_suffix(suf):\\n if len(suf) == 0:\\n return 0\\n r0 = base34.find(suf[0])\\n if len(suf) == 1:\\n r1 = 0\\n else:\\n r1 = base34.find(suf[1]) + 1\\n if r0 < 24: # first char is a letter, use base 25\\n return r0 * 25 + r1 + 1\\n else: # first is a number -- base 35.\\n return r0 * 35 + r1 - 239\",\n \"def safe_number(self):\\n mask = '*' * (len(self.account_number) - 4)\\n return '{0}{1}'.format(mask, self.account_number[-4:])\",\n \"def checkio(str_number, radix):\\n list_str_num = list(str_number)\\n power = 0\\n result = 0\\n for i in range(len(list_str_num)):\\n str_num = list_str_num[len(list_str_num) -1 - i]\\n if str_num.isdigit():\\n num = int(str_num)\\n else:\\n num = (ord(str_num) - 55)\\n if num >= radix:\\n return -1\\n result += num * (radix ** i)\\n return result\",\n \"def _validate_account_with_institution_57C(self, val):\\n return val\",\n \"def test_is_old_papernum(self):\\n self.assertFalse(util.is_old_papernum(\\\"9106001\\\"))\\n self.assertTrue(util.is_old_papernum(\\\"9107001\\\"))\\n self.assertFalse(util.is_old_papernum(\\\"9200001\\\"))\\n self.assertTrue(util.is_old_papernum(\\\"9201001\\\"))\\n self.assertTrue(util.is_old_papernum(\\\"0703999\\\"))\\n self.assertFalse(util.is_old_papernum(\\\"0704001\\\"))\",\n \"def check_digits_cnpj(x: str, n: int) -> int:\\n check_vec = np.array([6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2])\\n digits = np.array(list(x[: -3 + n])).astype(\\\"int\\\")\\n result = np.dot(check_vec[2 - n :], digits) % 11\\n\\n return 0 if result < 2 else 11 - result\",\n \"def luhn_verifica(ccred):\\n \\n # Primeiro criamos uma nova cadeia, n, com os digitos do cartao de credito sem o de controle.\\n # Usamos a funcao calc_soma para somar os digitos do cartao de acordo com o algoritmo de Luhn e juntamos o digito de controle. Caso este ultimo nao seja um algarismo, chamamos a atencao ao utilizador para o erro.\\n # Caso o resto da divisao por 10 seja 0, a funcao devolve o valor logico True. \\n \\n\\n n = ccred[:-1]\\n dig_verificacao = ccred[-1]\\n \\n if '0' <= dig_verificacao <= '9':\\n soma = calc_soma(n) + eval(dig_verificacao)\\n \\n else:\\n raise ValueError ('function luhn_verifica() O string recebido apenas pode conter digitos') \\n \\n return soma % 10 == 0\",\n \"def test_digit_14_min_base(self):\\n expected = 6\\n digit = 14\\n\\n assert expected == min_base(digit)\",\n \"def convert_to_3digit_icd9(dx_str):\\n\\n if dx_str.startswith(\\\"E\\\"):\\n if len(dx_str) > 4:\\n return dx_str[:4]\\n else:\\n return dx_str\\n else:\\n if len(dx_str) > 3:\\n return dx_str[:3]\\n else:\\n return dx_str\",\n \"def utf8(num):\\n # code de la prof louche\\n if num < 8:\\n return 1\\n else:\\n return num//6+1\\n\\n return binary\",\n \"def _get_random_number_code(self):\\r\\n return \\\"str(random.randint(0, 1e9))\\\"\",\n \"def card(n):\\r\\n assert type(n) == int and n > 0 and n <= 13, \\\"Bad card n\\\"\\r\\n specials = {1: 'A', 11: 'J', 12: 'Q', 13: 'K'}\\r\\n return specials.get(n, str(n))\",\n \"def oracle(ct: int) -> bool:\\n return rsa.dec(ct) & 1 == 0\",\n \"def _get_checksum(code: str) -> int:\\r\\n total = 0\\r\\n\\r\\n for index, digit in enumerate(code):\\r\\n digit = int(digit)\\r\\n if (index + 1) % 2 != 0:\\r\\n digit *= 2\\r\\n if digit > 9:\\r\\n digit -= 9\\r\\n total += digit\\r\\n\\r\\n checksum = 10 - total % 10\\r\\n\\r\\n return checksum if checksum != 10 else 0\",\n \"def _validate_contract_number_partyA_21N(self, val):\\n return val\",\n \"def is_valid_control_number(id_code: str) -> bool:\\n sum = 1 * int(id_code[:1]) + 2 * int(id_code[1:2]) + 3 * int(id_code[2:3]) + 4 * int(id_code[3:4]) + 5 * \\\\\\n int(id_code[4:5]) + 6 * int(id_code[5:6]) + 7 * int(id_code[6:7]) + 8 * int(id_code[7:8]) + 9 *\\\\\\n int(id_code[8:9]) + 1 * int(id_code[9:10])\\n control_number = sum % 11\\n if int(control_number) == int(id_code[10:11]):\\n return True\\n elif int(control_number) == 10:\\n sum = 3 * int(id_code[:1]) + 4 * int(id_code[1:2]) + 5 * int(id_code[2:3]) + 6 * int(id_code[3:4]) + 7 * \\\\\\n int(id_code[4:5]) + 8 * int(id_code[5:6]) + 9 * int(id_code[6:7]) + 1 * int(id_code[7:8]) + 2 * \\\\\\n int(id_code[8:9]) + 3 * int(id_code[9:10])\\n control_number = sum % 11\\n if control_number == int(id_code[10:11]):\\n return True\\n elif control_number == 10:\\n if int(id_code[10:11]) == 0:\\n return True\\n else:\\n return False\\n else:\\n return False\",\n \"def calculate_checksum(code):\\n\\n sum_odd = reduce(sum_chars, code[::2])\\n sum_even = reduce(sum_chars, code[1:-1:2])\\n check = (sum_even + sum_odd * 3) % 10\\n\\n if check == 0:\\n return 0\\n else:\\n return 10 - check\",\n \"def _validate_details_of_charges_71A(self, val):\\n return val\",\n \"def _mpc_lookup(x,packed_date):\\n\\n try:\\n x = int(x)\\n except ValueError:\\n x = ord(x) - 55\\n if x < 0 or x > 31:\\n print(packed_date)\\n raise ValueError\\n return x\",\n \"def calc_check_digit(number):\\n weights = (2, 4, 8, 5, 10, 9, 7, 3, 6)\\n return str(sum(w * int(n) for w, n in zip(weights, number)) % 11 % 10)\",\n \"def check_identity(input_string: str) -> str:\\n n = input_string[2]\\n if n == '6':\\n return 'a foreigner with nationality'\\n elif n == '7':\\n return 'a national without household registration'\\n elif n == '8':\\n return 'from Hong Kong or Macau'\\n elif n == '9':\\n return 'from China'\\n elif n == '0' \\\\\\n or n == '1' \\\\\\n or n == '2' \\\\\\n or n == '3' \\\\\\n or n == '4' \\\\\\n or n == '5':\\n return 'a normal national'\\n else:\\n # Should not happen\\n return None\",\n \"def get_country_dcid(country_code: str) -> str:\\n numeric_code = int(country_code, 10)\\n if numeric_code in UN_COUNTRY_CODES:\\n return UN_COUNTRY_CODES[numeric_code]\\n return None\",\n \"def is_valid_two_digit_char(code: str) -> bool:\\n\\n return 10 <= int(code) <= 26\",\n \"def area_code(self):\\n return self.number[:3]\",\n \"def CODE(string):\\n return ord(string[0])\",\n \"def validate(number):\\n number = compact(number)\\n if len(number) != 9:\\n raise InvalidLength()\\n if not isdigits(number[2:]):\\n raise InvalidFormat()\\n if not isdigits(number[:2]) and not all(x in 'ABCEHKMOPT' for x in number[:2]):\\n raise InvalidFormat()\\n if number[0] not in '1234567ABCEHKM':\\n raise InvalidComponent()\\n if number[-1] != calc_check_digit(number):\\n raise InvalidChecksum()\\n return number\",\n \"def country(alpha_2_code: str) -> None:\",\n \"def _validate_account_with_institution_57D(self, val):\\n return val\",\n \"def generate_game_code() -> int:\\n while True:\\n # code will only contain digits\\n code_options = string.digits\\n generated_game_code = ''.join(secrets.choice(code_options) for i in range(7))\\n if Game.objects.filter(game_code=generated_game_code).count() == 0:\\n break\\n return int(generated_game_code)\",\n \"def ck(value):\\n return chr(value)\",\n \"def _get_det_id(self, source):\\n match = re.match(r\\\"Camp\\\\.0:pnCCD\\\\.(\\\\d)\\\", source)\\n number = str.zfill(match.groups()[0], 4)\\n return \\\"pnccd_\\\" + number\",\n \"def fix_RFID(r):\\n #f = str(r).strip()\\n #while f[0] == '0':\\n # f = f[1:]\\n return int(r)\",\n \"def _hexchar(c):\\n if c == '1': return 1\\n if c == '2': return 2\\n if c == '3': return 3\\n if c == '4': return 4\\n if c == '5': return 5\\n if c == '6': return 6\\n if c == '7': return 7\\n if c == '8': return 8\\n if c == '9': return 9\\n if c == 'A' or c == 'a': return 10\\n if c == 'B' or c == 'b': return 11\\n if c == 'C' or c == 'c': return 12\\n if c == 'D' or c == 'd': return 13\\n if c == 'E' or c == 'e': return 14\\n if c == 'F' or c == 'f': return 15\\n return 0\",\n \"def verify(isbn):\\n\\n isbn = isbn.replace(\\\"-\\\", \\\"\\\")\\n if not verify_format(isbn):\\n return False\\n\\n isbn_sum = 0\\n for digit, i in zip(isbn, range(10, 0, -1)):\\n if digit == \\\"X\\\":\\n isbn_sum += 10 * i\\n else:\\n isbn_sum += int(digit) * i\\n\\n return isbn_sum % 11 == 0\",\n \"def is_sedol(value):\\n return re.match(r'^[0-9BCDFGHJKLMNPQRSTVWXYZ]{6}\\\\d$', value)\",\n \"def generate_new_code():\\n code = ''.join(random.choice(string.digits) for i in range(6))\\n return code\",\n \"def checksum(n):\\n\\n # Compute the sum of the non-check digits.\\n s = sum(luhn_digits(n * 10))\\n\\n # Multiply by 9.\\n result = s * 9\\n\\n # The units digit is the check digit\\n check_digit = result % 10\\n\\n m = int(str(n) + str(check_digit))\\n assert(verify(m))\\n\\n return check_digit\",\n \"def convert_UPCE_to_UPCA(upce_value):\\n if len(upce_value) == 6:\\n middle_digits = upce_value # assume we're getting just middle 6 digits\\n elif len(upce_value) == 7:\\n # truncate last digit, assume it is just check digit\\n middle_digits = upce_value[:6]\\n elif len(upce_value) == 8:\\n # truncate first and last digit,\\n # assume first digit is number system digit\\n # last digit is check digit\\n middle_digits = upce_value[1:7]\\n else:\\n return False\\n d1, d2, d3, d4, d5, d6 = list(middle_digits)\\n if d6 in [\\\"0\\\", \\\"1\\\", \\\"2\\\"]:\\n mfrnum = d1 + d2 + d6 + \\\"00\\\"\\n itemnum = \\\"00\\\" + d3 + d4 + d5\\n elif d6 == \\\"3\\\":\\n mfrnum = d1 + d2 + d3 + \\\"00\\\"\\n itemnum = \\\"000\\\" + d4 + d5\\n elif d6 == \\\"4\\\":\\n mfrnum = d1 + d2 + d3 + d4 + \\\"0\\\"\\n itemnum = \\\"0000\\\" + d5\\n else:\\n mfrnum = d1 + d2 + d3 + d4 + d5\\n itemnum = \\\"0000\\\" + d6\\n newmsg = \\\"0\\\" + mfrnum + itemnum\\n # calculate check digit, they are the same for both UPCA and UPCE\\n check_digit = calc_check_digit(newmsg)\\n return newmsg + str(check_digit)\",\n \"def decode(code):\\n def h(x):\\n hs = []\\n for i in range(len(code)):\\n if code[i] != '0' and (code[i] == '?' or code[i] == x[i]):\\n hs.append(True)\\n else:\\n hs.append(False)\\n return all(hs)\\n return h\",\n \"def _algorithm(self, rut):\\n suma = 0\\n multi = 2\\n for r in rut[::-1]:\\n suma += int(r) * multi\\n multi += 1\\n if multi == 8:\\n multi = 2\\n return u'0123456789K0'[11 - suma % 11]\",\n \"def getAAAZZZSId(self):\\n if self.element.symbol == \\\"C\\\":\\n return \\\"120060\\\"\\n elif self.element.symbol == \\\"V\\\":\\n return \\\"510230\\\"\\n else:\\n return None\",\n \"def get_seat_id(boarding_pass):\\n return int(re.sub(\\\"[FL]\\\", \\\"0\\\", re.sub(\\\"[BR]\\\", \\\"1\\\", boarding_pass)), 2)\",\n \"def clean_phone(number):\\n numberlist = re.findall(\\\"\\\\d\\\",number)\\n new_number = \\\"\\\".join(numberlist)\\n if len(new_number) == 8:\\n \\tnew_number = \\\"010\\\" + new_number\\n\\tnew_number = new_number[-11:]\\n\\tif new_number.startswith('1'):\\n\\t\\tnew_number = \\\"+86-\\\" + new_number\\n\\telse:\\n\\t\\tnew_number = \\\"+86-10-\\\" + new_number[-8:]\\n\\treturn new_number\",\n \"def test_cpf_has_11_digits(self):\\r\\n form = self.make_validated_form(cpf='1234')\\r\\n self.assertFormErrorCode(form, 'cpf', 'length')\",\n \"def code(char):\\n return int(char) if char.isdigit() else letter_code(char)\",\n \"def octet(n):\\n\\t\\n\\treturn n & 0b11111111\",\n \"def _format_bank_operation_code_23B(self, val):\\n return val\",\n \"def getCurrencyIsoCode(id=None):\",\n \"def check_for_int(check):\",\n \"def _validate_instruction_code_23E(self, val):\\n validate_instruction_code(val)\\n return val\",\n \"def validate_CPF(value):\\n\\t\\tif value in EMPTY_VALUES:\\n\\t\\t\\treturn u''\\n\\t\\tif not value.isdigit():\\n\\t\\t\\tvalue = re.sub(\\\"[-\\\\.]\\\", \\\"\\\", value)\\n\\t\\torig_value = value[:]\\n\\t\\ttry:\\n\\t\\t\\tint(value)\\n\\t\\texcept ValueError:\\n\\t\\t\\treturn False\\n\\t\\tif len(value) != 11 or value == \\\"00000000000\\\" or value == \\\"11111111111\\\" or value == \\\"22222222222\\\" or value == \\\"33333333333\\\" or \\\\\\n\\t\\t\\tvalue == \\\"44444444444\\\" or value == \\\"55555555555\\\" or value == \\\"66666666666\\\" or value == \\\"77777777777\\\" or \\\\\\n\\t\\t\\tvalue == \\\"88888888888\\\" or value == \\\"99999999999\\\":\\n\\t\\t\\t\\n\\t\\t\\treturn False\\n\\n\\t\\torig_dv = value[-2:]\\n\\n\\t\\tnew_1dv = sum([i * int(value[idx]) for idx, i in enumerate(range(10, 1, -1))])\\n\\t\\tnew_1dv = DV_maker(new_1dv % 11)\\n\\t\\tvalue = value[:-2] + str(new_1dv) + value[-1]\\n\\t\\tnew_2dv = sum([i * int(value[idx]) for idx, i in enumerate(range(11, 1, -1))])\\n\\t\\tnew_2dv = DV_maker(new_2dv % 11)\\n\\t\\tvalue = value[:-1] + str(new_2dv)\\n\\t\\tif value[-2:] != orig_dv:\\n\\t\\t\\treturn False \\n\\n\\n\\t\\treturn orig_value\",\n \"def valid_barcode(s):\\n # implement this function!\\n odd_digits = 0\\n even_digits = 0\\n result = 0\\n for i in range(len(s) - 1):\\n if i % 2 == 0:\\n odd_digits += int(s[i])\\n else:\\n even_digits += int(s[i])\\n result = (3 * odd_digits + even_digits) % 10\\n if result != 0:\\n result = 10 - result\\n\\n try:\\n if int(s[-1]) == result and len(s) == 12:\\n return True\\n else:\\n return False\\n except IndexError:\\n return False\",\n \"def encode_identifier(alphabet, n):\\r\\n c = alphabet[n & 0b1111]\\r\\n n>>=4\\r\\n while n > 0:\\r\\n c = c + alphabet[n & 0b111111]\\r\\n n>>=6\\r\\n return c\",\n \"def Detect_network(num):\\n\\tif num.isdigit():\\n\\t\\tif num.startswith(\\\"077\\\") or num.startswith(\\\"078\\\"):\\n\\t\\t\\treturn \\\"MTN\\\"\\n\\t\\tif num.startswith(\\\"075\\\") or num.startswith(\\\"070\\\"):\\n\\t\\t\\treturn\\\"Airtel\\\"\\n\\t\\tif num.startswith(\\\"079\\\"):\\n\\t\\t\\treturn \\\"Africel\\\"\\n\\t\\tif num.startswith(\\\"074\\\"):\\n\\t\\t\\treturn \\\"Smart\\\"\\n\\t\\tif num.startswith(\\\"071\\\"):\\n\\t\\t\\treturn \\\"UTL\\\"\\n\\t\\tif num.startswith(\\\"073\\\"):\\n\\t\\t\\treturn \\\"K2\\\"\\t\\n\\t\\telse:\\n\\t\\t\\treturn \\\"Others\\\"\\t\\n\\telse:\\n\\t\\treturn \\\"Invalid\\\"\",\n \"def test_mode_digit():\\n print('Testing mode_digit')\\n\\n # Cases given to test this problem\\n assert_equals(1, hw1.mode_digit(12121))\\n assert_equals(0, hw1.mode_digit(0))\\n assert_equals(2, hw1.mode_digit(-122))\\n assert_equals(2, hw1.mode_digit(1211232231))\\n\\n # Additional cases to test numbers with same digit occurance numbers\\n assert_equals(3, hw1.mode_digit(-333000221))\\n assert_equals(4, hw1.mode_digit(440011))\",\n \"def create_checksum(self, fifteen_digit):\\n duplicate_odd_digits = [int(fifteen_digit[i - 1]) * 2 if i % 2 else\\n int(fifteen_digit[i - 1]) for i in range(1, 16)]\\n subtract_nine = [digit - 9 if digit > 9 else digit for digit in duplicate_odd_digits]\\n sum_up = sum(subtract_nine)\\n return (10 - sum_up % 10) % 10\",\n \"def is_not_used(code):\\n return 0 <= code <= 999\",\n \"def alpha_number(alpha):\\r\\n if alpha.isupper() == False:\\r\\n num = ord(alpha) - 96\\r\\n return num\\r\\n elif alpha.isupper() == True:\\r\\n num = ord(alpha) - 64\\r\\n return num\",\n \"def test_cpf_is_digit(self):\\n form = self.make_validated_form(cpf='ABCD5678901')\\n self.assertFormErrorMessage(form, 'cpf', 'digits')\",\n \"def y2k_coding(n):\\n if n < 60:\\n return 2000 + n\\n else:\\n return 1900 + n\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6888133","0.6631145","0.6620832","0.6535597","0.6298015","0.6270086","0.6102347","0.6022895","0.6003835","0.59928644","0.5986576","0.59091353","0.58925956","0.5891122","0.5886155","0.5840528","0.58109224","0.5803279","0.5776782","0.5743615","0.5738659","0.57323015","0.5727749","0.5703101","0.56719273","0.56675","0.56660366","0.56646174","0.5654082","0.56520844","0.5651498","0.56264555","0.56083","0.56048036","0.5600922","0.5600729","0.55995417","0.5589979","0.5570258","0.556992","0.55676436","0.55669594","0.55662274","0.55649185","0.5560041","0.55514276","0.55305773","0.55219203","0.55172205","0.5484386","0.5476423","0.54737103","0.5469068","0.5453305","0.5441699","0.54389185","0.5434664","0.5428551","0.5422499","0.54207575","0.5418594","0.54160875","0.54113615","0.5397645","0.53866833","0.53764313","0.53737396","0.53621596","0.5362084","0.53597564","0.5355583","0.5355024","0.53526694","0.53499115","0.53474617","0.5346353","0.53345084","0.532956","0.532586","0.53165567","0.5315768","0.53154886","0.5314883","0.5314108","0.5306698","0.5301914","0.5293848","0.52895766","0.5286068","0.52821803","0.5281684","0.5279996","0.5276232","0.52741325","0.52696496","0.52679545","0.5266865","0.52650696","0.5263268","0.52554464"],"string":"[\n \"0.6888133\",\n \"0.6631145\",\n \"0.6620832\",\n \"0.6535597\",\n \"0.6298015\",\n \"0.6270086\",\n \"0.6102347\",\n \"0.6022895\",\n \"0.6003835\",\n \"0.59928644\",\n \"0.5986576\",\n \"0.59091353\",\n \"0.58925956\",\n \"0.5891122\",\n \"0.5886155\",\n \"0.5840528\",\n \"0.58109224\",\n \"0.5803279\",\n \"0.5776782\",\n \"0.5743615\",\n \"0.5738659\",\n \"0.57323015\",\n \"0.5727749\",\n \"0.5703101\",\n \"0.56719273\",\n \"0.56675\",\n \"0.56660366\",\n \"0.56646174\",\n \"0.5654082\",\n \"0.56520844\",\n \"0.5651498\",\n \"0.56264555\",\n \"0.56083\",\n \"0.56048036\",\n \"0.5600922\",\n \"0.5600729\",\n \"0.55995417\",\n \"0.5589979\",\n \"0.5570258\",\n \"0.556992\",\n \"0.55676436\",\n \"0.55669594\",\n \"0.55662274\",\n \"0.55649185\",\n \"0.5560041\",\n \"0.55514276\",\n \"0.55305773\",\n \"0.55219203\",\n \"0.55172205\",\n \"0.5484386\",\n \"0.5476423\",\n \"0.54737103\",\n \"0.5469068\",\n \"0.5453305\",\n \"0.5441699\",\n \"0.54389185\",\n \"0.5434664\",\n \"0.5428551\",\n \"0.5422499\",\n \"0.54207575\",\n \"0.5418594\",\n \"0.54160875\",\n \"0.54113615\",\n \"0.5397645\",\n \"0.53866833\",\n \"0.53764313\",\n \"0.53737396\",\n \"0.53621596\",\n \"0.5362084\",\n \"0.53597564\",\n \"0.5355583\",\n \"0.5355024\",\n \"0.53526694\",\n \"0.53499115\",\n \"0.53474617\",\n \"0.5346353\",\n \"0.53345084\",\n \"0.532956\",\n \"0.532586\",\n \"0.53165567\",\n \"0.5315768\",\n \"0.53154886\",\n \"0.5314883\",\n \"0.5314108\",\n \"0.5306698\",\n \"0.5301914\",\n \"0.5293848\",\n \"0.52895766\",\n \"0.5286068\",\n \"0.52821803\",\n \"0.5281684\",\n \"0.5279996\",\n \"0.5276232\",\n \"0.52741325\",\n \"0.52696496\",\n \"0.52679545\",\n \"0.5266865\",\n \"0.52650696\",\n \"0.5263268\",\n \"0.52554464\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.697806"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":147,"numItemsPerPage":100,"numTotalItems":95772,"offset":14700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA2NDc5NiwianRpIjoiYTUzNTI5MTctMzBjOS00ZWExLWEzZDktOTM1OTkzODc0ODFkIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwNjgzOTYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.LCmQgIzJyTAG7WO52GDuTMxRFSbf7YiGAA0nWZNh1cEe8L5_5LbkwdLSFfgvxYJjYiFIeFK3NzxDUZ5F50j9Cg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Makes an IGVstyle drawing with colors | def make_line_plot(the_sets, params):
bed_filename = params['bed_filename']
coords = get_read_coordinates(bed_filename, normalize=True)
gapset, spanset, preset, postset = the_sets
colors = node_set_colors(coords.keys(), gapset, spanset, preset, postset)
y_increment = (1. / float(len(coords)))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _style_colours(self):\n\n pass",
"def _color(self, args):",
"def show_vertex_colors():\n if bpy.app.version > (2, 80, 0):\n for area in bpy.context.screen.areas:\n if area.type == 'VIEW_3D':\n for space in area.spaces:\n if space.type == 'VIEW_3... | [
"0.624505",
"0.62064",
"0.6150767",
"0.60509986",
"0.6041359",
"0.6030837",
"0.5991825",
"0.5965499",
"0.596378",
"0.59161466",
"0.5888834",
"0.58749616",
"0.5782469",
"0.5722621",
"0.5711476",
"0.5706236",
"0.5691816",
"0.56374407",
"0.56123173",
"0.5612097",
"0.560385",
"... | 0.0 | -1 |
Generates four graphs for the structural variant defined by merged_filename | def make_four_pdf(args):
params = make_four_params(args)
m4_filename = params['m4_filename']
prefix = params['prefix']
min_matching_length = params['min_matching_length']
output_prefix = params['output_prefix']
# if there are fewer than threshold reads then skip it
threshold = 25 # threshol... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sixteen_graphs(the_dir):\n # TODO change to deprecation warning\n warnings.warn(\"Does not call sv_pipeline functoins correctly\", DeprecationWarning)\n\n plb.rcParams['figure.figsize'] = 30, 30\n plt.clf()\n plt.figure(1)\n\n # should look like: read_data/all_files/chr4_124,017,492_124,029,0... | [
"0.62337637",
"0.6031929",
"0.5773707",
"0.569177",
"0.5651232",
"0.55629456",
"0.5511487",
"0.5491815",
"0.5481452",
"0.5463038",
"0.5419759",
"0.5395845",
"0.5369272",
"0.5366786",
"0.53644574",
"0.5349286",
"0.53409547",
"0.53354126",
"0.53175104",
"0.53075373",
"0.5303393... | 0.0 | -1 |
generates graphs for each structual variant | def sixteen_graphs(the_dir):
# TODO change to deprecation warning
warnings.warn("Does not call sv_pipeline functoins correctly", DeprecationWarning)
plb.rcParams['figure.figsize'] = 30, 30
plt.clf()
plt.figure(1)
# should look like: read_data/all_files/chr4_124,017,492_124,029,032_merged.txt
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_graph(self):",
"def populate_graph(self):",
"def build_graph(self):\n pass",
"def _build_graph(self):\n pass",
"def generate_subgraph(format):\n\n # get business information\n directorypath = genpath+directory\n if os.path.isfile(directorypath):\n \n bizdata = pd... | [
"0.7290527",
"0.65085155",
"0.6410746",
"0.6359326",
"0.6265157",
"0.62437093",
"0.62147",
"0.6130856",
"0.6063134",
"0.6014573",
"0.5913868",
"0.58793896",
"0.58649206",
"0.5789208",
"0.57693243",
"0.5733632",
"0.5728531",
"0.56909496",
"0.5682795",
"0.5681683",
"0.5664425",... | 0.54853797 | 38 |
Generates four graphs for each structural variant in the directory formerly | def four_graphs(the_dir, min_matching_length, output_prefix, sw_window_size):
files = get_files(the_dir)
print('Looking in directory %s*.m4' % (the_dir))
print('There are %d files' % (len(files)))
zipped = zip(files,
itertools.repeat(the_dir),
itertools.repeat(min_match... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_subgraph(format):\n\n # get business information\n directorypath = genpath+directory\n if os.path.isfile(directorypath):\n \n bizdata = pd.read_csv( directorypath, escapechar='\\\\')\n\n #create a directory of page-id and object-ids\n tempdf = bizdata.set_index('pag... | [
"0.659347",
"0.64899665",
"0.6482556",
"0.6280894",
"0.61621535",
"0.60121584",
"0.59992623",
"0.59135026",
"0.58882594",
"0.58695626",
"0.5819254",
"0.5776892",
"0.57706445",
"0.57308894",
"0.57188094",
"0.56933165",
"0.5661808",
"0.5643725",
"0.56388",
"0.5616771",
"0.56149... | 0.5689229 | 16 |
Validates an email address. >>> is_email_address("test.com") True >>> is_email_address("test.this.domain.example.me") True >>> is_email_address("test.gmail.style+tag.com") True >>> is_email_address("invalid") False >>> is_email_address("invalid&domain.com") False >>> is_email_address("test@.domain.com") Actually seen i... | def is_email_address(value):
return _COMPILED[EMAIL].match(value) != None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_email_address(email_address: str):\n email_regex = \"^[a-z0-9]+[\\\\._]?[a-z0-9]+[@]\\\\w+[.]\\\\w{2,3}$\"\n if re.search(email_regex, email_address):\n return True\n return False",
"def is_valid_email_address (email):\n return valid_email.search(email)",
"def is_v... | [
"0.8575625",
"0.84851384",
"0.83953494",
"0.83473897",
"0.83036774",
"0.8301605",
"0.8282927",
"0.8255866",
"0.80955577",
"0.803546",
"0.7959708",
"0.7903979",
"0.789488",
"0.7892206",
"0.7866369",
"0.785021",
"0.78347176",
"0.78037316",
"0.77615976",
"0.7758334",
"0.7695697"... | 0.7941021 | 11 |
Create a ProducerFactory object. | def __init__(self, connection, topic, args, kargs):
self.__args__ = args
self.__kargs__ = kargs
self.__topic__ = topic
self.__conn__ = connection | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kafka_producer_factory(kafka_broker, request):\n _producer = [None]\n\n def factory(**kafka_producer_params):\n params = {} if kafka_producer_params is None else kafka_producer_params.copy()\n params.setdefault('client_id', 'producer_%s' % (request.node.name,))\n _producer[0] = next(... | [
"0.7025217",
"0.68390906",
"0.6834584",
"0.6776398",
"0.6401017",
"0.6385152",
"0.62134594",
"0.61186343",
"0.6028576",
"0.5980782",
"0.59188235",
"0.5901068",
"0.5899369",
"0.5796073",
"0.569973",
"0.5683468",
"0.567076",
"0.5631843",
"0.55990684",
"0.5586578",
"0.5585444",
... | 0.0 | -1 |
Create a producer. Calls pykafka.topic.Topic.get_producer to create the producer Returns pykafka.producer.Producer | def create(self):
topic = self.__conn__.create_topic(self.__topic__)
return topic.get_producer(*self.__args__, **self.__kargs__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_producer(self, topic_id: str) -> Producer:\n backend = None\n if self.vendor == 'kafka':\n backend = KafkaClient(topic_id, self.configs['kafka_servers'])\n else:\n project_id = os.getenv(\"GOOGLE_CLOUD_PROJECT\")\n subscription_id = os.getenv(\"GOOGL... | [
"0.77851456",
"0.72549456",
"0.6957942",
"0.6930621",
"0.69090855",
"0.68014026",
"0.66531676",
"0.66403145",
"0.6623068",
"0.6583257",
"0.6494753",
"0.6437796",
"0.63862807",
"0.6300328",
"0.6213889",
"0.6204735",
"0.60279506",
"0.59126776",
"0.58620876",
"0.58424014",
"0.58... | 0.77106583 | 1 |
Return a string representation. Returns str returns a string representation of itself | def __str__(self):
return f"topic: {self.__topic__}" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_str(self) -> str:",
"def toString(self) -> str:\n raise NotImplementedError",
"def toString():",
"def to_string(self):\r\n return self.__str__()",
"def __str__(self):\n buf = StringIO()\n self.write_to(buf)\n return buf.getvalue()",
"def __str__(self) -> str:\n ... | [
"0.83085304",
"0.8040051",
"0.80097175",
"0.78801274",
"0.7878785",
"0.77915126",
"0.77915126",
"0.77915126",
"0.7749101",
"0.7697228",
"0.76855636",
"0.76847416",
"0.7681851",
"0.7667078",
"0.76651454",
"0.75902957",
"0.75799274",
"0.7561032",
"0.75398624",
"0.75385803",
"0.... | 0.0 | -1 |
All messages to the server must be JSONserialisable. | def send(self, msg):
self.ws.send(json.dumps(msg)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_json(self):\n pass",
"def send_jsonified(self, msg, stats=True):\n raise NotImplemented()",
"def _send_json(self, data):\n return self.sendMessage(json.dumps(data).encode(\"utf-8\"))",
"def json_serialize(self):\n raise NotImplementedError('json_serialize must be over... | [
"0.6654911",
"0.6630986",
"0.65368146",
"0.6442708",
"0.62427086",
"0.61884284",
"0.6152484",
"0.6149814",
"0.61469465",
"0.6071603",
"0.591953",
"0.5882717",
"0.58408344",
"0.58157843",
"0.574765",
"0.573589",
"0.57143545",
"0.5693478",
"0.5688369",
"0.56881183",
"0.5675443"... | 0.0 | -1 |
All messages from the server are valid JSON. | def recv(self):
msg = self.ws.recv()
print(msg)
return (
json.loads(msg)
if msg
else msg
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_json(self):\n pass",
"def construct_json(self):\n\n if 'message' not in self.data:\n self.data['message'] = self.message\n\n if self.status == 200:\n self.data['status'] = 'OK'\n else:\n self.data['status'] = 'Not OK'\n\n return jso... | [
"0.6554427",
"0.64114743",
"0.60908055",
"0.6054486",
"0.5964556",
"0.5874959",
"0.5825551",
"0.5794578",
"0.57911843",
"0.5787778",
"0.5780893",
"0.576939",
"0.57630444",
"0.57298136",
"0.5708723",
"0.5703407",
"0.5702239",
"0.5669806",
"0.5662018",
"0.56608593",
"0.56513697... | 0.5448092 | 45 |
Assert that the correct message is received. | def recv_type(self, type_):
msg = self.recv()
assert msg and msg['type'] == type_, msg
return msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_message(self):\n\n message = typhoonae.websocket.Message(\n {'from': 0, 'body': 'Message body'})\n\n self.assertEqual(0, message.socket)\n self.assertEqual('Message body', message.body)",
"def test_send(self):\n self.inverter.send(b\"\\x00\\x01\\x02\", b\"\")\n ... | [
"0.7479688",
"0.7339858",
"0.72840655",
"0.7169065",
"0.7160685",
"0.7150704",
"0.70198834",
"0.70130646",
"0.6920468",
"0.691517",
"0.68666226",
"0.6832248",
"0.67956877",
"0.67729837",
"0.6744708",
"0.6733483",
"0.6730778",
"0.6692171",
"0.66914153",
"0.66856384",
"0.666463... | 0.0 | -1 |
Return a pretty string representation of the board. | def render_state(self, state, is_first_player_black):
MOVES_STR = {
-1 if is_first_player_black else 1: '▒▒',
0: ' ',
1 if is_first_player_black else -1: '██',
}
numbers = ' ' + ''.join(
str(i) + (' ' if i < 10 else '')
for i in ran... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def board_string(self):\n s = \"\"\n for i, v in enumerate(self.board):\n # if i % 81 == 0:\n # s += \"\\n\"\n if v is None:\n s += \"0\"\n else:\n if v.color == StoneColor.black:\n s += \"1\"\n ... | [
"0.8255606",
"0.82497513",
"0.81109965",
"0.8038326",
"0.8034061",
"0.7885153",
"0.78684336",
"0.783711",
"0.78338665",
"0.7774994",
"0.7771326",
"0.7763116",
"0.77425283",
"0.7736104",
"0.7733884",
"0.7731785",
"0.76850206",
"0.76814973",
"0.76664",
"0.7656324",
"0.76460916"... | 0.0 | -1 |
A simple memoryless implementation of a Gomoku gameplaying bot. Modify this if you want to do something fancy. (The first player is 1, the second player is 1). | def play_game(self, is_first_player):
state = [0] * (self.SIZE * self.SIZE)
turn_number = 0
player_number = -1 if is_first_player else 1
print('Your bot is playing {} ({})'.format(
'first' if is_first_player else 'second',
'black' if self.index == 0 else 'white'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_game():\n pass",
"def oneGame():\n playOneGame()",
"def play_game():\n pass",
"async def playing(self, ctx: commands.Context, *, game: str = None):\n\n global _ # MyPy was complaining this was a unresolved reference until global was called\n game_name = _(\"what\")\n ... | [
"0.66748965",
"0.6540396",
"0.6504868",
"0.63579094",
"0.6345802",
"0.63275534",
"0.6317963",
"0.62635875",
"0.62507284",
"0.6207458",
"0.61773705",
"0.6171212",
"0.6160435",
"0.6150239",
"0.61368304",
"0.6126107",
"0.61235934",
"0.6106824",
"0.61023647",
"0.61023176",
"0.609... | 0.61000913 | 20 |
Check that broken __unicode__/__str__ actually raises an error. | def test_force_text_exception(self):
class MyString(object):
def __str__(self):
return b'\xc3\xb6\xc3\xa4\xc3\xbc'
__unicode__ = __str__
# str(s) raises a TypeError on python 3 if the result is not a text type.
# python 2 fails when it tries converting f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_unicode(data, err=\"Input not valid unicode\"):\n try:\n if not isinstance(data, str) and not isinstance(data, str):\n raise UnicodeError(err)\n # In some cases we pass the above, but it's still inappropriate utf-8.\n str(data)\n except UnicodeError:\n rai... | [
"0.7820335",
"0.712562",
"0.7090174",
"0.6981514",
"0.6951635",
"0.67255706",
"0.66341805",
"0.6598654",
"0.6582145",
"0.6511867",
"0.6404797",
"0.6359545",
"0.6332364",
"0.6303237",
"0.6299061",
"0.6286056",
"0.6273976",
"0.62645805",
"0.6254592",
"0.6227654",
"0.62090826",
... | 0.74112284 | 1 |
Test that force_bytes knows how to convert to bytes an exception containing nonASCII characters in its args. | def test_force_bytes_exception(self):
error_msg = "This is an exception, voilà"
exc = ValueError(error_msg)
result = force_bytes(exc)
self.assertEqual(result, error_msg.encode('utf-8')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_nonASCIIBytesToString(self):\n self.assertRaises(UnicodeError, nativeString, b\"\\xFF\")",
"def test_py2_transaction_exception_message_bytes_implicit_encoding_non_english():\n try:\n\n # Bytes literal with non-ascii compatible characters only allowed in\n # python 2\n\n ra... | [
"0.77594966",
"0.7754345",
"0.748256",
"0.74188924",
"0.7351609",
"0.7313225",
"0.7176732",
"0.71660197",
"0.71446127",
"0.71294063",
"0.7124105",
"0.71056265",
"0.7031364",
"0.70092523",
"0.6898177",
"0.6873759",
"0.68179154",
"0.6805716",
"0.6797002",
"0.67729616",
"0.67559... | 0.81311226 | 0 |
Entry point of Lambda function. | def lambda_handler(event, context):
# Generate json from base64-encoded image.
data = generate_json_from_base64_image(event['image'])
# Get response from Cloud Vision API
response = get_response_from_cv_api(data)
# Load response text as json.
text_result = json.loads(response.text)
# Extr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lambda_handler(event, context):\n return",
"def lambda_handler(event, context):\n return",
"def lambda_handler(event, context):\n return dispatch(event)",
"def lambda_method(self,t): \n return 5*math.sin(2*math.pi*1*t) # I don't see the value of 1 here but this is how lamda is defi... | [
"0.7117734",
"0.7117734",
"0.69204116",
"0.6426233",
"0.62977284",
"0.62949",
"0.62714696",
"0.6236613",
"0.6165585",
"0.6155875",
"0.60868734",
"0.6073085",
"0.60661924",
"0.5978792",
"0.5955426",
"0.5945215",
"0.59250873",
"0.5917553",
"0.58179045",
"0.57982415",
"0.5794267... | 0.0 | -1 |
Translates the input file into a json text. | def generate_json_from_base64_image(base64_image):
# Content image
content_json_obj = {'content': base64_image}
# Detection type.
feature_json_obj = [{'type': get_detection_type(5),
'maxResults': 50,
}
]
# Now add it to the re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_json(self, inputfile):\n transtransfile = json.load(inputfile)\n self.language = transfile['lang']\n self.translations = transfile['strings']",
"def _read_json(cls, input_file):\n with open(input_file) as f:\n return json.load(f)",
"def _read_json(cls, input_file):\n ... | [
"0.7513639",
"0.68007874",
"0.68007874",
"0.66803414",
"0.66803414",
"0.65688586",
"0.65220004",
"0.6511892",
"0.6482155",
"0.6418868",
"0.6394679",
"0.63921416",
"0.63604486",
"0.6353644",
"0.6273617",
"0.6259363",
"0.6204062",
"0.6163943",
"0.6163943",
"0.613355",
"0.610954... | 0.0 | -1 |
Return the Vision API symbol corresponding to the given number. | def get_detection_type(detect_num):
detect_num = int(detect_num)
if 0 < detect_num < len(DETECTION_TYPES):
return DETECTION_TYPES[detect_num]
else:
return DETECTION_TYPES[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def number_to_symbol(number):\n return [x for x in _atomic_number if _atomic_number[x] == number][0]",
"def getSymbolAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.symbol.Symbol:\n ...",
"def getSymbolAt(self, address: ghidra.program.model.address.Address, name: unico... | [
"0.66408694",
"0.6473042",
"0.637004",
"0.6256942",
"0.62465554",
"0.6236463",
"0.62076956",
"0.6110681",
"0.60870695",
"0.60536915",
"0.5998216",
"0.5983382",
"0.592511",
"0.59117895",
"0.59070474",
"0.5850959",
"0.58061606",
"0.578223",
"0.5773515",
"0.5768813",
"0.5754112"... | 0.0 | -1 |
Get response from Cloud Vision API. | def get_response_from_cv_api(data):
url = 'https://vision.googleapis.com/v1/images:annotate?key={}'.format(API_KEY)
response = requests.post(url=url, data=data, headers={'Content-Type': 'application/json'})
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_response(image):\n encoded = base64.b64encode(image.read())\n GOOGLE_CLOUD_VISION_API_URL = 'https://vision.googleapis.com/v1/images:annotate?key='\n API_KEY = 'AIzaSyCKFsYnfYoLFeD2OHpvcjky9opfhHKFnP0'\n api_url = GOOGLE_CLOUD_VISION_API_URL + API_KEY\n header = {'Content-Type': 'application... | [
"0.6588146",
"0.641112",
"0.61037785",
"0.57874006",
"0.571129",
"0.5638207",
"0.5509912",
"0.54499793",
"0.5273775",
"0.52694327",
"0.5254997",
"0.52453876",
"0.5232203",
"0.52142817",
"0.519771",
"0.51782495",
"0.51781756",
"0.51781756",
"0.51781756",
"0.51781756",
"0.51781... | 0.7367046 | 0 |
Constructor method. Initializes the client. | def __init__(self, host: str, port: int):
self.__host: str = host
self.__port: int = port | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, client=None):\n self._client = client",
"def __init__(self, client):\n self._client = client",
"def __init__(self, client):\n\n self.client = client",
"def __init__(self, client):\n self.client = client",
"def client_setup(self):\n self.client = Client(... | [
"0.8327685",
"0.8319791",
"0.8300767",
"0.8265125",
"0.8112874",
"0.8045332",
"0.78123504",
"0.76885706",
"0.7643811",
"0.75182176",
"0.73752475",
"0.7280026",
"0.7264783",
"0.7245352",
"0.72363025",
"0.722842",
"0.722842",
"0.722842",
"0.722842",
"0.722842",
"0.7146238",
"... | 0.0 | -1 |
Creates a new connection to the authentication server. | def __get_connection(self) -> HTTPConnection:
return HTTPConnection(self.__host, self.__port) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self, host, auth):\n return Connection(host, auth)",
"def _create_connection(self):\n if not self.connection:\n log.info(\"{}: Creating connection with address={}\".format(\n self.container_id, self.address.geturl()))\n self.connection = Connection(\... | [
"0.7142276",
"0.6768396",
"0.67655563",
"0.66948736",
"0.66659343",
"0.6585904",
"0.6562106",
"0.65490437",
"0.6543258",
"0.65032685",
"0.645694",
"0.6453362",
"0.644213",
"0.6427064",
"0.64152914",
"0.6409475",
"0.63966775",
"0.63941807",
"0.63804245",
"0.63536394",
"0.63535... | 0.0 | -1 |
Determines whether a given user from the authentication server has a certain right or not. | def has_right(self, username: str, right: str) -> bool:
form: str = urlencode({'username': username, 'right': right})
headers: dict = {
'Content-type': 'application/x-www-form-urlencoded'
}
connection: HTTPConnection = self.__get_connection()
connection.request('GET',... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_roles_check(request):\n logger.debug('right_user_check')\n options = {\n 'api_file': {'GET': True, 'POST': False}\n }\n url_name = request.request.resolver_match.url_name\n if not request.request.user.is_authenticated:\n return False\n user_have_right = options[url_name][re... | [
"0.6864294",
"0.6832401",
"0.6566839",
"0.65181917",
"0.650468",
"0.6478974",
"0.64769286",
"0.64769286",
"0.6463664",
"0.64017993",
"0.6368617",
"0.634587",
"0.6326526",
"0.63013756",
"0.6293979",
"0.62584096",
"0.62548155",
"0.62485784",
"0.62485784",
"0.6244719",
"0.624461... | 0.7994539 | 0 |
Initialize TCP Protocol object. | def __init__(self, test_stream=None, no_delay=False, window=None, server=None):
self._transport = None
self._socket = None
self._stream = test_stream
self._logger = logging.getLogger('py3iperf3')
self._sock_id = None
self._no_delay = no_delay
self._window = window... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, af: int=AF_INET, type: int=SOCK_STREAM,\n proto: int=IPPROTO_TCP) -> None:\n ...",
"def __init__(self, protocol):\r\n self._protocol = protocol",
"def __init__(self):\n # Create a TCP/IP socket\n self.client_socket = socket.socket(socket.AF_INET, s... | [
"0.71132845",
"0.70866555",
"0.70138896",
"0.6893583",
"0.6840369",
"0.68216836",
"0.68001693",
"0.6701732",
"0.6666578",
"0.66378766",
"0.6552398",
"0.65229064",
"0.64933044",
"0.6475642",
"0.64572215",
"0.6449293",
"0.64326483",
"0.642818",
"0.6422145",
"0.6418033",
"0.6411... | 0.6103575 | 57 |
Update owner to test from server once ready | def set_owner(self, owner, is_stream=False):
if is_stream:
self._logger.debug('TCP Proto Stream is set!')
self._stream = owner
else:
self._server = owner | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_owner(self, owner):\n self.settings[\"owner\"] = owner",
"def set_owner(self, data):\n self._owner = self._uni(data)\n self.add_payload('owner', data)",
"def test_patch_project_owner(self):\n new_owner = self.make_user('new_owner')\n url = reverse(\n 'proje... | [
"0.6797942",
"0.659154",
"0.6493841",
"0.6467483",
"0.6394063",
"0.6364081",
"0.63616765",
"0.6348624",
"0.6277065",
"0.6234481",
"0.62229526",
"0.6220377",
"0.62035775",
"0.61991775",
"0.6164376",
"0.61599797",
"0.6117153",
"0.6114377",
"0.6114377",
"0.6114377",
"0.6114377",... | 0.0 | -1 |
Connection from the client established to the server | def connection_from_client(self, transport):
peer_data = transport.get_extra_info('peername')
self._logger.info('[%s] incomming connection from %s port %s',
self._sock_id, peer_data[0], peer_data[1])
self._server.tcp_connection_established(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _establish_connection(self):\n self.conn = self.listener.accept()",
"def connectToServer(self):\n self.client = Client(base_url = self.server)\n self.ping()",
"def connect_to_server(self):\r\n self.client_socket.connect((SERVER_IP, SERVER_PORT))\r\n print('[CLIENT] connec... | [
"0.7680837",
"0.7548338",
"0.7450128",
"0.7296759",
"0.72919726",
"0.7278883",
"0.7217436",
"0.7145088",
"0.713979",
"0.7058609",
"0.70077366",
"0.69932455",
"0.6990394",
"0.6990394",
"0.69863665",
"0.6966686",
"0.69573164",
"0.6947758",
"0.6946488",
"0.6913199",
"0.68871427"... | 0.67098856 | 35 |
Connecton to the server established | def connection_to_server_made(self, transport):
local_data = self._socket.getsockname()
peer_data = transport.get_extra_info('peername')
self._logger.info('[%s] local %s:%s connected to %s:%s',
self._sock_id, local_data[0], local_data[1],
pee... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect():",
"def connect_to_server(self):\n\n\t\tself.__logs.append('-- connecting to server ...')\n\t\tself.connect_to_ssh_server.emit(self.__ip.text(), int(self.__port.text()),\\\n\t\t\tself.__username.text(), self.__pwd.text())",
"def connectToServer(self):\n self.client = Client(base_url = self... | [
"0.7862597",
"0.76363",
"0.76069903",
"0.75337553",
"0.75265294",
"0.7431935",
"0.7408243",
"0.73457116",
"0.73268795",
"0.7316221",
"0.73118395",
"0.72880214",
"0.72818154",
"0.7272668",
"0.7272488",
"0.72519034",
"0.72483194",
"0.7231158",
"0.7217925",
"0.7170677",
"0.71644... | 0.0 | -1 |
Callback on connection lost. | def connection_lost(self, exc):
if self._stream.done:
# Stream is done, no need to panic
pass
else:
self._logger.debug('[%s] Connection lost!', self._sock_id, exc_info=exc) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connectionLost(reason):",
"def loseConnection(self):\n self.lost_connection.callback(self)\n return None",
"def connectionLost(self,reason):\n pass",
"async def connection_lost(self):\n logging.info('connection dropped')",
"def connectionLost(self, reason):\n self.set... | [
"0.8439273",
"0.8378254",
"0.8260436",
"0.8224796",
"0.79659545",
"0.7914527",
"0.79005694",
"0.7887815",
"0.7828399",
"0.78213745",
"0.77782845",
"0.777723",
"0.77576625",
"0.7752954",
"0.7751443",
"0.77181697",
"0.7660339",
"0.76011044",
"0.7588255",
"0.7577671",
"0.7528674... | 0.7628913 | 17 |
Write data to transport. | def send_data(self, data):
self._transport.write(data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, data, timeout_ms=None, **kwargs):\n raise NotImplementedError(\"implement in derived transport class\")",
"def send_message(self, data):\n self.transport.write(data)",
"def write(self, data):\n if self.closed:\n raise ConnectionResetError(\n 'Trans... | [
"0.7657331",
"0.76417875",
"0.76139855",
"0.7602521",
"0.7583665",
"0.75793827",
"0.75037515",
"0.7470128",
"0.74523485",
"0.739304",
"0.73432237",
"0.7279804",
"0.7269122",
"0.7266278",
"0.72515565",
"0.72349596",
"0.7186108",
"0.71751815",
"0.7171012",
"0.7165056",
"0.70937... | 0.8111547 | 0 |
Pause writing callback from transport. | def pause_writing(self):
self._stream.pause_writing() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resume_writing(self):\n self._stream.resume_writing()",
"def _write(self, chunk):\n if self.consumer and not self.stop_event.is_set():\n self.consumer.write(chunk)",
"def write(self, data):\n if self.closed:\n raise ConnectionResetError(\n 'Transpor... | [
"0.6722218",
"0.6428597",
"0.6101962",
"0.6073248",
"0.60059124",
"0.59187335",
"0.59112674",
"0.5894187",
"0.58766466",
"0.5876161",
"0.5810171",
"0.5754038",
"0.5754038",
"0.57490945",
"0.5720258",
"0.57075626",
"0.5706053",
"0.5704085",
"0.56786174",
"0.56786174",
"0.56483... | 0.7620428 | 0 |
Resume writing callback from transport. | def resume_writing(self):
self._stream.resume_writing() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resume_reading(self):\n raise NotImplementedError",
"def resume_reading(self):\n if not self._paused_reading:\n raise RuntimeError('Not paused')\n self._paused_reading = False\n if not self._closing:\n self._loop.add_reader(self._sock_fd)",
"def pause_writi... | [
"0.66734207",
"0.6322468",
"0.6029015",
"0.60129535",
"0.5927665",
"0.5927665",
"0.5844039",
"0.5816916",
"0.5816916",
"0.5816916",
"0.5802818",
"0.57859164",
"0.578517",
"0.57731336",
"0.5732798",
"0.5677215",
"0.56752896",
"0.5654607",
"0.5628291",
"0.5628291",
"0.5628291",... | 0.76703745 | 0 |
run time code. Always indent under function | def main():
# print 'red string' in red
print(crayons.red('red string'))
# Red White and Blue text
#print('{} white {}'.format(crayons.red('red'), crayons.blue('blue'))) # format string (old ver of str templating)
print(f"{crayons.red('red')} white {crayons.blue('blue')}") # f-string (newest vers... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def code():",
"def main_code():\n pass",
"def sth():",
"def smarter():\r\n pass",
"def func():",
"def my_function1():\n \n ## Your code here\n ## Add comments to clarify what the code is doing",
"def main():\n\tpass",
"def example():\n print \"\"\"\n \"\"\"",
"def example():\n pri... | [
"0.7658427",
"0.72334856",
"0.64985275",
"0.6444914",
"0.64356536",
"0.64256144",
"0.636132",
"0.63579184",
"0.63579184",
"0.6322875",
"0.6236482",
"0.6220282",
"0.62160146",
"0.6209243",
"0.6209243",
"0.6209243",
"0.6209243",
"0.6209243",
"0.6209243",
"0.6209243",
"0.6209243... | 0.0 | -1 |
Report the member's replica set state Submit a service check. Create an event on state change. | def _report_replica_set_state(self, state, clean_server_name, replset_name, agentConfig):
last_state = self._last_state_by_server.get(clean_server_name, -1)
self._last_state_by_server[clean_server_name] = state
if last_state != state and last_state != -1:
return self.create_event(las... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_member_status():\n notify_member_status()\n logger.info('signal sent for status report')",
"def send_event(instance_config, status, output):\n # This function assumes the input is a string like \"mumble.main\"\n monitoring_overrides = instance_config.get_monitoring()\n if 'alert_after' n... | [
"0.6125251",
"0.60838777",
"0.59746987",
"0.544692",
"0.54446894",
"0.5343415",
"0.5315016",
"0.5272492",
"0.5270251",
"0.52520496",
"0.52330935",
"0.5200511",
"0.519126",
"0.5157797",
"0.51535314",
"0.5149566",
"0.5147222",
"0.51382697",
"0.5132011",
"0.5124594",
"0.5110116"... | 0.6736493 | 0 |
Return a reasonable hostname for a replset membership event to mention. | def hostname_for_event(self, clean_server_name, agentConfig):
uri = urlsplit(clean_server_name)
if '@' in uri.netloc:
hostname = uri.netloc.split('@')[1].split(':')[0]
else:
hostname = uri.netloc.split(':')[0]
if hostname == 'localhost':
hostname = sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hostname(self) -> str:\n _args: list[Arg] = []\n _ctx = self._select(\"hostname\", _args)\n return _ctx.execute_sync(str)",
"def get_host_name():\n return socket.gethostname()",
"def get_hostname(self):\n return self.name",
"def get_hostname(self):\n prompt = self.se... | [
"0.6662921",
"0.6660988",
"0.6594623",
"0.6580937",
"0.65463096",
"0.65075785",
"0.650404",
"0.64858186",
"0.64726937",
"0.64697844",
"0.64234984",
"0.64135784",
"0.6406523",
"0.63904727",
"0.6379771",
"0.63460785",
"0.6342044",
"0.6332148",
"0.63308704",
"0.63301355",
"0.632... | 0.73296475 | 0 |
Create an event with a message describing the replication state of a mongo node | def create_event(self, last_state, state, clean_server_name, replset_name, agentConfig):
status = self.get_state_description(state)
short_status = self.get_state_name(state)
last_short_status = self.get_state_name(last_state)
hostname = self.hostname_for_event(clean_server_name, agentCo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printstatechange(self, event):\n print('printstatechange; event: %s, %s->%s' % (event.event, event.src, event.dst))\n try:\n self.mqttclient.publish(\"{}/{}/events\".format(self.config['MQTT']['TOPICBASE'],\n self.config['CLIENTI... | [
"0.53126144",
"0.5274733",
"0.5268226",
"0.52290887",
"0.52170926",
"0.5165227",
"0.51233536",
"0.5103651",
"0.50933707",
"0.50899076",
"0.50673026",
"0.4976149",
"0.49485195",
"0.48921156",
"0.48767117",
"0.48721194",
"0.48523217",
"0.4849296",
"0.48433527",
"0.47988123",
"0... | 0.61032283 | 0 |
Build the metric list to collect based on the instance preferences. | def _build_metric_list_to_collect(self, additional_metrics):
metrics_to_collect = {}
# Defaut metrics
for default_metrics in self.DEFAULT_METRICS.itervalues():
metrics_to_collect.update(default_metrics)
# Additional metrics metrics
for option in additional_metrics:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_metrics_to_collect(self, instance_key, additional_metrics):\n if instance_key not in self.metrics_to_collect_by_instance:\n self.metrics_to_collect_by_instance[instance_key] = \\\n self._build_metric_list_to_collect(additional_metrics)\n return self.metrics_to_colle... | [
"0.65387714",
"0.6310117",
"0.62119526",
"0.5793617",
"0.57547987",
"0.57211876",
"0.56583136",
"0.5615191",
"0.55901927",
"0.5546556",
"0.5533608",
"0.5482031",
"0.5463035",
"0.5445631",
"0.5387678",
"0.53774405",
"0.5351017",
"0.53399146",
"0.5310214",
"0.52838415",
"0.5282... | 0.6790621 | 0 |
Return and cache the list of metrics to collect. | def _get_metrics_to_collect(self, instance_key, additional_metrics):
if instance_key not in self.metrics_to_collect_by_instance:
self.metrics_to_collect_by_instance[instance_key] = \
self._build_metric_list_to_collect(additional_metrics)
return self.metrics_to_collect_by_inst... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metrics(self):\n self.metrics = []\n \n self.clients()\n\n if len(self.metrics) > 0:\n return self.metrics\n else:\n return []",
"def __get_metrics_list(self):\n metrics = metrics_calculator.MetricsCalculator(self.processor)\n metric_list... | [
"0.7655766",
"0.72332054",
"0.7133441",
"0.7121115",
"0.70482403",
"0.6939825",
"0.6939825",
"0.69326377",
"0.6834937",
"0.6780733",
"0.67768204",
"0.67722744",
"0.67699736",
"0.67531794",
"0.6749277",
"0.6653984",
"0.66414446",
"0.6635117",
"0.66295934",
"0.6618553",
"0.6590... | 0.6690178 | 15 |
Return the submit method and the metric name to use. | def _resolve_metric(self, original_metric_name, metrics_to_collect, prefix=""):
submit_method = metrics_to_collect[original_metric_name][0] \
if isinstance(metrics_to_collect[original_metric_name], tuple) \
else metrics_to_collect[original_metric_name]
metric_name = metrics_to_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def method(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"method\")",
"def metric_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"metric_name\")",
"def metric_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"metric_name\")",
"def metric_name(self) -> pul... | [
"0.60242224",
"0.5900693",
"0.5900693",
"0.5900693",
"0.5900693",
"0.5900693",
"0.5900693",
"0.5900693",
"0.5900693",
"0.5900693",
"0.5779224",
"0.5709764",
"0.56761044",
"0.5673215",
"0.56213224",
"0.5533348",
"0.550876",
"0.54920304",
"0.5490709",
"0.5478249",
"0.5478249",
... | 0.6122732 | 0 |
Replace casesensitive metric name characters, normalize the metric name, prefix and suffix according to its type. | def _normalize(self, metric_name, submit_method, prefix):
metric_prefix = "mongodb." if not prefix else "mongodb.{0}.".format(prefix)
metric_suffix = "ps" if submit_method == RATE else ""
# Replace case-sensitive metric name characters
for pattern, repl in self.CASE_SENSITIVE_METRIC_NAM... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sanitize_metric_name(name: str) -> str:\n name = name.replace(\":\", \"-\")\n return name",
"def normalize_label(label: str) -> str:\n label = re.sub(r\"['\\\"`]+\", \"\", label) # remove apostrophes\n label = re.sub(r\"[-/\\\\ \\t_]+\", \" \", label) # normalize separators\n low... | [
"0.6782942",
"0.6727968",
"0.6660268",
"0.65970635",
"0.6492408",
"0.63663113",
"0.63579243",
"0.62790793",
"0.6254779",
"0.6217546",
"0.6214412",
"0.61892366",
"0.6164987",
"0.6164987",
"0.6164987",
"0.60686266",
"0.602515",
"0.60172975",
"0.5997466",
"0.59772354",
"0.597167... | 0.7554459 | 0 |
Authenticate to the database. | def _authenticate(self, database, username, password, use_x509, server_name, service_check_tags):
authenticated = False
try:
# X.509
if use_x509:
self.log.debug(
u"Authenticate `%s` to `%s` using `MONGODB-X509` mechanism",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authenticate(self):\n self.connection.authenticate()",
"def authenticate(self):\n self.login(closet.app.config['USERNAME'],\n closet.app.config['PASSWORD'])",
"def authenticate(self, username, password):\n user = self.db.get_user(username)\n print(user)\n\n ... | [
"0.8034163",
"0.7336118",
"0.71159965",
"0.7013732",
"0.68405634",
"0.6696718",
"0.66948277",
"0.6579576",
"0.65778863",
"0.6499458",
"0.6477201",
"0.6470728",
"0.6464623",
"0.6462387",
"0.6462387",
"0.6457548",
"0.6450114",
"0.6425771",
"0.64103705",
"0.6391898",
"0.63897616... | 0.6341946 | 23 |
Collect indexes statistics for all collections in the configuration. This use the "$indexStats" command. | def _collect_indexes_stats(self, instance, db, tags):
for coll_name in instance.get('collections', []):
try:
for stats in db[coll_name].aggregate([{"$indexStats": {}}], cursor={}):
idx_tags = tags + [
"name:{0}".format(stats.get('name', 'un... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index_stats(self):\n #Create Index\n self.run_multi_operations(buckets = self.buckets,\n query_definitions = self.query_definitions,\n create_index = True, drop_index = False)\n #Check Index Stats\n self.sleep(30)\n index_map = self.get_index_stats(... | [
"0.7033326",
"0.6837621",
"0.66362005",
"0.65313584",
"0.626018",
"0.62069684",
"0.6138566",
"0.612696",
"0.6071093",
"0.58983314",
"0.58849525",
"0.58647007",
"0.5845978",
"0.58452255",
"0.5805989",
"0.57855815",
"0.577376",
"0.5711172",
"0.5703516",
"0.56850964",
"0.5676570... | 0.78779423 | 0 |
Returns a dictionary that looks a lot like what's sent back by db.serverStatus() | def check(self, instance):
def total_seconds(td):
"""
Returns total seconds of a timedelta in a way that's safe for
Python < 2.7
"""
if hasattr(td, 'total_seconds'):
return td.total_seconds()
else:
return (
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_server_status(fields=[]):\n return get_dict_from_db(key='status', fields=fields)",
"def status() -> Dict[str, Any]:",
"def status(self):\n now = int(time())\n return {\n 'smrt': {\n 'smrt_version': '1.0.0',\n 'app_loaded': True,\n ... | [
"0.80077225",
"0.75977504",
"0.7279898",
"0.7164739",
"0.7101741",
"0.70730436",
"0.69886345",
"0.6890773",
"0.6871693",
"0.6844543",
"0.6762656",
"0.67537475",
"0.67115015",
"0.6665098",
"0.66358525",
"0.66358525",
"0.66328067",
"0.6618087",
"0.6522873",
"0.6517588",
"0.6512... | 0.0 | -1 |
Returns total seconds of a timedelta in a way that's safe for Python < 2.7 | def total_seconds(td):
if hasattr(td, 'total_seconds'):
return td.total_seconds()
else:
return (
lag.microseconds +
(lag.seconds + lag.days * 24 * 3600) * 10**6
) / 10.0**6 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_seconds(delta):\n try:\n return delta.total_seconds()\n except AttributeError:\n return ((delta.days * 24 * 3600) + delta.seconds +\n float(delta.microseconds) / (10 ** 6))",
"def total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1... | [
"0.78919387",
"0.78847253",
"0.783023",
"0.78134507",
"0.76809853",
"0.7531021",
"0.7426013",
"0.73222214",
"0.7240662",
"0.72142905",
"0.705758",
"0.70381075",
"0.6971049",
"0.69674176",
"0.69023997",
"0.6851663",
"0.68447584",
"0.6843502",
"0.6830019",
"0.6829389",
"0.68122... | 0.74855494 | 6 |
Test case for upload_area | def test_upload_area(self):
area = areamsg
query_string = [('deliveryAckEndPoint', 'https://localhost:8002')]
response = self.client.open('/area',
method='POST',
data=area,
query_string=qu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_multi_area(self):\n pass",
"def test_upload_file(self):\n pass",
"def test_upload_file1(self):\n pass",
"def test_upload_job_description_file_post(self):\n pass",
"def test_upload(self):\n with self.client:\n file = dict(\n file=(BytesIO... | [
"0.68717897",
"0.67497677",
"0.64811105",
"0.6158702",
"0.61027944",
"0.60922873",
"0.59541386",
"0.59376353",
"0.5898766",
"0.5843938",
"0.58039546",
"0.5802995",
"0.5782079",
"0.5776933",
"0.5713552",
"0.56940377",
"0.5679234",
"0.5669817",
"0.56505054",
"0.56200916",
"0.56... | 0.67986137 | 1 |
Test case for upload_area cleanup | def test_upload_area_cleanup(self):
vis2_uvid='urn:mrn:stm:service:instance:furuno:vis2'
p = Path('import')
files = list(p.glob('**/urn:mrn:s124:*'))
for item in files:
print(item)
os.remove(str(item))
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_final_cleanup():\n cleanup_file(\"tfsaves\")",
"def tearDown(self):\n self.tmp.cleanup()",
"def cleanup():",
"def _cleanup(self):\n pass",
"def test_cleanup(self):\n imgurl = \"{}spei03.nc\".format(self.processor.base_url)\n httpretty.register_uri(httpretty.GET, imgurl,\... | [
"0.6206157",
"0.6140681",
"0.6071183",
"0.6062651",
"0.6050911",
"0.6030279",
"0.6009838",
"0.6004148",
"0.6004148",
"0.6004148",
"0.6001869",
"0.5971952",
"0.5948387",
"0.59369427",
"0.59284383",
"0.5869602",
"0.5861927",
"0.5838485",
"0.5838485",
"0.5813883",
"0.5788908",
... | 0.6698037 | 0 |
Takes in a trajectory file and uploads it to the database | def upload_trajectory(cls, trajectory_file):
# extract the attributes from the file name
pitch, roll, u0 = cls.extract_pitch_roll_velocity(
trajectory_file)
# get or create a database object with those attributes
trajectory, created = SolvedTrajectory.objects.get_or_create(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_trajectory(trajectory):\n query = \"INSERT INTO trajectories (idUser, startTime, endTime) VALUES (%(id_user)s, %(start_time)s, %(end_time)s)\"\n\n trajectory_data = {\n 'id_user': trajectory.id_user,\n 'start_time': trajectory.start_time,\n 'end_time': trajectory.end_time\n }... | [
"0.67590135",
"0.6199504",
"0.60810244",
"0.5968449",
"0.5886125",
"0.5864965",
"0.58335364",
"0.5823321",
"0.58050644",
"0.5799841",
"0.57324755",
"0.57312024",
"0.57259333",
"0.57164156",
"0.5702718",
"0.569988",
"0.5675204",
"0.5665265",
"0.5634949",
"0.5631133",
"0.563033... | 0.7878746 | 0 |
Iterates through every trajectory that has been solved for and then uploads the trajectory that has been solved for | def sync_dir(self):
# mark the trajectories that we have seen
trajectories = os.listdir(self.trajectory_dir)
for trajectory_file in trajectories:
if trajectory_file not in self.seen_trajectories:
created = self.upload_trajectory(trajectory_file)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build(self, trajectory):\n #TODO Implement?",
"def build(self, trajectory):\n pass",
"def compute_trajectory():\n pass",
"def _insertAllSteps(self): \n self.uMics = self.inputCoordinatesTiltedPairs.get().getUntilted().getMicrographs()\n self.tMics = self.inputCoordina... | [
"0.59522563",
"0.59471226",
"0.5912256",
"0.5899517",
"0.5856624",
"0.5813247",
"0.57508117",
"0.57315934",
"0.5581307",
"0.55410546",
"0.5502698",
"0.54654527",
"0.5458855",
"0.53929365",
"0.53702384",
"0.5347481",
"0.5322975",
"0.53141",
"0.52880365",
"0.5242809",
"0.524104... | 0.6943155 | 0 |
returns a list of classes and titles, parsing through 'html' | def get_classes(html):
# elements = html.find_all("span", "code")
# titles = html.find_all("span", "title")
# classes = []
# for i in range(len(elements)):
# item = elements[i]
# tit = titles[i]
# classes += [(item.text.replace('\xa0', ' '), tit.text.replace('\xa0', ' '))]
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def EnrolledClasses(self,html): \n classes = []\n soup = BeautifulSoup(html)\n for element in soup.find_all(\"input\"):\n if element[\"name\"] == \"TITLE\" and element[\"value\"]:\n classes.append(element.get(\"value\"))\n return classes",
"def extract_all_tags(final_link, driver):\n\n ... | [
"0.8052008",
"0.6688938",
"0.6265724",
"0.6265724",
"0.61887735",
"0.6152137",
"0.60088265",
"0.5969638",
"0.5957513",
"0.59506553",
"0.59392065",
"0.59321856",
"0.5919949",
"0.5894865",
"0.5883525",
"0.5863221",
"0.5795686",
"0.5791473",
"0.57911634",
"0.5790925",
"0.5789725... | 0.80175537 | 1 |
Download master cdf file from cdaweb for 'dataset' | def _download_metafile(dataset, path=None):
if not path:
path = sunpy.config.get('downloads', 'sample_dir')
base_url = 'https://spdf.gsfc.nasa.gov/pub/software/cdawlib/0MASTERS/'
fname = dataset.lower() + '_00000000_v01.cdf'
url = base_url + fname
try:
downloaded_file = pooch.retriev... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def downloadFile()-> None:\n logging.info(f\"Downloading current data set {getTime()}\")\n with open(DATA_FILE,\"wb\") as f:\n f.write(get(\"https://covid.ourworldindata.org/data/owid-covid-data.csv\").text.encode())\n logging.info(f\"Finished Downloading current data set {getTime()}\")",
"def do... | [
"0.6694223",
"0.6588644",
"0.65666646",
"0.65666646",
"0.6565688",
"0.64363176",
"0.64334583",
"0.6366243",
"0.63625884",
"0.63276845",
"0.6297841",
"0.6201097",
"0.61550426",
"0.61423147",
"0.61154634",
"0.6100518",
"0.6091457",
"0.60131127",
"0.5990933",
"0.5977136",
"0.591... | 0.71092033 | 0 |
Downloads Wind/3DP CDF files via SunPy/Fido from CDAWeb | def wind3dp_download_fido(dataset, startdate, enddate, path=None, max_conn=5):
trange = a.Time(startdate, enddate)
cda_dataset = a.cdaweb.Dataset(dataset)
try:
result = Fido.search(trange, cda_dataset)
filelist = [i[0].split('/')[-1] for i in result.show('URL')[0]]
filelist.sort()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_engine(fcsd): #fcsd = first comic strip date\n\n url_list = get_comic_strip_url(fcsd)\n\n for url in url_list:\n session = requests.Session()\n response = session.get(url)\n download_url = get_image_comic_url(session, response)\n# download_dilbert(session, download_ur... | [
"0.6992597",
"0.6586604",
"0.6586604",
"0.62284845",
"0.62214994",
"0.6183709",
"0.6142462",
"0.61349034",
"0.60533696",
"0.6041575",
"0.6032721",
"0.601811",
"0.5998015",
"0.5983272",
"0.59466475",
"0.5895252",
"0.5893261",
"0.5883837",
"0.58763474",
"0.58670187",
"0.5820259... | 0.6681552 | 1 |
Download a single Wind/3DP level 2 data file from SRL Berkeley to local path | def wind3dp_single_download(file, path=None):
# add a OS-specific '/' to end end of 'path'
if path:
if not path[-1] == os.sep:
path = f'{path}{os.sep}'
else:
path = sunpy.config.get('downloads', 'download_dir') + os.sep
data = file.split('_')[1] # e.g. 'sfsp'
year = fi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_hess_dr1_data():\n download_data_files(FILENAMES_HESS_DR1)",
"def download():\r\n reader = GSODDataReader()\r\n year_list = range(2001, 2012)\r\n austin = reader.collect_data(year_list, exact_station=True,\r\n station_name='AUSTIN CAMP MABRY', state='TX', country='US')\r\n hous... | [
"0.67398626",
"0.6583231",
"0.6520613",
"0.6331625",
"0.6304204",
"0.6291874",
"0.6226741",
"0.62254614",
"0.62199074",
"0.61869997",
"0.60891455",
"0.60750973",
"0.6024186",
"0.60179967",
"0.60074246",
"0.5984744",
"0.59611046",
"0.5960039",
"0.5954429",
"0.5950052",
"0.5932... | 0.69402546 | 0 |
Downloads Wind/3DP CDF files via SunPy/Fido from CDAWeb | def wind3dp_download(dataset, startdate, enddate, path=None, **kwargs):
trange = a.Time(startdate, enddate)
cda_dataset = a.cdaweb.Dataset(dataset)
try:
result = Fido.search(trange, cda_dataset)
filelist = [i[0].split('/')[-1] for i in result.show('URL')[0]]
filelist.sort()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_engine(fcsd): #fcsd = first comic strip date\n\n url_list = get_comic_strip_url(fcsd)\n\n for url in url_list:\n session = requests.Session()\n response = session.get(url)\n download_url = get_image_comic_url(session, response)\n# download_dilbert(session, download_ur... | [
"0.69927144",
"0.6681631",
"0.6586002",
"0.6586002",
"0.6227894",
"0.6220564",
"0.6184514",
"0.61419713",
"0.6135068",
"0.60416824",
"0.60323346",
"0.6019162",
"0.59976286",
"0.5984312",
"0.59463805",
"0.58946854",
"0.589323",
"0.5883891",
"0.5876614",
"0.5867642",
"0.5821249... | 0.60538065 | 9 |
Loadin data for Wind/3DP instrument. Provides released data obtained by SunPy through CDF files from CDAWeb. Returns data as Pandas dataframe. | def wind3dp_load(dataset, startdate, enddate, resample="1min", multi_index=True,
path=None, threshold=None, **kwargs):
files = wind3dp_download(dataset, startdate, enddate, path)
if len(files) > 0:
df = _wind3dp_load(files, resample, threshold)
# download master file from CDAWe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_cdf_wind3dp(fname, ignore_vars=[]):\n import astropy.units as u\n from cdflib.epochs import CDFepoch\n from packaging.version import Version\n from sunpy import log\n from sunpy.timeseries import GenericTimeSeries\n from sunpy.util.exceptions import warn_user\n cdf = cdflib.CDF(str(f... | [
"0.6468716",
"0.64177483",
"0.63601965",
"0.6326345",
"0.6200869",
"0.6196842",
"0.6185922",
"0.6155612",
"0.6130087",
"0.6104664",
"0.6011164",
"0.60078377",
"0.6003299",
"0.59791",
"0.59743065",
"0.5966459",
"0.596409",
"0.5956343",
"0.59252155",
"0.59170336",
"0.5893538",
... | 0.6185055 | 7 |
Read a CDF file that follows the ISTP/IACG guidelines. | def _read_cdf_wind3dp(fname, ignore_vars=[]):
import astropy.units as u
from cdflib.epochs import CDFepoch
from packaging.version import Version
from sunpy import log
from sunpy.timeseries import GenericTimeSeries
from sunpy.util.exceptions import warn_user
cdf = cdflib.CDF(str(fname))
#... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_dicom_file(fname):\n fo = open(fname)\n try:\n preamble = fo.read(128)\n magic = fo.read(4)\n if len(preamble) != 128 or magic != 'DICM':\n raise InvalidDicomError\n fo.seek(0)\n do = dicom.read_file(fo)\n finally:\n fo.close()\n return do",... | [
"0.60510045",
"0.604307",
"0.5898858",
"0.5860045",
"0.5791958",
"0.5680922",
"0.5642261",
"0.5582769",
"0.5567393",
"0.5543166",
"0.5474913",
"0.54198694",
"0.54080296",
"0.53842884",
"0.5370347",
"0.53613174",
"0.53224874",
"0.5320849",
"0.53164923",
"0.53088623",
"0.530528... | 0.0 | -1 |
Get the indices of words where all keywords occur most closely together Takes one keyword, and performs binary search for each index of that keyword for other keywords. Absolute distance is added, result is sorted and top `K` are extracted | def get_closest(occurences, content, k=25):
result = []
o = occurences[0] #get first
for idx in o:
res = 0
for i in range(1, len(occurences)): #other than first
oo = occurences[i]
where = bisect_left(oo, idx)
#try both, after and before the binary searched... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top_k(indices, words, k):\n inds = np.argpartition(indices, -k)[-k:]\n topkwords = words[inds]\n topkvals = indices[inds]\n top = [(word, val) for word, val in zip(topkwords, topkvals)]\n top = sorted(top, key=lambda t: t[1], reverse=True)\n return top",
"def topKSimilar(self,word,k = 5,max... | [
"0.70105875",
"0.69487935",
"0.6726304",
"0.6642951",
"0.6558925",
"0.6321629",
"0.6267497",
"0.6247251",
"0.62325543",
"0.6175135",
"0.6156061",
"0.60509574",
"0.60417193",
"0.6032859",
"0.6018945",
"0.5914206",
"0.58785915",
"0.58734584",
"0.58478695",
"0.5831793",
"0.58169... | 0.6156018 | 11 |
Find all occurences of a keyword progressively, until it isn't present anymore | def get_all_occurences(s, word):
res = [0]
print("Searching for " + word)
while True:
try:
idx = s.index(word, res[-1])
res.append(idx+1)
#print("found at ", idx)
except ValueError:
break
return res[1:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetchRelatedkeywords(self, keyword, meta_keyword):\n prefix = [\"how\", \"which\", \"why\", \"where\", \"who\", \"when\", \"are\", \"what\"]\n suffix = [\"\", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\",\n \"m\", \"n\", \"o\", \"p\", \"q\", ... | [
"0.5892223",
"0.56149435",
"0.5609027",
"0.5558268",
"0.5548612",
"0.54912615",
"0.54362696",
"0.54015934",
"0.53735536",
"0.53658015",
"0.53658015",
"0.5305467",
"0.5299855",
"0.5296011",
"0.5276156",
"0.52694416",
"0.5258406",
"0.52114064",
"0.52089685",
"0.5205524",
"0.517... | 0.5443021 | 6 |
Returns the current state of the gameboard and the two player's colors. Returns np.ndarray a flat 1D representation of the gameboard appended by the two players' colors | def get_state(self):
return np.append(self.game.game_board.get_board(),
[self.game.player_1.color, self.game.player_2.color])[None, :] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_current_game_state(board):\n return np.concatenate((_get_pieces_one_hot(board, color=False),\n _get_pieces_one_hot(board, color=True)),\n axis=-1)",
"def return_state(board):\r\n state = np.array(INIT_ARRAY)\r\n for pos in BOARD_POSITIO... | [
"0.6973377",
"0.6708354",
"0.6522196",
"0.651381",
"0.651381",
"0.6499365",
"0.6218236",
"0.6212448",
"0.6204406",
"0.61157256",
"0.6032963",
"0.60149604",
"0.6009506",
"0.59559596",
"0.5954081",
"0.5951532",
"0.58624077",
"0.58483106",
"0.58110374",
"0.57483196",
"0.5746821"... | 0.8583118 | 0 |
Performs the specified action in the environment and returns the observation, \ reward, and if the game is over. | def step(self, action):
self.game.play_single_turn([action])
next_obs = self.get_state()
reward = self.game.player_1.score - self.game.turn_count
done = self.game.check_for_end_of_game() or self.game.turn_count > 25
if done:
if self.game.player_1.score > self.game.pl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def perform_action(self, action):\n \n assert self.is_valid_action(action)\n \n # Save the action.\n self.action = action\n \n #the slight strategy of the opponent\n if self.reward==rLose :\n observation = self.observation\n else:\n ... | [
"0.7654873",
"0.75809324",
"0.73705",
"0.7285594",
"0.7201223",
"0.710793",
"0.7067227",
"0.70066214",
"0.6996156",
"0.69719476",
"0.6938891",
"0.69306713",
"0.6914033",
"0.6892272",
"0.6873118",
"0.68673706",
"0.68626064",
"0.68542176",
"0.685064",
"0.6846933",
"0.68432224",... | 0.0 | -1 |
Returns the possible color options that can be played. Returns list a list of the possible color options (as integers) | def get_color_options(self):
mask = (self.all_colors != self.player_1.color) & (self.all_colors != self.player_2.color)
return self.all_colors[mask] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_player_colors() -> List[Tuple[float, float, float]]:\n return PLAYER_COLORS",
"def supported_color_modes(self) -> set[str] | None:\n color_modes = [COLOR_MODE_ONOFF]\n if self.dp_code_bright in self.tuya_device.status:\n color_modes.append(COLOR_MODE_BRIGHTNESS)\n\n if ... | [
"0.70465565",
"0.65711427",
"0.6478505",
"0.64456594",
"0.6323879",
"0.62680316",
"0.61799985",
"0.6158194",
"0.61572695",
"0.61044914",
"0.6100955",
"0.60627854",
"0.60627854",
"0.60460067",
"0.60313606",
"0.59857523",
"0.59533656",
"0.5913804",
"0.5863346",
"0.58114314",
"0... | 0.75890493 | 0 |
Checks if the game is over. The game is over if the players' scores are greater than the number of cells. Returns bool True if the game is over, False otherwise | def check_for_end_of_game(self):
return self.player_1.score + self.player_2.score >= self.number_of_cells | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def game_over(self) -> bool:\n for row in range(9):\n for col in range(9):\n if self._grid_sol[row][col] != self.get_cell(row, col):\n return False\n return True",
"def _check_game_over(self):\n return self.game_board.check_game_over()",
"def is... | [
"0.8031195",
"0.79091746",
"0.78659517",
"0.783071",
"0.77987564",
"0.7613732",
"0.7612134",
"0.7563146",
"0.7546135",
"0.75450456",
"0.75265986",
"0.7522862",
"0.7521878",
"0.7511197",
"0.75016576",
"0.74913526",
"0.7444311",
"0.7433588",
"0.7423347",
"0.7408691",
"0.7385972... | 0.77203864 | 5 |
Completes a single turn by showing the gameboard, playing each of the players' turns, and printing the result. The former and latter are only done if the game type is RL. | def play_single_turn(self, action=None):
self.turn_count += 1
if self.save_images_suffix:
self.game_board.graphical_output(save=True, display=False,
image_suffix=f'{self.save_images_suffix}_{self.turn_count}')
if self.game_type == self.gam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finishTurn(self):\n print \"go\"\n sys.stdout.flush()",
"def play(self, turn):\n # global black_prompt, white_prompt, res, pi, board\n if turn % 2 == 0:\n prompt, requests_add, responses_add, color_to_play = self.bp, self.bp, self.wp, BLACK\n print(\"pure\")\... | [
"0.688064",
"0.66935813",
"0.6467623",
"0.64412105",
"0.6440219",
"0.6420127",
"0.63784677",
"0.6366233",
"0.635333",
"0.62903583",
"0.62639993",
"0.62625086",
"0.6251562",
"0.6237911",
"0.6230091",
"0.6221477",
"0.62081194",
"0.6202306",
"0.616118",
"0.6145242",
"0.6123327",... | 0.67183626 | 1 |
Completes the entire game by playing turns until the game is over and then prints the result. | def play_game(self, early_finish=False):
automated = self.game_type == self.game_types['vs_ai']
while not (self.check_for_end_of_game() or (early_finish and self.check_for_early_finish())):
self.play_single_turn()
if automated:
input('Press any key to continue.\n'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finishTurn(self):\n print \"go\"\n sys.stdout.flush()",
"def _do_outputs(self):\n self._puzzle.display_revealed_puzzle()\n hint = self._puzzle.get_hint()\n self._console.write(hint)\n print(\"\")\n self._jumper.draw_jumper()\n print(\"\")\n\n # T... | [
"0.7868776",
"0.722649",
"0.68513465",
"0.6713279",
"0.67080253",
"0.66717774",
"0.6625295",
"0.6593353",
"0.6520406",
"0.65030307",
"0.6463218",
"0.6455685",
"0.6454045",
"0.6443304",
"0.6435754",
"0.6430937",
"0.6429039",
"0.6426349",
"0.63851017",
"0.6380919",
"0.6375855",... | 0.0 | -1 |
Outputs the gameboard as text. | def text_output(self):
print(self.board)
print() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_board(self):\n print(self.game_board)",
"def render_board(self):\n print \"\"\n for row in self._board:\n print row",
"def draw(self):\n res = ''\n # ANSI code to clear the screen\n #res += chr(27) + \"[2J\"\n for position, value in enumer... | [
"0.76990277",
"0.7684276",
"0.7571131",
"0.75571936",
"0.75506896",
"0.75325507",
"0.7497205",
"0.7475444",
"0.74271286",
"0.7372031",
"0.7361939",
"0.73593736",
"0.7353311",
"0.73500687",
"0.7348999",
"0.7339537",
"0.73229283",
"0.73167104",
"0.7309406",
"0.7297968",
"0.7288... | 0.8650465 | 0 |
Outputs the gameboard in a MatPlotLib window that is updated everytime this function is called. The 2D numpy array is converted to colors using the COLORS dictionary and then repeated to create an image. | def graphical_output(self, block=False, save=False, display=True, folder_name='output', image_suffix=None):
masks = [np.where(self.board == i, True, False) for i in range(self.number_of_colors)]
output = np.zeros((self.height, self.width, 3), dtype=np.int)
for mask, color in zip(masks, list(COLO... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_board():\n count = 0\n cars = {}\n cmap = colors.ListedColormap(['white','purple', 'brown', 'red', 'pink', 'black', 'beige', 'yellow', 'turquoise', 'coral', 'grey', 'navy', 'indigo', 'cyan', 'olive', 'maroon', 'silver', 'lime', 'teal', 'tan', 'aquamarine', 'violet', 'magenta', 'chartreuse', ... | [
"0.7340595",
"0.6782643",
"0.6562929",
"0.6523237",
"0.64797074",
"0.6475668",
"0.6462612",
"0.6370303",
"0.6243013",
"0.62422794",
"0.6232159",
"0.6221264",
"0.62133884",
"0.6183281",
"0.61543",
"0.61533546",
"0.6152027",
"0.61465985",
"0.6143385",
"0.6136374",
"0.61292225",... | 0.66855747 | 2 |
Gets the color at the specified coordinates on the gameboard. | def get_color(self, coord):
return self.board[coord[0], coord[1]] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_color(self, _pos):\n return self.__framebuffer[_pos]",
"def _get_color(self, r, g, b):\n clr = (r, g, b)\n return clr",
"def get_colour(self, x, y):\n if x >= self.width or y >= self.height:\n return (0, 0, 0)\n\n return self.env_img.get_at((int(x), int(y))... | [
"0.6995972",
"0.67755926",
"0.6742886",
"0.6678613",
"0.66424483",
"0.6595865",
"0.65444714",
"0.6500604",
"0.6482022",
"0.64749384",
"0.64731526",
"0.6466952",
"0.6460171",
"0.6415692",
"0.6340766",
"0.6315026",
"0.63021356",
"0.6299288",
"0.62905073",
"0.62475747",
"0.62238... | 0.81525886 | 0 |
Sets the color at the specified cells on the gameboard. | def set_color(self, color, filled):
for cell in filled:
self.board[cell[0], cell[1]] = color | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_color(board, tile, color):\n for el in tile:\n el_x = el[0]\n el_y = el[1]\n board[el_x,el_y] = color",
"def set(self, row: int, col: int, color: Color) -> None:\n super(ColorGrid, self).set(row, col, color)",
"def change_cell_bgcolor(self, cell: tuple, color: str = \"... | [
"0.66752845",
"0.6670882",
"0.6661175",
"0.6591124",
"0.6471529",
"0.6251041",
"0.61291766",
"0.61236733",
"0.61236733",
"0.60985804",
"0.60878223",
"0.60815275",
"0.60369647",
"0.6032888",
"0.6024978",
"0.60133576",
"0.60054994",
"0.59898573",
"0.5964465",
"0.59419614",
"0.5... | 0.7248661 | 0 |
Checks if the new cell has the same color. If so, then it will be added to filled_edges. | def check_if_filled(self, new_cell, cell_color, filled_edges, filled_surrounded):
new_cell_color = self.get_color(new_cell)
if new_cell_color != cell_color:
return False
if new_cell not in filled_edges + filled_surrounded:
filled_edges.append(new_cell)
return Tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_filled(self, filled_edges, filled_surrounded):\n surrounded_cells = []\n for cell in filled_edges:\n coord_x = cell[1]\n coord_y = cell[0]\n color = self.get_color(cell)\n surrounded = True\n\n # up\n if coord_y - 1 >= 0:\n ... | [
"0.68136656",
"0.6298156",
"0.62293226",
"0.61843455",
"0.60629505",
"0.6019774",
"0.5996726",
"0.59899193",
"0.59833056",
"0.59146136",
"0.58846736",
"0.58377993",
"0.57722366",
"0.5716285",
"0.5706663",
"0.56588453",
"0.5620642",
"0.5616831",
"0.56144696",
"0.56116164",
"0.... | 0.8191558 | 0 |
Updates the list of cells that belong to the player. The edge cells will be checked to see if adjoining cells have the same color. If a cell is surrounded by the same color, then it will be moved to the surrounded cells list and not be checked further. | def update_filled(self, filled_edges, filled_surrounded):
surrounded_cells = []
for cell in filled_edges:
coord_x = cell[1]
coord_y = cell[0]
color = self.get_color(cell)
surrounded = True
# up
if coord_y - 1 >= 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n for player in self.players:\n player.update()\n player.last_seen = player.current_cell\n\n self.in_cell()\n for player in self.players:\n if player.current_cell != player.last_seen:\n self.player_paths.add(player.last_seen)\n ... | [
"0.72930026",
"0.68095976",
"0.6565382",
"0.63855034",
"0.623758",
"0.6231316",
"0.62005574",
"0.615561",
"0.61323214",
"0.6109885",
"0.6100814",
"0.6096795",
"0.6084608",
"0.60593855",
"0.59803164",
"0.59193355",
"0.5863843",
"0.58529425",
"0.5852107",
"0.58215886",
"0.57433... | 0.6750988 | 2 |
Counts the number of adjacent cells of the specified color. | def get_color_count(self, color, filled):
count = 0
for cell in filled:
coord_x = cell[1]
coord_y = cell[0]
# up
if coord_y - 1 >= 0:
new_cell = (coord_y-1, coord_x)
cell_up_color = self.get_color(new_cell)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_colors(board, color):\n n = 0\n for cell in board:\n if cell == color:\n n += 1\n elif cell == cinv(color):\n n -= 1\n return n",
"def countDiff(self, color):\n count = 0\n for y in range(self.n):\n for x in range(self.n):\n ... | [
"0.7808628",
"0.7358172",
"0.7177182",
"0.6915037",
"0.6702927",
"0.66539484",
"0.634662",
"0.6150625",
"0.60990244",
"0.6096208",
"0.6083482",
"0.59975606",
"0.5963964",
"0.59438294",
"0.5927667",
"0.5881134",
"0.58247036",
"0.58202237",
"0.5811849",
"0.5797079",
"0.57578915... | 0.74115384 | 1 |
Flattens the gameboard and returns it as a 1D array. Returns np.ndarray a flat 1D representation of the gameboard | def get_board(self):
return self.board.copy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten_numpy(ndarray):\n return np.reshape(ndarray, (-1,), 'F')",
"def flatten_rows(self, arr: np.array) -> torch.Tensor:\n snake_ = []\n k = 1\n for row in arr:\n snake_ += list(row[::k])\n k *= -1\n return torch.tensor(snake_).unsqueeze(-1)",
... | [
"0.62531096",
"0.61981404",
"0.61488134",
"0.6146238",
"0.6139373",
"0.61236525",
"0.61006224",
"0.605742",
"0.6032158",
"0.58906454",
"0.58046883",
"0.57959795",
"0.57739055",
"0.5723731",
"0.57159185",
"0.56728446",
"0.5669656",
"0.5646378",
"0.5644627",
"0.5641197",
"0.563... | 0.0 | -1 |
Trace decorator for use with recursive functions. | def trace(f):
indent = ' '
def _f(*args):
signature = '%s(%s)' % (f.__name__, ', '.join(map(repr, args)))
print '%s--> %s' % (trace.level*indent, signature)
trace.level += 1
try:
result = f(*args)
print '%s<-- %s == %s' % ((trace.level-1)*indent,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trace(func):\n @wraps(func)\n def tracer(*args, **kwargs):\n name = func.__name__\n stack_size = int(len(inspect.stack(0)) / 2) # @wraps(func) is also increasing the size\n indent = stack_size*'\\t'\n print(f'{indent} > Entering \"{name}\": args: {args}')\n result = fu... | [
"0.7315188",
"0.7188264",
"0.70268303",
"0.688243",
"0.688243",
"0.6847975",
"0.68394035",
"0.6646007",
"0.63865286",
"0.6358532",
"0.6295772",
"0.6160866",
"0.60975045",
"0.60519403",
"0.59872144",
"0.59862864",
"0.5976006",
"0.5974944",
"0.59432507",
"0.5927856",
"0.5881031... | 0.66391844 | 8 |
Once proper file has been found, get it. | def download_it(fw, acquisition, file_name, input_path):
safe = make_file_name_safe(file_name, replace_str='_')
full_path = input_path + safe
if acquisition.timestamp:
if acquisition.timezone:
created = acquisition.original_timestamp.isoformat()
else:
created = acq... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(name):\n\n filename = find(name)\n if filename == None:\n return name\n return open(filename).read()",
"def _fs_get_file(url, working_dir):\n if not os.path.isabs(url) and working_dir:\n url = os.path.join(working_dir, url)\n\n try:\n with codecs.open(u... | [
"0.7244406",
"0.7236674",
"0.709632",
"0.7088684",
"0.68636674",
"0.6847282",
"0.6831245",
"0.6783735",
"0.67528933",
"0.671292",
"0.6656482",
"0.6624175",
"0.6588251",
"0.65659696",
"0.6486953",
"0.64499605",
"0.64499605",
"0.64179486",
"0.6409363",
"0.6396551",
"0.63920933"... | 0.0 | -1 |
Find apropriate files for the subject and download them Search through all files for all acquisitions for all sessions for this subject and download only the T1 nifti files. If file names are repeated a number is prepended. Troublesome characters in the file name are replaced with "_". The file's original name, full pa... | def find_and_download_files(context):
input_path = 'input/'
if os.path.isdir(input_path):
log.debug('Path already exists: ' + input_path)
else:
log.debug('Creating: ' + input_path)
os.mkdir(input_path)
fw = context.client
if 'classification_measurement' in context.config:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_subject(self, subject_ID):\r\n hcp_data_path = os.path.join(self.hcp_directory, str(subject_ID))\r\n\r\n if not os.path.exists(hcp_data_path):\r\n os.makedirs(hcp_data_path)\r\n\r\n print('Downloading data to {}'.format(hcp_data_path))\r\n\r\n counter = 0\r\n ... | [
"0.6075932",
"0.5923535",
"0.58468294",
"0.5837011",
"0.57766956",
"0.5741573",
"0.5726924",
"0.5726823",
"0.56845653",
"0.56502473",
"0.556752",
"0.55647373",
"0.5562809",
"0.55589074",
"0.5542313",
"0.55303603",
"0.5507099",
"0.54877055",
"0.54732233",
"0.5440725",
"0.54362... | 0.64693093 | 0 |
Set destination's 'info' to indicate what's happening | def update_gear_status(key, value):
fw = context.client
dest_container = fw.get(context.destination['id'])
kwargs = {key: value}
dest_container.update_info(kwargs)
log.info(repr(kwargs)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def info(self, info: str):\n\n self._info = info",
"def info(self, info):\n\n self._info = info",
"def log_info(self, obj, message):\n super().log_info(obj=obj, message=message)",
"def set_info(self, msg):\n logger.debug(\"Setting info: %s\", msg)\n self.vars[\"info\"].set(... | [
"0.6143804",
"0.61416364",
"0.61075276",
"0.6027803",
"0.60268867",
"0.6010292",
"0.59295946",
"0.589257",
"0.5882718",
"0.5719608",
"0.5704234",
"0.5674577",
"0.56674504",
"0.56561124",
"0.5644978",
"0.56406033",
"0.56371397",
"0.5615866",
"0.5614427",
"0.5540901",
"0.553031... | 0.0 | -1 |
Set final status to last line of reconallstatus.log. | def set_recon_all_status(subject_dir):
path = context.gear_dict['output_analysisid_dir'] + '/' + \
subject_dir + '/scripts/recon-all-status.log'
if os.path.exists(path):
with open(path, 'r') as fh:
for line in fh:
pass
last_line = line
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def final_status(self, final_status):\n\n self._final_status = final_status",
"def after_epoch(self):\n line = ' '.join([str(k) + ': ' + str(v) for k, v in self.trainer.status.items()])\n with open(os.path.join(self.root_path, 'log.txt'), 'a+') as fout:\n fout.write(line + '\\n')... | [
"0.6525308",
"0.63573575",
"0.61293614",
"0.5867392",
"0.58495337",
"0.5713314",
"0.56992143",
"0.5678644",
"0.5619614",
"0.5558952",
"0.5548329",
"0.55442154",
"0.54692274",
"0.54651254",
"0.5439889",
"0.54174083",
"0.53965306",
"0.5389551",
"0.53609776",
"0.53462833",
"0.53... | 0.71194637 | 0 |
Set destination's 'info' to indicate what's happening | def update_gear_status(key, value):
fw = context.client
dest_container = fw.get(context.destination['id'])
kwargs = {key: value}
dest_container.update_info(kwargs)
log.info(repr(kwargs)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def info(self, info: str):\n\n self._info = info",
"def info(self, info):\n\n self._info = info",
"def log_info(self, obj, message):\n super().log_info(obj=obj, message=message)",
"def info(self, msg, *args, **kwargs):\n pass",
"def set_info(self, msg):\n logger.debug(\"S... | [
"0.61399955",
"0.6138113",
"0.6105326",
"0.60246885",
"0.60241956",
"0.6006875",
"0.5932573",
"0.5896946",
"0.58830565",
"0.57182986",
"0.5707436",
"0.56726485",
"0.56645304",
"0.56543434",
"0.5644393",
"0.5642732",
"0.5640949",
"0.56155336",
"0.5612505",
"0.55384743",
"0.552... | 0.0 | -1 |
Set final status to last line of reconallstatus.log. | def set_recon_all_status(subject_dir):
path = context.gear_dict['output_analysisid_dir'] + '/' + \
subject_dir + '/scripts/recon-all-status.log'
if os.path.exists(path):
with open(path, 'r') as fh:
for line in fh:
pass
last_line = line
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def final_status(self, final_status):\n\n self._final_status = final_status",
"def after_epoch(self):\n line = ' '.join([str(k) + ': ' + str(v) for k, v in self.trainer.status.items()])\n with open(os.path.join(self.root_path, 'log.txt'), 'a+') as fout:\n fout.write(line + '\\n')... | [
"0.65249884",
"0.6357503",
"0.61292785",
"0.58676416",
"0.5849602",
"0.57127684",
"0.56986594",
"0.56790066",
"0.56193364",
"0.55592257",
"0.5547861",
"0.5544232",
"0.54690313",
"0.5465183",
"0.543945",
"0.54176474",
"0.53966546",
"0.5389639",
"0.5360609",
"0.5345862",
"0.533... | 0.71203095 | 1 |
Download scans to run on | def set_up_data(context, log):
try:
if context.gear_dict['run_level'] == 'project':
msg = 'This gear must be run at the subject, '+\
'not project level'
context.gear_dict['errors'].append(msg)
raise Exception(msg)
elif context.gear_dic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n download(self.attempt)",
"def download_files(self):",
"def download():\n raise NotImplementedError",
"def download(self):\n pass",
"def download(self):\n pass",
"def download(all):\n print(\"Downloading\")",
"def download():\n try:\n cli.run(\n ... | [
"0.68915814",
"0.68358505",
"0.65526867",
"0.6551495",
"0.6551495",
"0.64888924",
"0.6438649",
"0.6431932",
"0.6431932",
"0.6384153",
"0.631998",
"0.62750447",
"0.6221688",
"0.6210655",
"0.6185226",
"0.6155247",
"0.61521363",
"0.6148834",
"0.6130831",
"0.6113376",
"0.6106293"... | 0.0 | -1 |
Check if the given value is "close enough" to the desired value Because sometimes MagneticFieldStrength can be provide in mT (3000, 1500) or something like 2.9721T | def field_strength_close_enough(field_strength, desired_value):
if field_strength > 100: # assume it is in mT instead of Teslas
field_strength /= 1000 # and turn it into Teslas
diff = abs(field_strength - desired_value)
if diff < 0.2:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def above_threshold(self, value):\n # We use floating point number here so we have to take care\n return finf(value,self.min) or finf(self.max,value)",
"def check_value(value, sensor):\n if not GraphModel.check_if_int(value):\n return False\n\n return (sensor == 't' and ba.... | [
"0.6649637",
"0.6314969",
"0.6307575",
"0.6263273",
"0.621036",
"0.61276513",
"0.61120135",
"0.60805684",
"0.6008309",
"0.59797776",
"0.59608775",
"0.59385926",
"0.59351903",
"0.5876801",
"0.5854414",
"0.5851238",
"0.58508086",
"0.58508086",
"0.58364314",
"0.58322096",
"0.582... | 0.788576 | 0 |
Run the Freesurfer Longitudinal Pipeline | def execute(context, log):
try:
# Don't run if there were errors or if this is a dry run
ok_to_run = True
dry = False
ret = [] # return codes from all runs
return_code = 1 # assume the worst
if len(context.gear_dict['errors']) > 0:
ok_to_run = False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(mu_v, Sigma_w, Sigma_z, a_mu, l_sensor):\n N = 1000\n # Init tracking\n mu_x = np.zeros(N) # Belief or estimation of hidden state \n F = np.zeros(N) # Free Energy of AI neuron\n mu_y = np.zeros(N) # Belief or prediction of sensory signal \n x = np.zeros(N) # True hidden state\n y = np.... | [
"0.57218367",
"0.5423614",
"0.53331274",
"0.527583",
"0.5265408",
"0.5264002",
"0.5260391",
"0.52263385",
"0.5207814",
"0.52057993",
"0.5197902",
"0.5194441",
"0.5166975",
"0.5135886",
"0.5120619",
"0.51003754",
"0.508593",
"0.50717276",
"0.506908",
"0.50658154",
"0.5045627",... | 0.0 | -1 |
Powers or unpowers the bells. | def power_bells(state):
if not pinlessMode:
if state:
for pin in bellPins:
GPIO.output(pin, GPIO.HIGH)
elif not state:
for pin in bellPins:
GPIO.output(pin, GPIO.LOW)
else:
logging.debug("Bell state: " + str(state)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handlePowers(self):\n self.player.sprite.handlePowers(self.get_remaining_time())",
"def poweroff(self) -> None:\n pass",
"def poweroff(self):\n raise NotImplementedError()",
"def set_powers(self, power_1, power_2):\n pass",
"def power_off(self):\n raise NotImplemented... | [
"0.64014935",
"0.6041298",
"0.5899135",
"0.5873446",
"0.58522767",
"0.5775622",
"0.5713468",
"0.5671503",
"0.5662006",
"0.56604326",
"0.56582326",
"0.5653668",
"0.56442696",
"0.5575584",
"0.5575584",
"0.55735165",
"0.55625665",
"0.5539788",
"0.55348086",
"0.5527003",
"0.55260... | 0.6172118 | 1 |
Rings the school bells in a pattern for the given schedule/time. | def ring_bells():
# Need to get the pattern for this time slot and apply it.
curTime = time.strftime("%H:%M")
if curTime not in jsonConfig["schedules"][curSchedule]:
logging.error("Couldn't find time record for time " + curTime + " in schedule " + curSchedule)
return
# Obtain the patter... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tick(self) -> None:\n\n bell = self._row[self._place]\n user_controlled = self._user_assigned_bell(bell)\n\n self._rhythm.wait_for_bell_time(time.time(), bell, self._row_number, self._place,\n user_controlled, self.stroke)\n\n if not user_contr... | [
"0.5695601",
"0.5432977",
"0.5410973",
"0.5381197",
"0.53569686",
"0.51683617",
"0.5059934",
"0.50112706",
"0.49925143",
"0.49726513",
"0.49589247",
"0.49199778",
"0.49188292",
"0.4897901",
"0.48784587",
"0.48409376",
"0.48267853",
"0.4821929",
"0.4812405",
"0.47980654",
"0.4... | 0.72606444 | 0 |
Reloads the schedule from our json file. | def reload_schedule():
global jsonConfig
global curSchedule
jsonConfig = None
curSchedule = None
# Clear currently scheduled bells.
schedule.clear("current")
logging.debug("Reloading schedule...")
with open(jsonFile) as jsonFileHandle:
jsonConfig = json.load(jsonFileHandle)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reload(self):\n with open(self._config) as f:\n self.data = json.load(f)",
"def reload(self):\n try:\n with open(self.__file_path, 'r') as f:\n for key, value in json.load(f).items():\n self.__objects[key] = eval(key.split('.')[0])(**value... | [
"0.719504",
"0.69318056",
"0.6864976",
"0.67585194",
"0.6752321",
"0.6690034",
"0.66177434",
"0.6605925",
"0.65952766",
"0.6545089",
"0.64971936",
"0.6459408",
"0.6386498",
"0.632974",
"0.62427646",
"0.62313604",
"0.62149954",
"0.61784226",
"0.61701703",
"0.6152167",
"0.61414... | 0.7724108 | 0 |
Calculates average climatology for annual data either Jan to Dec or accummulation period | def precip_stats_to_climatology(fili, start_year=1981, end_year=2015):
nyear = end_year - start_year + 1
ds = xr.open_dataset(fili)
year = ds['time'].dt.year
#dsMsk = ds.isel( time=( (year >= start_year) & (year <= end_year) ) ).count(dim='time')
dsClm = ds.isel( time=( (year >= start_year) &... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_annual_cycle(data):\n ntime, nlat, nlon = data.shape\n # reshape from [nmonth,nlat,nlon] to [nyear,12,nlat,nlon]\n work = MA.reshape(data,(-1,12,nlat,nlon))\n # compute mean annual cycle\n mean_data = MA.average(work,0)\n return mean_data",
"def monthly_avgs(HC):\n monthlies = np.ze... | [
"0.6993821",
"0.6731715",
"0.65855527",
"0.6528531",
"0.65122795",
"0.6510179",
"0.64892894",
"0.64774054",
"0.6472804",
"0.63967705",
"0.63076663",
"0.63015807",
"0.6238311",
"0.6189327",
"0.61609685",
"0.61545795",
"0.61481494",
"0.6128874",
"0.61187685",
"0.61106884",
"0.6... | 0.5866293 | 28 |
Undistort the image using distortion coefficients | def undistort_image(mtx_, dist_, img_):
dst = cv2.undistort(img_, mtx_, dist_, None, mtx_)
return dst | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def undistort(self, image):\n return cv2.undistort(image, self.camera_matrix, self.distortion_coeffs, None, self.camera_matrix)",
"def undistort(self, image):\n dst = cv2.undistort(image, self.mtx, self.dist_coeff, None)\n\n if self.args.is_test:\n self.image_logger.save_image(dst... | [
"0.7884479",
"0.7551686",
"0.7374037",
"0.7349525",
"0.7250263",
"0.72426575",
"0.71945417",
"0.7146802",
"0.7065099",
"0.671219",
"0.66244733",
"0.6621529",
"0.64361244",
"0.6337158",
"0.6207002",
"0.6132985",
"0.6115165",
"0.59107697",
"0.59106004",
"0.5851052",
"0.5788503"... | 0.7565127 | 1 |
Calculate Perspective and Inverse Perspective Transform Matrices | def calc_transform(src_, dst_):
M_ = cv2.getPerspectiveTransform(src_, dst_)
Minv_ = cv2.getPerspectiveTransform(dst_, src_)
return M_, Minv_ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def perspective_transform():\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\n M = cv2.getPerspectiveTransform(src, dst)\n Minv = cv2.getPerspectiveTransform(dst, src)\n\n re... | [
"0.77655315",
"0.6772391",
"0.67308986",
"0.669059",
"0.6618192",
"0.65587133",
"0.64216304",
"0.6264239",
"0.6257005",
"0.62168366",
"0.6215676",
"0.6160854",
"0.6142326",
"0.6108185",
"0.6086129",
"0.6077356",
"0.60574424",
"0.6047167",
"0.6012863",
"0.599367",
"0.5987706",... | 0.7251248 | 1 |
Extract all Non Zero Pixels and return X, Y Coordinates | def extract_pixels(img_):
non_zero_pixels = np.argwhere(0 < img_)
x = non_zero_pixels.T[0].astype(np.float32)
y = non_zero_pixels.T[1].astype(np.float32)
return x, y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __create_xyz_points(raster, no_data=-9999):\n y, x = np.where(raster != no_data)\n z = np.extract(raster != no_data, raster)\n\n return x, y, z",
"def find_pixels(self):\n ref_image=Image.open('sample0000.png')\n imarray=np.array(ref_image)\n ref_image.close()\n ... | [
"0.655391",
"0.64457804",
"0.6414161",
"0.63365555",
"0.6304538",
"0.62975013",
"0.6216841",
"0.62149465",
"0.6204824",
"0.61987865",
"0.6195701",
"0.6187824",
"0.61301506",
"0.60819465",
"0.6074533",
"0.60721606",
"0.60360277",
"0.6013827",
"0.59923506",
"0.597244",
"0.59497... | 0.81292105 | 0 |
Get x intercepts for given y value | def get_intercepts(fit, y):
x = fit[0] * (y * y) + fit[1] * y + fit[2]
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_x_y_for_line(bounds, y_intercept, slope): \n\n x = np.sort(bounds)\n\n y = y_intercept + (slope * x)\n\n return x, y",
"def intercept(x1, y1, x2, y2):\r\n m = slope(x1, y1, x2, y2)\r\n return y1 - m*x1",
"def get_fit_x(self, y):\n if self.line_fit_m.size == 0:\n retu... | [
"0.63922507",
"0.6389413",
"0.6266955",
"0.6237579",
"0.62286144",
"0.609001",
"0.60876924",
"0.6066772",
"0.605182",
"0.605182",
"0.6022421",
"0.59712934",
"0.5959732",
"0.5946199",
"0.5945855",
"0.5922003",
"0.59173673",
"0.5792059",
"0.57911325",
"0.57743794",
"0.57610834"... | 0.7766451 | 0 |
Get Left_x, Right_x, Left_y, Right_y, Image , return Image with Polygon | def draw_polygon(left_x, right_x, left_y, right_y, img_):
pts_left = np.array([np.flipud(np.transpose(np.vstack([left_x, left_y])))])
pts_right = np.array([np.transpose(np.vstack([right_x, right_y]))])
pts = np.hstack((pts_left, pts_right))
img_ = cv2.polylines(img_, np.int_([pts]), isClosed=False, colo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_image(self):\n dir_ship = self.direction\n dir_cannon=self.cannon_dir\n temp_image = self.base_image.copy()\n pygame.draw.polygon(temp_image, (0,0,0), [(2,2),(2,3),(3,3),(3,2)])\n if dir_cannon == dir_ship:\n pygame.draw.polygon(temp_image, (60,60,60), [(4,3),... | [
"0.65409863",
"0.6449552",
"0.62613237",
"0.61531603",
"0.61507094",
"0.6134605",
"0.5918344",
"0.5892853",
"0.58924294",
"0.58919007",
"0.58887494",
"0.58701646",
"0.58659583",
"0.5839686",
"0.58155435",
"0.5813019",
"0.581092",
"0.5798064",
"0.57906735",
"0.5779135",
"0.576... | 0.7396713 | 0 |
Convert parameters from X,Y plane to Image Plane Points | def coordinates_to_imgpts(x, y):
pts = np.array([np.flipud(np.transpose(np.vstack([x, y])))])
return pts | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def project_points_plane(points, plane):\n return [project_point_plane(point, plane) for point in points]",
"def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\n # preliminary stuff\n if origin != None: x = x - origin\n a,b,c,d = plane\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\n a,b... | [
"0.65616685",
"0.64299065",
"0.6374554",
"0.63244987",
"0.6322487",
"0.6310065",
"0.6286317",
"0.6259193",
"0.62357223",
"0.6208368",
"0.6159411",
"0.60882986",
"0.6084627",
"0.60737157",
"0.60300255",
"0.60300255",
"0.6017754",
"0.5987526",
"0.5984642",
"0.59726226",
"0.5969... | 0.59584945 | 21 |
Draw Polylines for points with given thickness specified by Window Size | def draw_polylines(input_img, pts, window_size):
return cv2.polylines(input_img, np.int_([pts]), isClosed=False, color=(255, 255, 255),
thickness=2 * window_size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_lines(self, color, points, width = 1, closed = False):\n color = spyral.color._determine(color)\n pygame.draw.aalines(self._surf, color, closed, points)",
"def drawLines(self):\n\t\tintersections = [[], []]\n\t\tfor l in self.lines:\n\t\t\tif l.direction == 'v':\n\t\t\t\tif l.rtc:\n\t\t\t\... | [
"0.6230124",
"0.61896694",
"0.61215425",
"0.6083533",
"0.5963582",
"0.5954477",
"0.58733976",
"0.58443934",
"0.5826821",
"0.58263594",
"0.58262116",
"0.5811678",
"0.57939386",
"0.573556",
"0.5720824",
"0.5711357",
"0.57111347",
"0.57054645",
"0.56073576",
"0.557913",
"0.55431... | 0.69677657 | 0 |
Use polyfit from the mask points for smoothening them | def smoothen_masks(fit, img_, window_size):
img_size = img_.shape
mask_poly = np.zeros_like(img_)
# Get top to Bottom for refactoring #
mask_y = np.linspace(0, img_size[0] - 1, img_size[0])
mask_x = get_intercepts(fit, mask_y)
# Smoothen the mask #
pts = coordinates_to_imgpts(mask_x, mask_y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sigclip_polyfit(p, xx, yy, degree, weight = None):\n # read constants from p\n sigclip = p['WAVE_SIGCLIP']\n # initialise the while loop\n sigmax = sigclip + 1\n # initialise mask\n mask = np.ones_like(xx, dtype='Bool')\n while sigmax > sigclip:\n # Need to mask weight here if not N... | [
"0.62117845",
"0.62038964",
"0.60165256",
"0.5831612",
"0.5827311",
"0.57904327",
"0.572582",
"0.5706521",
"0.56874967",
"0.56852",
"0.56852",
"0.56852",
"0.56538486",
"0.5650198",
"0.5639281",
"0.5617409",
"0.5605478",
"0.5585841",
"0.557275",
"0.55547965",
"0.5492608",
"0... | 0.7063888 | 0 |
Polynomial search based on previous fit | def limited_search(img_, window_size, flag='L'):
# Initialize Mask with Same Size as Image #
mask_poly = np.zeros_like(img_)
# Get previous Coefficients #
fit = get_last_fit(flag=flag)
if fit is not None:
mask_poly_smooth = smoothen_masks(fit, img_, window_size)
return mask_poly_smoo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_expected_polynomial_coefs(y, degree, with_intercept=True):\n poly_matrix = np.vander(np.arange(len(y)), degree + 1)\n if not with_intercept:\n poly_matrix = poly_matrix[:, :-1]\n return np.linalg.lstsq(poly_matrix, y.to_numpy(), rcond=None)[0]",
"def fit_polynomial(self, ym_per_pix, xm_pe... | [
"0.6252983",
"0.60985476",
"0.60769516",
"0.6001327",
"0.59808683",
"0.5978871",
"0.59773546",
"0.5953325",
"0.59510887",
"0.5937711",
"0.593213",
"0.58654374",
"0.58370185",
"0.58306885",
"0.57615274",
"0.57519823",
"0.57093227",
"0.5706699",
"0.5706699",
"0.5706699",
"0.570... | 0.52596563 | 94 |
Get the mean value of fit "Left" and "Right" based on flag | def get_mean_fit(flag='L'):
if flag == 'L':
return np.mean(np.vstack(l_coeff_queue), axis =0) if len(l_coeff_queue)>1 else l_coeff_queue[-1]
else:
return np.mean(np.vstack(r_coeff_queue), axis =0) if len(r_coeff_queue)>1 else r_coeff_queue[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mask_and_avg(values, padding_mask):\n\tdec_lens = torch.sum(padding_mask,dim=1)\n\tlosses = torch.stack(values, dim=1)\n\tlosses = losses * padding_mask\n\tvalues_per_ex = torch.sum(losses, dim=1)/dec_lens\n\treturn torch.sum(values_per_ex)",
"def mean(self):\n\n\t\tif not self._masked:\n\t\t\t\n\t\t\tretur... | [
"0.60307616",
"0.59903556",
"0.5989535",
"0.5927027",
"0.58250964",
"0.58250463",
"0.58083445",
"0.5792237",
"0.57348174",
"0.57280666",
"0.57189894",
"0.571298",
"0.56587595",
"0.5591607",
"0.5536695",
"0.55357367",
"0.5512962",
"0.55089694",
"0.5496177",
"0.5463986",
"0.545... | 0.7186115 | 0 |
Gets the Last Fit depending on the flag | def get_last_fit(flag='L'):
if flag == 'L':
return l_coeff_queue[-1]
else:
return r_coeff_queue[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFit(self):\n if self.fits.has_key('default'):\n return self.fits['default']\n else:\n return None",
"def last_fmeasure(self):\n return self.get_fvalue(self.last_position())",
"def get_last_saved_estimation(self):\n return None",
"def get_fit(self, spac... | [
"0.6239705",
"0.6228102",
"0.6141779",
"0.6008824",
"0.59334695",
"0.5871821",
"0.5755246",
"0.5743263",
"0.5716989",
"0.57042426",
"0.5698672",
"0.56794965",
"0.56396884",
"0.56118524",
"0.55922616",
"0.55794775",
"0.55546254",
"0.55316406",
"0.55230576",
"0.5493914",
"0.547... | 0.8070429 | 0 |
Verify if number of pixels are satisfactory for a confident fit and then fit | def check_and_fit(x, y, flag='L', threshold=1000):
confidence_index = len(x)
if IsLaneFound is False:
threshold =500
if confidence_index < threshold:
fit = None
foundFlag = False
else:
fit, cov = curve_fit(lambda x, a, b, c:a*x*x+b*x + c , x, y)
foundFlag = T... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_is_fitted(self):\n check_is_fitted(self, ['w', 'b'])",
"def will_data_fit(bit_num, image, bits_per_pix):\r\n max_bits = reduce(lambda x, y: x * y, image.size) * bits_per_pix\r\n return bit_num <= max_bits",
"def _check_is_fitted(self):\n # Do not check `b` as some classifiers do ... | [
"0.72636896",
"0.6932754",
"0.66202956",
"0.66143525",
"0.65346766",
"0.63944054",
"0.6253365",
"0.6242172",
"0.62324864",
"0.62324864",
"0.6188465",
"0.6146149",
"0.6145773",
"0.61280084",
"0.6103189",
"0.6067273",
"0.60213757",
"0.6007816",
"0.5982442",
"0.59745777",
"0.596... | 0.5679916 | 43 |
Mask the Images and then return the equation of the lane lines | def mask_and_fit(mask, binary_warped, flag):
img = cv2.bitwise_and(binary_warped, binary_warped, mask=mask)
x, y = extract_pixels(img)
fit, foundFlag, confidence_index = check_and_fit(x, y, flag)
return fit, foundFlag, confidence_index | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calcmask(self, *args, **kwargs):\n return _image.image_calcmask(self, *args, **kwargs)",
"def set_lanes(left_lines, right_lines, image):\n \n Y_LANE_EXTRAP = 35 # percent up from bottom of image to extrapolate lane lines\n \n image_wk = np.copy(image) # working copy\n image_lines = np.c... | [
"0.6409335",
"0.6389279",
"0.63278013",
"0.6144017",
"0.61208165",
"0.61032546",
"0.6092377",
"0.60494506",
"0.60046375",
"0.60025907",
"0.5973677",
"0.5961888",
"0.5948796",
"0.59485275",
"0.5888697",
"0.5870006",
"0.58533627",
"0.58333975",
"0.58228105",
"0.5813124",
"0.580... | 0.0 | -1 |
Use The current values of Curvature and Offset from Left and Right Lanes to decide if Lanes are sane | def curvature_sanity(left_curvature, left_offset, right_curvature, right_offset):
if return_queue_len(flag='L') >= 1 and return_queue_len(flag='R') >= 1:
offset = center_position - (left_offset + right_offset) / 2.
offset_measure = np.abs(overall_offset - offset)
return True if offset_measur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _curvature(self):\n y_eval = self.left_fitx.shape[0] - 10\n left_curverad = (((1 + (2 * self.left_fit[0] * y_eval + self.left_fit[1]) ** 2) ** 1.5) /\n np.absolute(2 * self.left_fit[0]))\n right_curverad = (((1 + (2 * self.right_fit[0] * y_eval + self.right_fit[1]) ... | [
"0.63404727",
"0.6133634",
"0.6060749",
"0.58401936",
"0.56271565",
"0.5616536",
"0.5516699",
"0.5483635",
"0.54565936",
"0.5450176",
"0.5428849",
"0.54229635",
"0.540363",
"0.54026043",
"0.53971386",
"0.5384905",
"0.53581065",
"0.5353302",
"0.53430974",
"0.5340143",
"0.53293... | 0.70147413 | 0 |
Use the left and right fit | def update_lanewidth(left_fit, right_fit, img_):
img_size = img_.shape
y_eval = np.linspace(0, img_size[0], 20)
left_x = get_intercepts(left_fit, y_eval)
right_x = get_intercepts(right_fit, y_eval)
return np.clip(right_x - left_x, 400, 800) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, left, mode, right, size=None, **kwargs):\n return super().__call__(left, mode, right, size=size, **kwargs)",
"def hflip(self):\n self.leftimg, self.rightimg = self.rightimg, self.leftimg",
"def rightbox(self):\r\n pass",
"def check_extent(self):\n if self.lower_... | [
"0.5895596",
"0.5836528",
"0.5623411",
"0.55394584",
"0.5525405",
"0.5424819",
"0.53840476",
"0.53774345",
"0.53398556",
"0.53164613",
"0.52830184",
"0.5280889",
"0.5272965",
"0.52709484",
"0.52354926",
"0.51937866",
"0.51937866",
"0.51937866",
"0.51937866",
"0.51937866",
"0.... | 0.6062885 | 0 |
Create an ISO 6346 shipping container code. | def create(owner_code, serial, category='U'):
if not (len(owner_code) == 3 and owner_code.isalpha()):
raise ValueError("Invalid ISO 6346 owner code '{}'".format(owner_code))
if category not in ('U', 'J', 'Z', 'R'):
raise ValueError("Invalid ISO 6346 category identifier '{}'".format(category))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def USCode(self, short):\n states = {\n 'AK': 'Alaska',\n 'AL': 'Alabama',\n 'AR': 'Arkansas',\n 'AS': 'American Samoa',\n 'AZ': 'Arizona',\n 'CA': 'California',\n 'CO': 'Colorado',\n 'CT': 'Connecticut',\n 'D... | [
"0.5175448",
"0.5125011",
"0.50932604",
"0.49715528",
"0.49012083",
"0.48026282",
"0.48011735",
"0.47937286",
"0.47771695",
"0.47705403",
"0.47160998",
"0.47139278",
"0.47057864",
"0.47034556",
"0.46948606",
"0.46944666",
"0.4689189",
"0.4687901",
"0.46823987",
"0.46695173",
... | 0.5852458 | 0 |
Compute the check digit for an ISO 6346 code without that digit | def check_digit(raw_code):
s = sum(code(char) * 2**index for index, char in enumerate(raw_code))
return s % 11 % 10 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkdigit(code):\n check = sum((i+1)*int(code[i]) for i in range(9)) % 11\n return 'X' if check == 10 else str(check)",
"def calc_check_digit_issn(issn):\n\n total = 0\n lissn = list(issn.replace('-', ''))\n\n for i, v in enumerate(lissn[:-1]):\n total = total + ((8-i) * int(v))\n\n ... | [
"0.6888133",
"0.6631145",
"0.6620832",
"0.6535597",
"0.6298015",
"0.6270086",
"0.6102347",
"0.6022895",
"0.6003835",
"0.59928644",
"0.5986576",
"0.59091353",
"0.58925956",
"0.5891122",
"0.5886155",
"0.5840528",
"0.58109224",
"0.5803279",
"0.5776782",
"0.5743615",
"0.5738659",... | 0.697806 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.