0)) / 255\n })\n return c_info","def binary_contour_image_filter(*args, **kwargs):\n import itk\n instance = itk.BinaryContourImageFilter.New(*args, **kwargs)\n return instance.__internal_call__()","def get_contours(mask, threshold_area):\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\n\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy","def get_contours(mask, threshold_area):\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\n\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy","def extract_features(img, clf, windows, y_start_stop, xy_window, stride):\n\n transformers = {k: v for k, v in clf.named_steps['features'].transformer_list}\n\n chist_transformer = transformers['chist']\n # remove the first two steps since they are not needed\n chist_transformer = Pipeline(chist_transformer.steps[2:])\n\n sb_transformer = transformers['sb']\n # remove the first two steps since they are not needed\n sb_transformer = Pipeline(sb_transformer.steps[2:])\n\n img_scaled_sb = convert_cspace(img, transformers['sb'].named_steps['sb_csc'].cspace)\n samples_sb = cut_out_windows(img_scaled_sb, windows)\n\n img_scaled_chist = convert_cspace(img, transformers['chist'].named_steps['chist_csc'].cspace)\n samples_chist = cut_out_windows(img_scaled_chist, windows)\n\n img_scaled_hog = convert_cspace(img, transformers['hog'].named_steps['hog_csc'].cspace)\n search_area_hog = img_scaled_hog[y_start_stop[0]:y_start_stop[1], :, :]\n\n hog_vectors = get_hog_vector(search_area_hog, transformers['hog'], xy_window[0], stride)\n sb_vectors = sb_transformer.transform(samples_sb)\n chist_vectors = chist_transformer.transform(samples_chist)\n\n return np.concatenate((hog_vectors, chist_vectors, sb_vectors), axis=1)","def __find_contours(input1, external_only):\n if(external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n contours, hierarchy = cv2.findContours(input1, cv2.RETR_TREE, method=method)\n return contours","def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\n\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\n\n # Since the watershed draws contours, we need to invert the predictions to\n # get the 'inside' blob portion. We also slightly compress the blob portion\n # so we can get a more defining border.\n inverted_contours = 255 - class_contours\n\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\n # remove areas that are not part of the class mask\n inverted_contours[class_mask==0]= 0 # here ?\n\n return inverted_contours","def contour2points(contours):\n return contours.reshape(-1, 2)","def subimage(image_as_array, step):\r\n\tsubimage_2d_array = image_as_array[200-int(step):200+int(step)]\r\n\treturn subimage_2d_array","def split(self):\n sub_images = []\n\n for region in regionprops(self.cells):\n minr, minc, maxr, maxc = region.bbox\n sub_image = self.image_raw[max(0, minr - 10):maxr, max(0, minc - 10):maxc, :]\n\n sub_images.append(FQimage(data=sub_image))\n\n return sub_images","def contours_to_arrays(gdf, col): \n\n coords_zvals = []\n\n for i in range(0, len(gdf)):\n\n val = gdf.iloc[i][col]\n\n try:\n coords = np.concatenate([np.vstack(x.coords.xy).T \n for x in gdf.iloc[i].geometry])\n except:\n coords = np.vstack(gdf.iloc[i].geometry.coords.xy).T\n\n coords_zvals.append(np.column_stack((coords, \n np.full(np.shape(coords)[0], \n fill_value=val))))\n\n return np.concatenate(coords_zvals)","def getContours(frame):\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def get_segmented_point_clouds(seg_masks, depth): \n obj_labels = np.unique(seg_masks)\n num_objs = obj_labels.shape[0]+1\n rows, cols = seg_masks.shape\n cm = plt.get_cmap('gist_rainbow')\n colors = [cm(1. * i/num_objs) for i in range(num_objs)]\n \n object_dict = {}\n # key - object label; val - depth array of that object\n for i in obj_labels:\n object_dict[i] = np.zeros((rows,cols), dtype = np.float32)\n\n for i in range(rows):\n for j in range(cols):\n if seg_masks[i][j] != 0 and seg_masks[i][j] != -1:\n object_dict[seg_masks[i][j]][i][j] = depth[i][j]\n \n segmented_pcds = []\n for key, val in object_dict.items():\n if key == -1 or key == 0:\n continue\n img = o3d.geometry.Image(val)\n pcd_from_depth = o3d.geometry.PointCloud.create_from_depth_image(\n img,\n o3d.camera.PinholeCameraIntrinsic(\n o3d.camera.PinholeCameraIntrinsicParameters.PrimeSenseDefault))\n\n # Multiply with Transformation matrix to get correct view of the PCD\n pcd_from_depth.transform([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]])\n pcd_from_depth.paint_uniform_color(np.array(colors[key][:3], dtype = np.uint8) * 255)\n segmented_pcds.append(pcd_from_depth)\n return segmented_pcds","def bbxes_data(img):\n _, _, stats, centr = cv2.connectedComponentsWithStats(img)\n # (xCentr, yCentr, area, width, height, xStart, xEnd , yStart, yEnd )\n return sorted([(cent[0], cent[1], stat[4], stat[2], stat[3], stat[0], stat[0] + stat[2], stat[1], stat[1] + stat[3])\n for cent, stat in zip(centr[1:], stats[1:])])","def image2features(img_bat, features, lat, lon):\n # create contours\n im2, contours, hierarchy = cv.findContours(img_bat, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)\n\n # create array of points\n polygones = [[] for _ in contours]\n points = []\n list_coord_poly = []\n for i in range(len(contours)):\n for j in range(len(contours[i])):\n var = np.array(contours[i][j]).tolist()\n points.append(var[0])\n polygones[i].append(points[:])\n points = []\n list_coord_poly.append(polygones[i][0])\n\n # project points from geographic coordinates(Google Maps) to WGS_1984_Web_Mercator_Auxiliary_Sphere EPSG:3857\n list_coord_poly = inv_y(list_coord_poly, img_bat)\n list_coord_poly = scale(list_coord_poly)\n list_coord_poly = translation(list_coord_poly, lat, lon)\n\n # list of Polygon objects\n # features = []\n for polygone in list_coord_poly:\n # Create a Polygon object based on the array of points\n # Append to the list of Polygon objects\n features.append(\n arcpy.Polygon(\n arcpy.Array([arcpy.Point(*coords) for coords in polygone])))","def slicewhere(condition):\n regions = ndimage.find_objects(ndimage.label(condition)[0])\n return [region[0] for region in regions]","def getCharacterContour(space, debug=False):\r\n\r\n contours = cv2.findContours(space, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)\r\n contours = imutils.grab_contours(contours)\r\n\r\n # Sort contours by area, descending\r\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\r\n\r\n totalArea = space.shape[0] * space.shape[1]\r\n\r\n for contour in contours:\r\n\r\n area = cv2.contourArea(contour)\r\n hull = cv2.convexHull(contour)\r\n hull_area = cv2.contourArea(hull)\r\n\r\n if debug:\r\n cv2.drawContours(space, contours, 0, (128, 255, 60), 2)\r\n cv2.imshow('space', space)\r\n cv2.waitKey(0)\r\n cv2.destroyAllWindows()\r\n\r\n if cv2.contourArea(cv2.convexHull(contour)) < totalArea * 0.05:\r\n break\r\n\r\n if cv2.contourArea(cv2.convexHull(contour)) < totalArea * 0.95:\r\n return contour\r\n\r\n return None","def substratesFrom(polygons):\n containmentGraph = buildContainmentGraph(polygons)\n polygonLevels = graphLevels(containmentGraph) # Even polygons are outlines, odd are holes\n substrates = []\n for idx, polygon in enumerate(polygons):\n level = polygonLevels[idx]\n if not even(level):\n continue\n holes = [polygons[x].exterior for x in containmentGraph[idx] if polygonLevels[x] == level + 1]\n substrates.append(Polygon(polygon.exterior, holes))\n return substrates","def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\n min_ratio, max_ratio):\n output = []\n for contour in input_contours:\n x,y,w,h = cv2.boundingRect(contour)\n if (w < min_width or w > max_width):\n continue\n if (h < min_height or h > max_height):\n continue\n area = cv2.contourArea(contour)\n if (area < min_area):\n continue\n if (cv2.arcLength(contour, True) < min_perimeter):\n continue\n hull = cv2.convexHull(contour)\n solid = 100 * area / max(cv2.contourArea(hull),1)\n if (solid < solidity[0] or solid > solidity[1]):\n continue\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\n continue\n ratio = (float)(w) / h\n if (ratio < min_ratio or ratio > max_ratio):\n continue\n output.append(contour)\n return output","def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\n return [\n [sc.cVLS() for sc in scList]\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\n ]","def watershed(img):\n\ttmp = img.copy()\n\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\n\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n\tkernel = np.ones((3,3), np.uint8)\n\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\n\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\n\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\n\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\n\tsure_fg = np.uint8(sure_fg)\n\tunknown = cv2.subtract(sure_bg, sure_fg)\n\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\n\tmarkers = markers+1\n\tmarkers[unknown==255] = 0\n\tmarkers = cv2.watershed(tmp, markers)\n\ttmp[markers == -1] = [255,0,0]\n\treturn tmp","def ShowOneContour(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt,figname):\n plt.figure(figsize=(15,6))\n spec_index_min=100 # cut the left border\n spec_index_max=1900 # cut the right border\n star_halfwidth=70\n \n YMIN=-15\n YMAX=15\n \n figfilename=os.path.join(dir_top_img,figname) \n \n #center is approximately the one on the original raw image (may be changed)\n #x0=int(all_pointing[index][0])\n x0=int(thex0[index])\n \n \n # Extract the image \n full_image=np.copy(all_images[index])\n \n # refine center in X,Y\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\n \n profile_X=np.sum(star_region_X,axis=0)\n profile_Y=np.sum(star_region_X,axis=1)\n\n NX=profile_X.shape[0]\n NY=profile_Y.shape[0]\n \n X_=np.arange(NX)\n Y_=np.arange(NY)\n \n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\n \n x0=int(avX+x0-star_halfwidth)\n \n \n # find the center in Y on the spectrum\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\n y0=np.where(yprofile==yprofile.max())[0][0]\n\n # cut the image in vertical and normalise by exposition time\n reduc_image=full_image[y0-20:y0+20,x0:spec_index_max]/all_expo[index] \n reduc_image[:,0:100]=0 # erase central star\n \n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\n \n # calibration in wavelength\n #grating_name=all_filt[index].replace('dia ','')\n grating_name=get_disperser_filtname(all_filt[index])\n \n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\n \n #if grating_name=='Ron200':\n # holo = Hologram('Ron400',verbose=True)\n #else: \n # holo = Hologram(grating_name,verbose=True)\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\n #if grating_name=='Ron200':\n # lambdas=lambdas*2.\n \n\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \n T=np.transpose(reduc_image)\n \n \n plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\n C = plt.contour(X, Y, reduc_image , 20, colors='black', linewidth=.5,origin='lower')\n \n \n for line in LINES:\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\n plt.text(line['lambda'],YMAX-3,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\n \n \n \n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\n plt.title(all_titles[index])\n plt.grid(color='white', ls='solid')\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\n plt.xlabel('$\\lambda$ (nm)')\n plt.ylabel('pixels')\n plt.ylim(YMIN,YMAX)\n plt.xlim(0.,1200.)\n plt.savefig(figfilename)","def extract_faces(self, img, list_face_coord):\n #from the img array extract the facees\n list_faces = []\n #Go through each face coordinates and store the array\n #or clip face region in the list\n for i, coord in enumerate(list_face_coord):\n left, top, right, bottom = coord\n list_faces.append(img[top:bottom, left:right])\n return list_faces","def splitContours(contours):\n split_contours = []\n for contour in contours:\n c = contour.reshape(-1, 2)\n line_segments = splitLine(c)\n for seg in line_segments:\n # Turn it back to its original shape, so we can add it back to contours\n new_contour = seg.reshape(-1,1,2)\n # Dont add empty contours to our new list of contours\n if new_contour.size != 0:\n split_contours.append(new_contour)\n\n return split_contours","def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\n\n kernel = np.ones((5, 5), np.float32)\n\n # Use a distance transform to find the seed points for watershed\n tmp = class_mask\n tmp[tmp>0] = 1 # here\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\n dist = (dist / np.max(dist)) * 255.\n\n # Since there may be multiple peaks, we use dilation to find them\n dilate = cv2.dilate(dist, kernel, iterations=3)\n peaks = np.float32(np.where(dilate == dist, 1, 0))\n peaks = peaks * class_mask * 255\n\n sure_fg = np.where(peaks > 125, 255., 0.)\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\n sure_fg = np.uint8(sure_fg)\n\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\n unknown = sure_bg - sure_fg\n\n # Add one to all labels so that known background is not 0, but 1\n _, markers = cv2.connectedComponents(sure_fg)\n markers = markers + 1\n\n markers[unknown == 255] = 0\n\n markers = cv2.watershed(self.image, markers)\n\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\n watershed_superpixels[markers == -1] = 255\n\n return watershed_superpixels","def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\n min_ratio, max_ratio):\n output = []\n for contour in input_contours:\n x, y, w, h = cv2.boundingRect(contour)\n if (w < min_width or w > max_width):\n continue\n if (h < min_height or h > max_height):\n continue\n area = cv2.contourArea(contour)\n if (area < min_area):\n continue\n if (cv2.arcLength(contour, True) < min_perimeter):\n continue\n hull = cv2.convexHull(contour)\n solid = 100 * area / cv2.contourArea(hull)\n if (solid < solidity[0] or solid > solidity[1]):\n continue\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\n continue\n ratio = (float)(w) / h\n if (ratio < min_ratio or ratio > max_ratio):\n continue\n output.append(contour)\n return output","def active_contour_balloon(img, spline, debug=False, threshold='auto'):\n init = spline.generate_mask(img.shape)\n init[init == l.CONTOUR] = l.INSIDE\n init[init == l.BG] = 0\n init.clip(max=1)\n debug and plot(init, \"init\")\n prep_img = inverse_gaussian_gradient(np.array(img))\n debug and plot(prep_img, \"inverse_gaussian_gradient\")\n morph_GAC = morphological_geodesic_active_contour(\n prep_img, 5, init, smoothing=1,\n balloon=1, threshold=threshold,\n # iter_callback=lambda x: plot(x * 255)\n )\n morph_GAC = np.array(morph_GAC * 255).astype(np.uint8)\n if not morph_GAC.any():\n return None\n morph_GAC[morph_GAC > 0] = 255\n debug and plot(morph_GAC, \"morphGAC\")\n try:\n contours, _ = cv2.findContours(morph_GAC, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n except:\n return None\n contours = sorted(contours, key=lambda x: cv2.contourArea(x), reverse=True)\n contour = np.squeeze(contours[0])\n\n return contour","def bound_shapes(contours):\r\n\r\n contours_poly = [None]*len(contours)\r\n boundRect = [None]*len(contours)\r\n centers = [None]*len(contours)\r\n radius = [None]*len(contours)\r\n for i, c in enumerate(contours):\r\n contours_poly[i] = cv2.approxPolyDP(c, 3, True)\r\n boundRect[i] = cv2.boundingRect(contours_poly[i])\r\n centers[i], radius[i] = cv2.minEnclosingCircle(contours_poly[i])\r\n \r\n return (contours_poly, boundRect, centers, radius)","def get_sun_features(image): # Use grayscale images, outside val: NaN\r\n ratio = sun_isoperimetric_ratio(image)\r\n sun_features = {\"sun_circularity_ratio\": ratio}\r\n return sun_features","def contour_sampling(contour, num,delta = 5):\n \n samples = []\n step = len(contour)/num\n\n lefte = 0\n \n for i in range(num):\n #for i in range(5):\n samples.append(contour[i*step - i*delta])\n samples.append((contour[i*step - i*delta][0],lefte))\n\n #samples.append(contour[len(contour) - 1])\n\n return samples","def cfdGetFaceSfSubArrayForBoundaryPatch(self):\r\n\r\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\r\n \r\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\r\n \r\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\r\n \r\n iBFaces=list(range(int(startBFace),int(endBFace))) \r\n \r\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=[self.faceSf[i] for i in iBFaces] \r\n \r\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=np.asarray(self.cfdBoundaryPatchesArray[iBPatch]['facesSf'])","def GetPointToIncidentFacesArray(self, p_int):\n ...","def get_contours_points(found, contours):\n contours_points = []\n for i in found:\n c = contours[i]\n for sublist in c:\n for p in sublist:\n contours_points.append(p)\n return contours_points","def getNewIntersections(self):\n sections = []\n sections2D = []\n xs = np.array(self.XYProjections)[:,0]\n L = xs[-1] - xs[0]\n xis = xs / L\n R = self.XYZCoordinate.T\n if len(xis) != len(self.SkeletonPoints):\n raise Exception(\"Conflit between xis and SkeletonPoints.\", self.SKeletonPoints)\n for i in range(len(xis)):\n xi = xis[i]\n normalVec = self.returnTangentVectorAtXi(xi)\n originPoint = self.SkeletonPoints[i]\n \n # define transform manually\n T = np.zeros((4,4))\n T[:3,:3] = R[:,np.array([1,2,0])]; # 3rd axis is reduced by projection\n T[:3,3] = originPoint; \n T[3,3] = 1.0\n to_2D = (np.linalg.inv(T)).astype(float)\n \n try:\n slice = self.mesh.section(plane_origin=originPoint, plane_normal=normalVec)\n # 选取每个截面图中面积最大的子图，实现初步去噪\n if slice is not None:\n slice_2D, to_3D = slice.to_planar(to_2D=to_2D,check=False)\n slices_splited = slice_2D.split()\n sliceIndex = np.argmax([s.area for s in slices_splited])\n slice_2D = slices_splited[sliceIndex]\n if True: #slice_2D.area > 1e-1:\n sections2D.append(slice_2D)\n sections.append(slice_2D.to_3D(to_3D))\n except:\n pass\n \n self.Intersections2D = sections2D\n self.Intersections = sections","def find_contours(img_path, **kwargs):\n threshold = kwargs['threshold']\n image = cv2.imread(img_path)\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n blurred = cv2.GaussianBlur(gray, (5, 5), 0)\n thresh = cv2.threshold(blurred, threshold, 255, cv2.THRESH_BINARY)[1]\n contours, _ = cv2.findContours(thresh.copy(),\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n\n\n contour_areas = [] # TODO: is there a faster way to keep the contors with n-largest areas?\n for i, contour in enumerate(contours):\n area = cv2.contourArea(contour)\n contour_areas.append((i, area))\n\n rect = cv2.minAreaRect(contour)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n cv2.drawContours(image,[box],0,(0,0,255),2)\n cv2.imwrite('rect_{}.png'.format(i), image)\n # Contours that cover the largest areas are whole pieces\n largest_contour_areas = nlargest(10, contour_areas, key=lambda x:x[1])\n #print(largest_contour_areas)\n\n for i, area in largest_contour_areas:\n print (i, area)\n cv2.drawContours(image, contours, i, (100, 155, 100), 3)\n cv2.imwrite('contor_{}.png'.format(i), image)\n return True","def get_integral_descriptors(image,filtered_coords,wid=5):\n desc = []\n for coords in filtered_coords:\n patch = image[coords[0]-wid:coords[0]+wid+1,\n coords[1]-wid:coords[1]+wid+1]\n desc.append(patch)\n return desc","def contour_array(self, a, masked_values=None, head=None, **kwargs):\n return self.__cls.contour_array(a=a, masked_values=masked_values,\n head=head, **kwargs)","def contours(subject, colour='gray'):\n for row in data.get_contours(subject)['contours']:\n for col in row:\n xs = []\n ys = []\n for pair in col['arr']:\n xs.append(pair['x'])\n ys.append(pair['y'])\n ys = config['surveys']['atlas']['fits_height'] - numpy.array(ys)\n matplotlib.pyplot.plot(xs, ys, c=colour)","def drawShadedContours(xlist, ylist, zmatrix, levels):\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))","def get_objects(color, depth, threshold1, threshold2):\n\n gray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\n surf = cv2.xfeatures2d.SURF_create(500)\n\n # find and draw the keypoints\n kp = surf.detect(blur,None)\n\n pts = [p.pt for p in kp]\n xpts = []\n ypts = []\n\n # evaluate the keypoints and only save the keypoints who are between the given threshold\n depth_values = []\n for i in range(0,len(pts)):\n xco = int(pts[i][0])\n yco = int(pts[i][1])\n depth_value = depth[yco][xco]\n if depth_value >= float(threshold1) and depth_value <= float(threshold2):\n xpts.append(xco)\n ypts.append(yco)\n depth_values.append(depth_value)\n\n # make histogram of x coordinates of the saved keypoints\n n, distr, _ = plt.hist(xpts)\n plt.savefig('hist.png')\n\n # evaluate the histogram and make seperate arrays for the different objects\n objectarray = []\n temp = []\n for i in range(len(n)):\n if n[i] > 0:\n temp.append(distr[i])\n temp.append(distr[i+1])\n else:\n if len(temp)!=0:\n objectarray.append(temp)\n temp = []\n objectarray.append(temp)\n\n objects = []\n\n # determine the objects with the previous calculated arrays\n for i in range(len(objectarray)):\n y_values = []\n min_x = int(np.amin(objectarray[i]))\n max_x = int(np.amax(objectarray[i]))\n\n for j in range(len(xpts)):\n if xpts[j] > min_x and xpts[j] < max_x:\n y_values.append(ypts[j])\n\n min_y = int(np.amin(y_values))\n max_y = int(np.amax(y_values))\n x = min_x\n y = min_y\n w = max_x - min_x\n h = max_y - min_y\n\n depth_mean = round(get_depth_mean(depth, x, y, w, h), 3)\n\n object = DetectedObject(x, y, w, h, depth_mean)\n objects.append(object)\n\n return objects","def draw_contours(self, edged_image, image_cropped): \n # Find contours. Since we are only intersted in the list of contours we use a dummy variable for the second thing that is also returned (hierarchy)\n (contours, _) = cv2.findContours(edged_image.copy(), # using a copy of the image\n cv2.RETR_EXTERNAL, # contour retrieval mode. RETR_EXTERNAL has to do with how contours are structured hierarchically. It performs a hierarchical structuring, which means that internal structures are filtered out leaving only external contours. Hence, if there are contours inside the object we filter those out, and only focus on the contours that surrounds the object itself. \n cv2.CHAIN_APPROX_SIMPLE) # contours approximation method. This method only saves the most important boundary points of the contours rather than all of them in order to save memory. \n \n # Draw green contours around the letters on the cropped image\n image_letters = cv2.drawContours(image_cropped.copy(), # using a copy of the image\n contours, # list of contours\n -1, # draw all contours\n (0,255,0), # green following the BGR-color model of openCV\n 2) # thickness of contours\n \n # Save cropped image with contours\n cv2.imwrite(os.path.join(self.output_dir, f\"{self.input_image}_letters.jpg\"), image_letters)","def findContours(img, thresh=127, val=255):\n\tgray = grayscale(img)\n\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\n\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\terrorCheckContour(contours)\n\treturn sort(contours)","def extract(integral_channels, feature_stubs):\n\n features = []\n for stub in feature_stubs:\n ch, p_x, p_y, he, wi = stub\n\n ch = integral_channels[ch]\n rect1 = ch.item(p_y, p_x)\n rect2 = ch.item(p_y, p_x+wi)\n rect3 = ch.item(p_y+he, p_x)\n rect4 = ch.item(p_y+he, p_x+wi)\n\n fea = rect4 + rect1 - rect2 - rect3\n features.append(fea)\n\n return features","def find_contours(vertical, horizontal):\n\tmask = vertical + horizontal\n\n\ttry:\n\t\t__, contours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\texcept ValueError:\n\t\t# for opencv backward compatibility\n\t\tcontours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\t# sort in reverse based on contour area and use first 10 contours\n\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\n\n\tcont = []\n\tfor c in contours:\n\t\tc_poly = cv2.approxPolyDP(c, 3, True)\n\t\tx, y, w, h = cv2.boundingRect(c_poly)\n\t\tcont.append((x, y, w, h))\n\treturn cont","def displayContours(self):\n #obsolete?\n profbox()\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\n for modelNode in modelNodes.values():\n if modelNode.GetAttribute(\"contour\") == \"1\":\n needleNode = slicer.mrmlScene.GetNodeByID(modelNode.GetAttribute(\"needleID\"))\n if needleNode != None:\n if needleNode.GetDisplayVisibility()==1:\n modelNode.SetDisplayVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))\n d = modelNode.GetDisplayNode()\n d.SetSliceIntersectionVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))","def get_cntr_points_from_center(self, contour, img_size):\n res_arr = []\n half_img_size = int(np.round(img_size/3))\n diag_coord = np.random.randint(half_img_size,2*half_img_size)\n # find the center point\n center_point = [diag_coord,diag_coord]\n # define all borders point\n border = ([[0,i] for i in np.arange(0,img_size)] + \n [[img_size,i] for i in np.arange(0,img_size)] +\n [[i,0] for i in np.arange(0,img_size)] + \n [[i,img_size] for i in np.arange(0,img_size)])\n for point in border:\n tmp_res = []\n row_diff = point[0] - center_point[0]\n col_diff = point[1] - center_point[1]\n # find the distance between center point and border point\n dist = int(np.round(np.sqrt(row_diff*row_diff+col_diff*col_diff)))\n # find steps for row and column to go from center to border\n row_step = row_diff/dist\n col_step = col_diff/dist\n \n row_diff = center_point[0]\n col_diff = center_point[1]\n c_point = [int(np.round(row_diff)),\n int(np.round(col_diff))]\n\n # go from center to border until points inside image\n while ((c_point[0]>= 0) \n and (c_point[0] < img_size) \n and (c_point[1]>= 0) \n and (c_point[1] < img_size)):\n if cv2.pointPolygonTest(contour,(c_point[0],c_point[1]),True)> 0:\n tmp_res.append(c_point)\n row_diff = row_diff + row_step\n col_diff = col_diff + col_step\n c_point = [int(np.round(row_diff)),\n int(np.round(col_diff))]\n if len(tmp_res):\n res_arr.append(tmp_res)\n return res_arr"],"string":"[\n \"def detect_contours(self):\\r\\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\r\\n return [DbugContour(cv_contour=contour) for contour in contours]\",\n \"def contour_ice(dataarray):\\n contours = dataarray.plot.contourf(vmin=0, vmax=100, levels=5)\\n ice_json = json.loads(contourf_to_geojson(contourf=contours))\\n print(ice_json['type'])\\n # Remove land polygons\\n rm_feats = [f for f in ice_json['features']\\n if f['properties']['title'] == '<0.00 ']\\n for rm in rm_feats:\\n ice_json['features'].remove(rm)\\n print([np.array(f['geometry']['coordinates']).shape\\n for f in ice_json['features']])\\n geodf_ice = gpd.GeoDataFrame.from_features(ice_json)\\n return geodf_ice\",\n \"def select_contours(img):\\n # Find contours at a constant value\\n contours = measure.find_contours(img, 300)\\n # print(\\\"Found \\\" + str(len(contours)) + \\\" contour(s)\\\")\\n # Select the nearest contours with respect to the center pixel of the image\\n width = img.shape[1] # number of columms\\n heigth = img.shape[0] # number of rows\\n pixel_ref = (width / 2, heigth / 2)\\n # Threshold distance is 10% of images smallest dimension\\n dist_thresh = min(width, heigth) * 0.1\\n contours_wanted = []\\n pixel_mean_array = []\\n for contour in contours:\\n contour_3d = np.zeros([contour.shape[0], 3]) # 3rd dimension added for later conversion to patient coord space\\n contour_3d[:, :2] = contour\\n pixel_mean = np.mean(contour, axis=0)\\n if distance.euclidean(pixel_ref, pixel_mean) <= dist_thresh:\\n contours_wanted.append(contour_3d)\\n pixel_mean_array.append(pixel_mean)\\n # print(\\\"Set \\\" + str(len(contours_wanted)) + \\\" contours of interest\\\")\\n return contours_wanted, pixel_mean_array\",\n \"def get_contours(self):\\n depth_image = capture_images((self.w,self.h))\\n\\n thresh = threshold_depth_image(depth_image, min_depth=config.min_depth, max_depth=config.max_depth, threshold=config.min_depth, kernel=self.kernel)\\n\\n # extract contours\\n im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\\n if hierarchy!=None:\\n hierarchy = hierarchy[0]\\n return contours, hierarchy\\n else:\\n return [], []\",\n \"def getContours(img,iteration):\\n nP, IDrange = upDate(iteration)\\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\\n kernel = np.ones((nP, nP), np.uint8)\\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\\n contours = []\\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n if iteration == 2 :\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n elif iteration == 3:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\n return contours\",\n \"def compute_contour(ptr_array):\\n hull = ConvexHull(ptr_array)\\n contour_index = hull.vertices.tolist() # indices are ordered\\n # contour_index = hull.simplices.flatten()\\n # contour_index = list(set(contour_index))\\n return contour_index\",\n \"def get_contours(image):\\n assert len(image.shape) == 2, 'Image should be binary'\\n contour_image = image.copy()\\n contour_image[contour_image == 1] = 255\\n _, contours, _ = cv2.findContours(contour_image.astype('uint8'),\\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n return contours\",\n \"def take_contours(self):\\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]\",\n \"def get_contour_features(mask,selectcell=\\\"centered\\\"):\\r\\n \\r\\n #binarize image (everything above 0 becomes 1)\\r\\n mask = np.clip(mask,a_min=0,a_max=1)\\r\\n\\r\\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\\r\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\r\\n contours = list(contours)\\r\\n \\r\\n #in case there is no contour found, add a dummy contour\\r\\n if len(contours)==0:\\r\\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\\r\\n\\r\\n #Sort contours, longest first\\r\\n contours.sort(key=len,reverse=True)\\r\\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\\r\\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\\r\\n\\r\\n mu_origs = [cv2.moments(contour) for contour in contours]\\r\\n mu_hulls = [cv2.moments(hull) for hull in hulls]\\r\\n\\r\\n area_origs = [mu_orig[\\\"m00\\\"] for mu_orig in mu_origs]\\r\\n area_hulls = [mu_hull[\\\"m00\\\"] for mu_hull in mu_hulls]\\r\\n\\r\\n #drop events where area is zero\\r\\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \\r\\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\\r\\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\\r\\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\\r\\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\\r\\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\\r\\n \\r\\n \\r\\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n\\r\\n \\r\\n if selectcell == \\\"smooth\\\":\\r\\n #compute the area ratio (roughness of contour)\\r\\n area_ratio = np.array(area_hulls)/np.array(area_origs)\\r\\n #get the contour with minimum roughness (smooth contour)\\r\\n sorter = np.argsort(area_ratio) #smallest first\\r\\n\\r\\n if selectcell == \\\"centered\\\":\\r\\n #select contour that is closest to the center of the image. \\r\\n #In iPAC, cells are usually in the center.\\r\\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\\r\\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\\r\\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\\r\\n sorter = np.argsort(distances) #smallest first\\r\\n \\r\\n #sort values with respect to chosen metric (area_ratio or distance)\\r\\n contours = [contours[s] for s in sorter]\\r\\n hulls = [hulls[s] for s in sorter]\\r\\n pos_x = [pos_x[s] for s in sorter]\\r\\n pos_y = [pos_y[s] for s in sorter]\\r\\n mu_origs = [mu_origs[s] for s in sorter]\\r\\n area_origs = [area_origs[s] for s in sorter]\\r\\n area_hulls = [area_hulls[s] for s in sorter]\\r\\n \\r\\n # draw mask of the chosen contour\\r\\n mask = np.zeros_like(mask)\\r\\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\\r\\n\\r\\n hull = hulls[0]#[0:n_contours]\\r\\n pos_x = pos_x[0]\\r\\n pos_y = pos_y[0] \\r\\n mu_orig = mu_origs[0]#[0:n_contours]\\r\\n area_orig = area_origs[0]#[0:n_contours]\\r\\n area_hull = area_hulls[0]#[0:n_contours]\\r\\n \\r\\n if area_orig>0:\\r\\n area_ratio = area_hull/area_orig\\r\\n else:\\r\\n area_ratio = np.nan\\r\\n\\r\\n arc = cv2.arcLength(hull, True) \\r\\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\\\"m00\\\"]) / arc\\r\\n\\r\\n\\r\\n dic = {\\\"mask\\\":mask,\\\"pos_x\\\":pos_x,\\\"pos_y\\\":pos_y,\\\"area_orig\\\":area_orig,\\\"area_hull\\\":area_hull,\\\\\\r\\n \\\"area_ratio\\\":area_ratio,\\\"circularity\\\":circularity}\\r\\n return dic\",\n \"def find_contours(image):\\n # skimage.measure.find_contours is not only slow but impractical:\\n # - interrupts hull polygon when it intersects the margins (!)\\n # - uses 0.5-based coordinates (i.e. center of pixel instead of top/left)\\n contours, _ = cv2.findContours(image.astype(uint8),\\n cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n # convert to y,x tuples\\n return [(contour[:,0,::-1], cv2.contourArea(contour))\\n for contour in contours]\",\n \"def contour_extract(ds_array,\\n z_values,\\n ds_crs,\\n ds_affine,\\n output_shp,\\n min_vertices=2,\\n attribute_data=None,\\n attribute_dtypes=None,\\n dim='time',\\n verbose=True):\\n\\n # Obtain affine object from either rasterio/xarray affine or a \\n # gdal geotransform:\\n if type(ds_affine) != affine.Affine:\\n ds_affine = affine.Affine.from_gdal(*ds_affine)\\n\\n # If z_values is supplied is not a list, convert to list:\\n z_values = z_values if isinstance(z_values, list) else [z_values]\\n\\n # If array has only one layer along the `dim` dimension (e.g. time), \\n # remove the dim:\\n try:\\n ds_array = ds_array.squeeze(dim=dim)\\n print(f\\\"Dimension '{dim}' has length of 1; removing from array\\\")\\n\\n except:\\n pass\\n\\n ########################################\\n # Single array, multiple z-values mode #\\n ########################################\\n\\n # Output dict to hold contours for each offset\\n contours_dict = collections.OrderedDict()\\n\\n # If array has only two dimensions, run in single array, \\n # multiple z-values mode:\\n if len(ds_array.shape) == 2:\\n\\n if verbose: print(f'Operating in single array, multiple z-values mode')\\n\\n # If no custom attributes given, default to including a single \\n # z-value field based on `z_values`\\n if not attribute_data:\\n\\n # Default field uses two decimal points by default\\n attribute_data = {'z_value': z_values}\\n attribute_dtypes = {'z_value': 'float:9.2'}\\n\\n # If custom attributes are provided, test that they are equal \\n # in length to the number of `z-values`:\\n else:\\n\\n for key, values in attribute_data.items():\\n\\n if len(values) != len(z_values):\\n\\n raise Exception(\\n f\\\"Supplied attribute '{key}' has length of {len(values)} while z_values has \\\"\\n f\\\"length of {len(z_values)}; please supply the same number of attribute values \\\"\\n \\\"as z_values\\\")\\n\\n for z_value in z_values:\\n\\n # Extract contours and convert output array cell coords \\n # into arrays of coordinate reference system coords.\\n # We need to add (0.5 x the pixel size) to the x and y \\n # values to correct coordinates to give the centre\\n # point of pixels, rather than the top-left corner\\n if verbose: print(f' Extracting contour {z_value}')\\n ps_x = ds_affine[0] # Compute pixel x size\\n ps_y = ds_affine[4] # Compute pixel y size\\n contours_geo = [\\n np.column_stack(ds_affine * (i[:, 1], i[:, 0])) +\\n np.array([0.5 * ps_x, 0.5 * ps_y])\\n for i in find_contours(ds_array, z_value)\\n ]\\n\\n # For each array of coordinates, drop xy points that have NA\\n contours_nona = [i[~np.isnan(i).any(axis=1)] for i in contours_geo]\\n\\n # Drop 0 length and add list of contour arrays to dict\\n contours_withdata = [i for i in contours_nona \\n if len(i) >= min_vertices]\\n\\n # If there is data for the contour, add to dict:\\n if len(contours_withdata) > 0:\\n contours_dict[z_value] = contours_withdata\\n\\n else:\\n if verbose:\\n print(f' No data for contour {z_value}; skipping')\\n contours_dict[z_value] = None\\n\\n \\n ########################################\\n # Single z-value, multiple arrays mode #\\n ########################################\\n\\n # For inputs with more than two dimensions, run in single z-value, \\n # multiple arrays mode:\\n else:\\n\\n # Test if only a single z-value is given when operating in \\n # single z-value, multiple arrays mode\\n print(f'Operating in single z-value, multiple arrays mode')\\n if len(z_values) > 1:\\n raise Exception('Please provide a single z-value when operating '\\n 'in single z-value, multiple arrays mode')\\n\\n # If no custom attributes given, default to including one field \\n # based on the `dim` dimension:\\n if not attribute_data:\\n\\n # Default field is numbered from 0 to the number of arrays \\n # along the `dim` dimension:\\n attribute_data = {dim: range(0, len(ds_array[dim]))}\\n attribute_dtypes = {dim: 'int'}\\n\\n # If custom attributes are provided, test that they are equal \\n # in length to the number of arrays along `dim`:\\n else:\\n\\n for key, values in attribute_data.items():\\n\\n if len(values) != len(ds_array[dim]):\\n\\n raise Exception(\\n f\\\"Supplied attribute '{key}' has length of {len(values)} while there are \\\"\\n f\\\"{len(ds_array[dim])} arrays along the '{dim}' dimension. Please supply \\\"\\n f\\\"the same number of attribute values as arrays along the '{dim}' dimension\\\"\\n )\\n\\n for z_value, _ in enumerate(ds_array[dim]):\\n\\n # Extract contours and convert output array cell coords into \\n # arrays of coordinate reference system coords. We need to \\n # add (0.5 x the pixel size) to the x and y values to \\n # correct coordinates to give the centre point of pixels, \\n # rather than the top-left corner\\n if verbose: print(f' Extracting contour {z_value}')\\n ps_x = ds_affine[0] # Compute pixel x size\\n ps_y = ds_affine[4] # Compute pixel y size\\n contours_geo = [\\n np.column_stack(ds_affine * (i[:, 1], i[:, 0])) +\\n np.array([0.5 * ps_x, 0.5 * ps_y]) for i in find_contours(\\n ds_array.isel({dim: z_value}), z_values[0])\\n ]\\n\\n # For each array of coordinates, drop any xy points that have NA\\n contours_nona = [i[~np.isnan(i).any(axis=1)] for i in contours_geo]\\n\\n # Drop 0 length and add list of contour arrays to dict\\n contours_withdata = [\\n i for i in contours_nona if len(i) >= min_vertices\\n ]\\n\\n # If there is data for the contour, add to dict:\\n if len(contours_withdata) > 0:\\n contours_dict[z_value] = contours_withdata\\n\\n else:\\n if verbose:\\n print(f' No data for contour {z_value}; skipping')\\n contours_dict[z_value] = None\\n\\n #######################\\n # Export to shapefile #\\n #######################\\n\\n # If a shapefile path is given, generate shapefile\\n if output_shp:\\n\\n if verbose: print(f'Exporting contour shapefile to {output_shp}')\\n\\n # Set up output multiline shapefile properties\\n schema = {'geometry': 'MultiLineString', \\n 'properties': attribute_dtypes}\\n\\n # Create output shapefile for writing\\n with fiona.open(output_shp,\\n 'w',\\n crs={\\n 'init': str(ds_crs),\\n 'no_defs': True\\n },\\n driver='ESRI Shapefile',\\n schema=schema) as output:\\n\\n # Write each shapefile to the dataset one by one\\n for i, (z_value, contours) in enumerate(contours_dict.items()):\\n\\n if contours:\\n\\n # Create multi-string object from all contour coordinates\\n contour_multilinestring = MultiLineString(contours)\\n\\n # Get attribute values for writing\\n attribute_vals = {field_name: field_vals[i] \\n for field_name, field_vals \\n in attribute_data.items()}\\n\\n # Write output shapefile to file with z-value field\\n output.write({\\n 'properties': attribute_vals,\\n 'geometry': mapping(contour_multilinestring)\\n })\\n\\n # Return dict of contour arrays\\n output_gdf = gpd.read_file(output_shp)\\n return output_gdf\",\n \"def preprocessing(self, img):\\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def get_contours(img):\\n contours, hierarchy = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours, hierarchy[0]\",\n \"def contours(self, image,debug=False):\\n imgray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\\n if debug: cv2.imwrite('debug_pics/gray_scale_contour.jpg',imgray) # cv2.imshow('gray_scale_contour',imgray)\\n im2, contours, hierarchy = cv2.findContours(imgray,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\\n\\n return contours,hierarchy\",\n \"def getContours( self,img ):\\n if( len(img.shape) == 3):\\n (_, contours, _) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n (contours,_) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def find_contour(ctx: Context):\\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\\n contours, _ = cv2.findContours(ctx.temp_image1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n\\n # take the 5 biggest areas\\n contours = sorted(contours, key=lambda c: math.fabs(cv2.contourArea(c)), reverse=True)[:5]\\n\\n # approximate contours with poly line\\n ctx.contours = [cv2.approxPolyDP(c, 2, True) for c in contours]\",\n \"def get_cntr_points(self, contour, img_size):\\n res_arr = []\\n # for each row\\n for row in range(img_size):\\n tmp_arr = []\\n # for each column\\n for col in range(img_size):\\n # if point in contour\\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\\n # add point to current line\\n tmp_arr.append([row,col])\\n if len(tmp_arr):\\n # add current line to result array\\n res_arr.append(tmp_arr)\\n return res_arr\",\n \"def extractFeatures(bwimage):\\n \\n \\n # circularity\\n img = bwimage.copy()\\n img1, contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n \\n if len(contours)==0:\\n return []\\n B = contours[0]\\n C = B[:,0,0]\\n l = C.size\\n \\n \\n if abs(B[0,0,0] - B[l-1,0,0]) + abs(B[0,0,1] - B[l-1,0,1]) == 2:\\n P8 = math.sqrt(2)\\n else:\\n P8 = 1 \\n for j in range(0,l-1): \\n if abs((B[j+1,0,0] - B[j,0,0])) + abs(B[j+1,0,1] - B[j,0,1]) == 2:\\n P8 = P8 + math.sqrt(2)\\n else:\\n P8 = P8 + 1\\n \\n n = np.count_nonzero(bwimage)\\n \\n circularity = P8*P8/n\\n \\n \\n # elongation\\n idx = np.nonzero(bwimage);\\n c = idx[1]\\n r = idx[0]\\n meanx = np.mean(c)\\n meany = np.mean(r)\\n \\n \\n pows = 2*np.ones(n)\\n \\n sigxx = np.sum(np.power((c-meanx),pows))/n\\n sigyy = np.sum(np.power((r-meany),pows))/n\\n sigxy = np.sum(np.multiply((r-meany),(c-meanx)))/n\\n \\n covMat = np.array([[sigxx, sigxy], [sigxy, sigyy]])\\n val, vects = np.linalg.eig(covMat);\\n \\n maxEigenValue = np.amax(val) \\n minEigenValue = np.amin(val.ravel()[np.flatnonzero(val)])\\n \\n \\n elongation = math.sqrt(maxEigenValue/minEigenValue);\\n \\n \\n # principal axis\\n maxidx = np.argmax(val)\\n principalAxisVector = vects[maxidx]\\n \\n \\n return [circularity, elongation, principalAxisVector]\",\n \"def get_contours(image, to_hsv=None, thresh=None, smooth=None, edge=None):\\n if to_hsv is True:\\n image=cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n \\n if thresh is not None:\\n if np.shape(thresh)!=(2, 3):\\n raise TypeError('thresh must be a 2x3 array.')\\n else:\\n mask=cv2.inRange(image, thresh[0, :].astype(int), thresh[1, :].astype(int))\\n\\n if smooth is not None:\\n if 'mask' in locals():\\n mask=cv2.bilateralFilter(np.uint8(mask), smooth[0], smooth[1], smooth[2])\\n else:\\n mask=cv2.bilateralFilter(np.uint8(image), smooth[0], smooth[1], smooth[2])\\n \\n if edge is not None:\\n if 'mask' in locals():\\n mask=cv2.Canny(mask, edge[0], edge[1])\\n else:\\n mask=cv2.Canny(image, edge[0], edge[1])\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) \\n return cnts[0] if imutils.is_cv2() else cnts[1]\",\n \"def findContours(image):\\n thresh = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\\n cv2.THRESH_BINARY, 11, 2)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def get_contour(image, threshold=3):\\n\\tmax_val = image.max()\\n\\tstd_val = image.std()\\n\\t_, image_thresh = cv2.threshold(image, threshold*std_val, max_val, \\n\\t cv2.THRESH_TOZERO)\\t\\n\\t_, contours, _ = cv2.findContours(image_thresh, 1, 2)\\n\\treturn contours[0]\",\n \"def getContours(image, copyImage):\\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n for contour in contours:\\n area = cv.contourArea(contour)\\n \\n if area > 500.0:\\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\\n perimeter = cv.arcLength(contour, True)\\n \\n # Approximates to the nearest polygon\\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\\n objectCoordinates = len(approx)\\n\\n # Returns the x, y and height width of the polygon\\n x, y, w, h = cv.boundingRect(approx)\\n\\n if objectCoordinates == 3:\\n objectShape = \\\"Triangle\\\"\\n elif objectCoordinates == 4:\\n ratio = w / float(h)\\n if ratio >= 0.95 and ratio <= 1.05:\\n objectShape = \\\"Square\\\"\\n else: objectShape = \\\"Rectangle\\\"\\n else: objectShape = \\\"Circle\\\" \\n\\n \\n\\n # Draw rectangles around the images\\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))\",\n \"def fun_contours(self, params):\\n shape_coeffs = params[:self.num_shape_params]\\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\\n\\n vertices3d = self.vertices3d\\n vertices3d_from_mesh = np.zeros_like(vertices3d)\\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\\n\\n inner_idx = 0\\n for idx in range(vertices3d.shape[0]):\\n lm_idx = idx % 66\\n obs_num = int(np.floor(idx/66))\\n\\n if lm_idx in self.contour_lms_list[0]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_right[obs_num])\\n elif lm_idx in self.contour_lms_list[1]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_left[obs_num])\\n else:\\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\\n inner_idx += 1\\n if inner_idx == 50:\\n inner_idx = 0\\n\\n return (vertices3d_from_mesh - vertices3d).ravel()\",\n \"def get_instance_contours(img, contoured, instance):\\n mask = np.zeros(img.shape, dtype=np.uint16)\\n mask[img == instance] = 1\\n ret, threshed = cv.threshold(mask, 0, 2 ** 16, cv.THRESH_BINARY)\\n compressed = threshed.astype(np.uint8)\\n contours, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n cv.drawContours(contoured, contours, -1, (randint(25, 255), randint(25, 255), randint(25, 255)), 3)\\n img2 = contours = hierarchy = mask = None\",\n \"def getContourRep(self):\\n\\t\\tvertex1 = [[self.startX, self.startY]]\\n\\t\\tvertex2 = [[self.startX, self.endY]]\\n\\t\\tvertex3 = [[self.endX, self.startY]]\\n\\t\\tvertex4 = [[self.endX, self.endY]]\\n\\t\\tvertices = [vertex1, vertex2, vertex3, vertex4]\\n\\t\\treturn convexHull(np.asarray(vertices, dtype = np.int32))\",\n \"def extract_features(image):\\n\\n return maximum_curvature(*preprocess(image), sigma = 3)\",\n \"def find_contours(thresh):\\n thresh = thresh.astype(np.uint8)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n\\n # filter outer contours\\n filtered_cont = []\\n for i in range(len(contours)):\\n if hierarchy[0, i, 3] == NO_PARENT:\\n filtered_cont.append(contours[i])\\n\\n return filtered_cont\",\n \"def getContours(img):\\n # mode: gets only exrteme outer contours\\n # method: stores all contour points\\n contours, hierarchy = cv2.findContours(img, mode=cv2.RETR_EXTERNAL,\\n method=cv2.CHAIN_APPROX_NONE)\\n \\n x, y, w, h = 0, 0, 0, 0\\n\\n # improving accuracy of contours\\n for cnt in contours:\\n area = cv2.contourArea(cnt)\\n if area > 500:\\n # assumes cnt with area > 500 is closed contour \\n perimeter = cv2.arcLength(cnt, True)\\n\\n # approximate polygonal curve of cnt\\n # set max difference between original and approxCurve as \\n # 0.02 * perimeter\\n approxCurve = cv2.approxPolyDP(cnt, 0.02 * perimeter, closed=True)\\n \\n x, y, w, h = cv2.boundingRect(approxCurve)\\n # wand point is is center-left tip\\n return x + (w // 2), y\",\n \"def points2contour(points):\\n return points.reshape(-1, 1, 2)\",\n \"def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\\n\\n device += 1\\n\\n if len(np.shape(img)) == 3:\\n iy, ix, iz = np.shape(img)\\n else:\\n iy, ix, = np.shape(img)\\n\\n # get the break groups\\n\\n if nrow == 1:\\n rbreaks = [0, iy]\\n else:\\n rstep = np.rint(iy / nrow)\\n rstep1 = np.int(rstep)\\n rbreaks = range(0, iy, rstep1)\\n if ncol == 1:\\n cbreaks = [0, ix]\\n else:\\n cstep = np.rint(ix / ncol)\\n cstep1 = np.int(cstep)\\n cbreaks = range(0, ix, cstep1)\\n\\n # categorize what bin the center of mass of each contour\\n\\n def digitize(a, step):\\n if isinstance(step, int) == True:\\n i = step\\n else:\\n i = len(step)\\n for x in range(0, i):\\n if x == 0:\\n if a >= 0 and a < step[x + 1]:\\n return x + 1\\n elif a >= step[x - 1] and a < step[x]:\\n return x\\n elif a > step[x - 1] and a > np.max(step):\\n return i\\n\\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\\n coord = []\\n for i in range(0, len(roi_objects)):\\n m = cv2.moments(roi_objects[i])\\n if m['m00'] == 0:\\n pass\\n else:\\n cx = int(m['m10'] / m['m00'])\\n cy = int(m['m01'] / m['m00'])\\n # colbin = np.digitize(cx, cbreaks)\\n # rowbin = np.digitize(cy, rbreaks)\\n colbin = digitize(cx, cbreaks)\\n rowbin = digitize(cy, rbreaks)\\n a = (cx, cy, colbin, rowbin, i)\\n coord.append(a)\\n coord1 = np.array(coord, dtype=dtype)\\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\\n\\n # get the list of unique coordinates and group the contours with the same bin coordinates\\n\\n groups = []\\n for i, y in enumerate(coord2):\\n col = y[3]\\n row = y[2]\\n location = str(row) + ',' + str(col)\\n groups.append(location)\\n\\n unigroup = np.unique(groups)\\n coordgroups = []\\n\\n for i, y in enumerate(unigroup):\\n col = int(y[0])\\n row = int(y[2])\\n for a, b in enumerate(coord2):\\n if b[2] == col and b[3] == row:\\n grp = i\\n contour = b[4]\\n coordgroups.append((grp, contour))\\n else:\\n pass\\n\\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\\n\\n contours = roi_objects\\n grouped_contour_indexes = coordlist\\n\\n # Debug image is rainbow printed contours\\n\\n if debug == 'print':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n print_image(img_copy, (str(device) + '_clusters.png'))\\n\\n elif debug == 'plot':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n plot_image(img_copy)\\n\\n return device, grouped_contour_indexes, contours\",\n \"def find_objects(img, threshold=.3):\\n thresholded_img = np.uint8(img > threshold)\\n _, markers = cv2.connectedComponents(thresholded_img)\\n object_centers = []\\n for ii in range(1, np.max(markers)):\\n masked_img = mask_img(img, markers == ii)\\n object_index = np.argmax(masked_img)\\n object_center = np.unravel_index(object_index, img.shape)\\n object_centers.append(object_center)\\n return np.array(object_centers)\",\n \"def get_descriptors(image,filtered_coords,wid=5):\\n desc = []\\n for coords in filtered_coords:\\n patch = image[coords[0]-wid:coords[0]+wid+1,\\n coords[1]-wid:coords[1]+wid+1].flatten()\\n desc.append(patch)\\n return desc\",\n \"def generate_contours(threshold):\\n \\tcnts = cv2.findContours(threshold.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n \\tcnts = imutils.grab_contours(cnts)\\n \\treturn cnts\",\n \"def draw_contours(self, image_path):\\n img = cv.imread(image_path, cv.IMREAD_ANYDEPTH)\\n contoured = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\\n unique, counts = np.unique(img, return_counts=True)\\n for uni in unique:\\n if uni == 0:\\n continue\\n self.get_instance_contours(img, contoured, uni)\\n\\n cv.namedWindow('building contours', cv.WINDOW_NORMAL)\\n cv.imshow('building contours', contoured)\\n cv.waitKey(0)\\n cv.destroyAllWindows()\",\n \"def __find_contours(input, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n im2, contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def __find_contours(input, external_only):\\r\\n if(external_only):\\r\\n mode = cv2.RETR_EXTERNAL\\r\\n else:\\r\\n mode = cv2.RETR_LIST\\r\\n method = cv2.CHAIN_APPROX_SIMPLE\\r\\n _, contours, hierarchy = cv2.findContours(\\r\\n input, mode=mode, method=method)\\r\\n return contours\",\n \"def gesture_single(img, contours, largestContour):\\n cnt = contours[largestContour]\\n hull = cv2.convexHull(cnt, returnPoints=False)\\n defects = cv2.convexityDefects(cnt, hull)\\n junctions = []\\n\\n # For each defect, find the angles associated.\\n for row in xrange(defects.shape[0]):\\n # Handle the returns.\\n start, end, far, dist = defects[row,0]\\n start = tuple(cnt[start][0])\\n end = tuple(cnt[end][0])\\n far = tuple(cnt[far][0])\\n print start, end, far\\n theta = getAngle(start, end, far)\\n # TODO: Impose some restrictions on theta and distance for detection.\\n cv2.line(img,start,end,[0,255,0],2)\\n cv2.circle(img,far,5,[0,0,255],-1)\\n cv2.imshow(\\\"Concert\\\", img)\\n cv2.waitKey(25)\\n print dist\\n # Primary filter: Test if distance > 20k.\\n if dist < 18000:\\n continue\\n else:\\n print theta\\n print \\\"Junction detected!\\\"\\n #pdb.set_trace()\\n # Append the angle to the row for further fun\\n junc = list(defects[row, 0])\\n junc.append(theta)\\n junctions.append(junc)\\n\\n if len(junctions) == 0:\\n return None\\n junctions = np.array(junctions)\\n return junctions\",\n \"def instance_contours(gti):\\n # TODO: move to somewhere better\\n import cv2\\n\\n rc_locs = np.where(gti > 0)\\n grouped_cc_rcs = util.group_items(\\n np.ascontiguousarray(np.vstack(rc_locs).T),\\n gti[rc_locs], axis=0\\n )\\n\\n def bounding_box(rcs):\\n rc1 = rcs.min(axis=0)\\n rc2 = rcs.max(axis=0)\\n return rc1, rc2\\n\\n # slice out a bounding region around each instance, detect the contour and\\n # then offset it back into image coordinates\\n grouped_contours = {}\\n for label, rcs in grouped_cc_rcs.items():\\n rc1, rc2 = bounding_box(rcs)\\n sl = (slice(rc1[0], rc2[0] + 2), slice(rc1[1], rc2[1] + 2))\\n submask = (gti[sl] == label).astype(np.uint8)\\n\\n xy_offset = rc1[::-1]\\n offset = xy_offset + [-2, -2]\\n\\n border = cv2.copyMakeBorder(submask, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=0 )\\n _, contors, hierarchy = cv2.findContours(border, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE,\\n offset=tuple(offset))\\n \\\"\\\"\\\"\\n offset = [0, 0]\\n BGR_GREEN = (0, 255, 0)\\n x = np.ascontiguousarray(util.ensure_alpha_channel(submask)[:, :, 0:3]).astype(np.uint8)\\n draw_img = cv2.drawContours(\\n image=x, contours=contors,\\n contourIdx=-1, color=BGR_GREEN, thickness=2)\\n \\\"\\\"\\\"\\n # note when len(contours > 1, there is a hole in the building)\\n # assert len(contors) == 1\\n grouped_contours[label] = contors\\n return grouped_contours\",\n \"def get_building_contour(current_building_mask):\\n ret, threshed = cv.threshold(current_building_mask, 0, 2 ** 16, cv.THRESH_BINARY)\\n compressed = threshed.astype(np.uint8)\\n current_building_contour, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n return current_building_contour, hierarchy\",\n \"def extract_features(img, sigmas, n_features): \\n dims = img.shape # dimensions of the image\\n \\n features = np.zeros((dims[0], dims[1], n_features)) # each feature map has the same size as the input image\\n \\n # the first feature we use is the pixel intensity in the green channel itself\\n img_g = img[:,:,1] #I just assume it follows the RGB convention and not GBR or BGR...\\n features[:,:,0] = img_g\\n features[:,:,1] = np.sum(img,axis=2) \\n \\n gabors = get_gabors() \\n \\n # >>> YOUR CODE STARTS HERE <<<\\n i = 2\\n# for s in sigmas:\\n# gfilters = gauss_filter(s)\\n# for gf in gfilters:\\n# features[:,:,i] = scipy.signal.fftconvolve(img_g, gf, mode='same') ;i+=1\\n for s in sigmas:\\n gauss = gauss_filter(s)\\n for g in gauss:\\n features[:,:,i] = scipy.signal.fftconvolve(img_g, g, mode='same') ;i+=1\\n \\n for gabor in gabors:\\n features[:,:,i] = scipy.signal.fftconvolve(img_g, gabor, mode='same') ;i+=1\\n \\n \\n features[:,:,i] = sobel(img_g, axis=0) ;i+=1\\n features[:,:,i] = sobel(img_g, axis=1) ;i+=1\\n features[:,:,i] = sobel(img_g, axis=0)+sobel(img_g, axis=1) ;i+=1\\n features[:,:,i] = feature.canny(img_g, sigma=0.0) ;i+=1\\n features[:,:,i] = feature.canny(img_g, sigma=0, low_threshold=13, high_threshold=50);i+=1\\n features[:,:,i] = feature.canny(img_g, sigma=1)\\n # >>> YOUR CODE ENDS HERE <<< \\n \\n return features\",\n \"def __find_contours(input, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def get_contours(self,pixel=True):\\n if not self.has_wcs():\\n raise NotImplementedError(\\\"Only WCS contours implemented and this has no wcs solution\\\")\\n \\n if pixel:\\n return self.wcs.contours_pxl\\n return self.wcs.contours\",\n \"def curvature_features(binary_image, step=2, min_prominance=0.1,min_width=5,dist_bwt_peaks=10):\\n r_c=local_radius_curvature(binary_image,step,False)\\n \\n #calculate local curvature features\\n local_curvature=[np.divide(1,r_c[x]) if r_c[x]!=0 else 0 for x in range(len(r_c))]\\n \\n #compute local and global features\\n global_features = [global_curvature_features(np.array(local_curvature))]\\n global_features = pd.DataFrame([o.__dict__ for o in global_features])\\n \\n prominant_features = [prominant_curvature_features(local_curvature,min_prominance=0.1,min_width=5,dist_bwt_peaks=10)]\\n prominant_features = pd.DataFrame([o.__dict__ for o in prominant_features])\\n\\n all_features = pd.concat([global_features.reset_index(drop=True), prominant_features], axis=1)\\n \\n return all_features\",\n \"def getContourListByDic(groupDic):\\n\\tcontourList = []\\n\\n\\tfor glyph in groupDic.keys():\\n\\t\\tfor idx in groupDic[glyph]:\\n\\t\\t\\tcontourList.append(glyph.contours[idx])\\n\\n\\treturn contourList\",\n \"def register_cells(contours: List[np.array]) -> np.array:\\n def create_cell(contour: np.array) -> np.array:\\n center, radius = cv2.minEnclosingCircle(contour)\\n v = (0, 0)\\n weight = -1\\n\\n return np.array([center[0], center[1], v[0], v[1], radius, weight])\\n\\n areas = np.array([cv2.contourArea(contour) for contour in contours]).astype(\\\"float32\\\")\\n blobs = np.array([create_cell(contour) for contour in contours]).astype(\\\"int32\\\")\\n\\n return blobs[areas >= 100].astype(\\\"float32\\\")\",\n \"def __find_contours(input, external_only):\\n if (external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy = cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def getTasseledCap(img):\\n\\t\\t\\t\\n\\t\\t\\tcoefficients = ee.Array([\\n\\t\\t\\t\\t[0.3037, 0.2793, 0.4743, 0.5585, 0.5082, 0.1863],\\n\\t\\t\\t\\t[-0.2848, -0.2435, -0.5436, 0.7243, 0.0840, -0.1800],\\n\\t\\t\\t\\t[0.1509, 0.1973, 0.3279, 0.3406, -0.7112, -0.4572],\\n\\t\\t\\t\\t[-0.8242, 0.0849, 0.4392, -0.0580, 0.2012, -0.2768],\\n\\t\\t\\t\\t[-0.3280, 0.0549, 0.1075, 0.1855, -0.4357, 0.8085],\\n\\t\\t\\t\\t[0.1084, -0.9022, 0.4120, 0.0573, -0.0251, 0.0238]\\n\\t\\t\\t]);\\n\\t\\t\\n\\t\\t\\tbands=ee.List(['blue','green','red','nir','swir1','swir2'])\\n\\t\\t\\t\\n\\t\\t\\t# Make an Array Image, with a 1-D Array per pixel.\\n\\t\\t\\tarrayImage1D = img.select(bands).toArray()\\n\\t\\t\\n\\t\\t\\t# Make an Array Image with a 2-D Array per pixel, 6x1.\\n\\t\\t\\tarrayImage2D = arrayImage1D.toArray(1)\\n\\t\\t\\n\\t\\t\\tcomponentsImage = ee.Image(coefficients).matrixMultiply(arrayImage2D).arrayProject([0]).arrayFlatten([['brightness', 'greenness', 'wetness', 'fourth', 'fifth', 'sixth']]).float();\\n\\t \\n\\t\\t\\t# Get a multi-band image with TC-named bands.\\n\\t\\t\\treturn img.addBands(componentsImage);\",\n \"def mark_contours(contour_arr, img, symmetry, _plot=False):\\n marg, flag = 7, 0\\n # fig, ax = plt.subplots()\\n # ax.imshow(img, cmap=\\\"gray\\\")\\n sub_images = [] # init array for pictures\\n for contour in contour_arr:\\n\\n lower_dim = contour[:, 0]\\n x, y = lower_dim[:, 0], lower_dim[:, 1]\\n min_x, min_y, max_x, max_y = min(x), min(y), max(x), max(y)\\n\\n # remove small noise\\n if (max_x - min_x) * (max_y - min_y) < MIN_IMG_SIZE:\\n continue\\n # avoid index error\\n if min_x - marg < 0 or min_y - marg < 0 or max_y + marg > img.shape[0] or max_x + marg > img.shape[1]:\\n marg = 0\\n # crop only half cause image is symmetric:\\n # TODO: address different types of symmetry as input from user\\n if symmetry == HORIZONTAL:\\n if max_x <= img.shape[1] // 2:\\n sub_images.append(img[min_y:max_y, min_x:max_x])\\n flag = 1\\n else: # symmetry is around the X-axis\\n if max_y <= img.shape[0] // 2:\\n sub_images.append(img[min_y:max_y, min_x:max_x])\\n flag = 1\\n if _plot and flag:\\n ax.plot([min_x - marg, max_x + marg, max_x + marg, min_x - marg, min_x - marg],\\n [min_y - marg, min_y - marg, max_y + marg, max_y + marg, min_y - marg], c='r', linewidth=0.4)\\n flag = 0\\n if _plot:\\n plt.savefig(\\\"found_subshapes2.jpg\\\")\\n # plt.show()\\n return sub_images\",\n \"def get_image_corners (wcs):\\n return list(wcs.calc_footprint())\",\n \"def draw_contours(image, contours):\\n assert isinstance(image, np.ndarray), 'Image should be a numpy array'\\n x, y, w, h = 0, 0, 0, 0\\n for contour in contours:\\n area = get_contour_area(contour)\\n if area > 10000:\\n x, y, w, h = draw_rect_around_contour(image, contour)\\n return x, y, w+x, h+y\",\n \"def contextualcull(cnts):\\n temp = []\\n actualout = []\\n indicesused = []\\n for cnt in cnts:\\n if cnt.area > CULL_MINIMUMS[cnt.spatialindex]:\\n temp.append(cnt)\\n if cnt.spatialindex not in indicesused:\\n indicesused.append(cnt.spatialindex)\\n if PRIORITIZE_FASTEST:\\n for sindex in indicesused: #filter down to the fastest contour.\\n _allatthisindex = [x for x in temp if x == sindex]\\n highest = _allatthisindex.sort(key=lambda y: y.spd, reverse=False)[0]\\n actualout.append(highest)\\n else:\\n actualout = temp\\n print 'Contours after cull: ', len(actualout)\\n return actualout\",\n \"def contour(self) -> np.ndarray:\\n return self.labels\",\n \"def getMostContour(img,svm,knn,filterArr,digits,wThresh,hThresh):\\r\\n # append the filter to filter array, this approach is used in case of \\r\\n # multiple filter methods would be used.\\r\\n counts = []\\r\\n # iterare through every filter\\r\\n for flt in filterArr:\\r\\n # copy the image so we don't draw on same image\\r\\n flt_img = img.copy()\\r\\n last_img = img.copy()\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh) \\r\\n if not digits:\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh)\\r\\n flt_contour_map = []\\r\\n labels = []\\r\\n for crop,(x,y,w,h),contour in cropNwriteBBs(img,cntfound_fltr):\\r\\n #crop = np.array(crop,dtype='float32')\\r\\n crop = cv2.cvtColor(crop,cv2.COLOR_BGR2GRAY)\\r\\n crop = cv2.resize(crop,(25,25))\\r\\n # winSize is the size of the image cropped to an multiple of the cell size\\r\\n hog_fts = hog.compute(crop)\\\\\\r\\n .reshape(n_cells[1] - block_size[1] + 1,\\r\\n n_cells[0] - block_size[0] + 1,\\r\\n block_size[0], block_size[1], nbins) \\\\\\r\\n .transpose((1, 0, 2, 3, 4))\\r\\n hog_fts = np.resize(hog_fts.flatten(),(1,576))\\r\\n # make the resulted crop same type with the trained values\\r\\n hog_fts.dtype = 'float32'\\r\\n # get predicted labels\\r\\n label_svm=svm.predict(hog_fts)[1]\\r\\n label_knn = knn.findNearest(hog_fts,k=5)[1]\\r\\n # label 10 is considered as 'not digit' or 'thrash'\\r\\n # so if predicted label is not 10, draw the bounding box\\r\\n if digits:\\r\\n if(label_svm!=10 and label_knn != 10 and label_svm!=11 and label_knn != 11):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n else:\\r\\n if(label_svm!=2 and label_knn != 2):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n last_cnt,last_labels = secondElimination(flt_contour_map,labels)\\r\\n for cnt in last_cnt:\\r\\n x,y,w,h = cv2.boundingRect(cnt)\\r\\n cv2.rectangle(flt_img,(x,y),(x+w,y+h),[0,255,0],2)\\r\\n #showWait(flt_img,'fltres')\\r\\n _,xx,res_boxes,_,_ = mergeBoundingBoxes(flt_img,last_cnt,last_labels)\\r\\n cnt = len(res_boxes)\\r\\n counts.append([cnt,flt_img,last_cnt,last_labels])\\r\\n # append resulted image and contours to an array\\r\\n counts = np.asarray(counts)\\r\\n # get the resulted image which contain more digits (bounding boxes)\\r\\n tmp = counts[:,0]\\r\\n resulted_img = counts[np.argmax(tmp),1]\\r\\n result_labels = counts[np.argmax(tmp),3]\\r\\n resulted_contour = counts[np.argmax(tmp),2]\\r\\n return resulted_contour,result_labels,resulted_img\",\n \"def props_for_contours(contours, ary):\\n c_info = []\\n for c in contours:\\n x, y, w, h = cv2.boundingRect(c)\\n c_im = np.zeros(ary.shape)\\n cv2.drawContours(c_im, [c], 0, 255, -1)\\n c_info.append({\\n 'x1': x,\\n 'y1': y,\\n 'x2': x + w - 1,\\n 'y2': y + h - 1,\\n 'sum': np.sum(ary * (c_im > 0)) / 255\\n })\\n return c_info\",\n \"def binary_contour_image_filter(*args, **kwargs):\\n import itk\\n instance = itk.BinaryContourImageFilter.New(*args, **kwargs)\\n return instance.__internal_call__()\",\n \"def get_contours(mask, threshold_area):\\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\\n\\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy\",\n \"def get_contours(mask, threshold_area):\\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\\n\\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy\",\n \"def extract_features(img, clf, windows, y_start_stop, xy_window, stride):\\n\\n transformers = {k: v for k, v in clf.named_steps['features'].transformer_list}\\n\\n chist_transformer = transformers['chist']\\n # remove the first two steps since they are not needed\\n chist_transformer = Pipeline(chist_transformer.steps[2:])\\n\\n sb_transformer = transformers['sb']\\n # remove the first two steps since they are not needed\\n sb_transformer = Pipeline(sb_transformer.steps[2:])\\n\\n img_scaled_sb = convert_cspace(img, transformers['sb'].named_steps['sb_csc'].cspace)\\n samples_sb = cut_out_windows(img_scaled_sb, windows)\\n\\n img_scaled_chist = convert_cspace(img, transformers['chist'].named_steps['chist_csc'].cspace)\\n samples_chist = cut_out_windows(img_scaled_chist, windows)\\n\\n img_scaled_hog = convert_cspace(img, transformers['hog'].named_steps['hog_csc'].cspace)\\n search_area_hog = img_scaled_hog[y_start_stop[0]:y_start_stop[1], :, :]\\n\\n hog_vectors = get_hog_vector(search_area_hog, transformers['hog'], xy_window[0], stride)\\n sb_vectors = sb_transformer.transform(samples_sb)\\n chist_vectors = chist_transformer.transform(samples_chist)\\n\\n return np.concatenate((hog_vectors, chist_vectors, sb_vectors), axis=1)\",\n \"def __find_contours(input1, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy = cv2.findContours(input1, cv2.RETR_TREE, method=method)\\n return contours\",\n \"def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\\n\\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\\n\\n # Since the watershed draws contours, we need to invert the predictions to\\n # get the 'inside' blob portion. We also slightly compress the blob portion\\n # so we can get a more defining border.\\n inverted_contours = 255 - class_contours\\n\\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\\n # remove areas that are not part of the class mask\\n inverted_contours[class_mask==0]= 0 # here ?\\n\\n return inverted_contours\",\n \"def contour2points(contours):\\n return contours.reshape(-1, 2)\",\n \"def subimage(image_as_array, step):\\r\\n\\tsubimage_2d_array = image_as_array[200-int(step):200+int(step)]\\r\\n\\treturn subimage_2d_array\",\n \"def split(self):\\n sub_images = []\\n\\n for region in regionprops(self.cells):\\n minr, minc, maxr, maxc = region.bbox\\n sub_image = self.image_raw[max(0, minr - 10):maxr, max(0, minc - 10):maxc, :]\\n\\n sub_images.append(FQimage(data=sub_image))\\n\\n return sub_images\",\n \"def contours_to_arrays(gdf, col): \\n\\n coords_zvals = []\\n\\n for i in range(0, len(gdf)):\\n\\n val = gdf.iloc[i][col]\\n\\n try:\\n coords = np.concatenate([np.vstack(x.coords.xy).T \\n for x in gdf.iloc[i].geometry])\\n except:\\n coords = np.vstack(gdf.iloc[i].geometry.coords.xy).T\\n\\n coords_zvals.append(np.column_stack((coords, \\n np.full(np.shape(coords)[0], \\n fill_value=val))))\\n\\n return np.concatenate(coords_zvals)\",\n \"def getContours(frame):\\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def get_segmented_point_clouds(seg_masks, depth): \\n obj_labels = np.unique(seg_masks)\\n num_objs = obj_labels.shape[0]+1\\n rows, cols = seg_masks.shape\\n cm = plt.get_cmap('gist_rainbow')\\n colors = [cm(1. * i/num_objs) for i in range(num_objs)]\\n \\n object_dict = {}\\n # key - object label; val - depth array of that object\\n for i in obj_labels:\\n object_dict[i] = np.zeros((rows,cols), dtype = np.float32)\\n\\n for i in range(rows):\\n for j in range(cols):\\n if seg_masks[i][j] != 0 and seg_masks[i][j] != -1:\\n object_dict[seg_masks[i][j]][i][j] = depth[i][j]\\n \\n segmented_pcds = []\\n for key, val in object_dict.items():\\n if key == -1 or key == 0:\\n continue\\n img = o3d.geometry.Image(val)\\n pcd_from_depth = o3d.geometry.PointCloud.create_from_depth_image(\\n img,\\n o3d.camera.PinholeCameraIntrinsic(\\n o3d.camera.PinholeCameraIntrinsicParameters.PrimeSenseDefault))\\n\\n # Multiply with Transformation matrix to get correct view of the PCD\\n pcd_from_depth.transform([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]])\\n pcd_from_depth.paint_uniform_color(np.array(colors[key][:3], dtype = np.uint8) * 255)\\n segmented_pcds.append(pcd_from_depth)\\n return segmented_pcds\",\n \"def bbxes_data(img):\\n _, _, stats, centr = cv2.connectedComponentsWithStats(img)\\n # (xCentr, yCentr, area, width, height, xStart, xEnd , yStart, yEnd )\\n return sorted([(cent[0], cent[1], stat[4], stat[2], stat[3], stat[0], stat[0] + stat[2], stat[1], stat[1] + stat[3])\\n for cent, stat in zip(centr[1:], stats[1:])])\",\n \"def image2features(img_bat, features, lat, lon):\\n # create contours\\n im2, contours, hierarchy = cv.findContours(img_bat, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)\\n\\n # create array of points\\n polygones = [[] for _ in contours]\\n points = []\\n list_coord_poly = []\\n for i in range(len(contours)):\\n for j in range(len(contours[i])):\\n var = np.array(contours[i][j]).tolist()\\n points.append(var[0])\\n polygones[i].append(points[:])\\n points = []\\n list_coord_poly.append(polygones[i][0])\\n\\n # project points from geographic coordinates(Google Maps) to WGS_1984_Web_Mercator_Auxiliary_Sphere EPSG:3857\\n list_coord_poly = inv_y(list_coord_poly, img_bat)\\n list_coord_poly = scale(list_coord_poly)\\n list_coord_poly = translation(list_coord_poly, lat, lon)\\n\\n # list of Polygon objects\\n # features = []\\n for polygone in list_coord_poly:\\n # Create a Polygon object based on the array of points\\n # Append to the list of Polygon objects\\n features.append(\\n arcpy.Polygon(\\n arcpy.Array([arcpy.Point(*coords) for coords in polygone])))\",\n \"def slicewhere(condition):\\n regions = ndimage.find_objects(ndimage.label(condition)[0])\\n return [region[0] for region in regions]\",\n \"def getCharacterContour(space, debug=False):\\r\\n\\r\\n contours = cv2.findContours(space, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)\\r\\n contours = imutils.grab_contours(contours)\\r\\n\\r\\n # Sort contours by area, descending\\r\\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\\r\\n\\r\\n totalArea = space.shape[0] * space.shape[1]\\r\\n\\r\\n for contour in contours:\\r\\n\\r\\n area = cv2.contourArea(contour)\\r\\n hull = cv2.convexHull(contour)\\r\\n hull_area = cv2.contourArea(hull)\\r\\n\\r\\n if debug:\\r\\n cv2.drawContours(space, contours, 0, (128, 255, 60), 2)\\r\\n cv2.imshow('space', space)\\r\\n cv2.waitKey(0)\\r\\n cv2.destroyAllWindows()\\r\\n\\r\\n if cv2.contourArea(cv2.convexHull(contour)) < totalArea * 0.05:\\r\\n break\\r\\n\\r\\n if cv2.contourArea(cv2.convexHull(contour)) < totalArea * 0.95:\\r\\n return contour\\r\\n\\r\\n return None\",\n \"def substratesFrom(polygons):\\n containmentGraph = buildContainmentGraph(polygons)\\n polygonLevels = graphLevels(containmentGraph) # Even polygons are outlines, odd are holes\\n substrates = []\\n for idx, polygon in enumerate(polygons):\\n level = polygonLevels[idx]\\n if not even(level):\\n continue\\n holes = [polygons[x].exterior for x in containmentGraph[idx] if polygonLevels[x] == level + 1]\\n substrates.append(Polygon(polygon.exterior, holes))\\n return substrates\",\n \"def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\\n min_ratio, max_ratio):\\n output = []\\n for contour in input_contours:\\n x,y,w,h = cv2.boundingRect(contour)\\n if (w < min_width or w > max_width):\\n continue\\n if (h < min_height or h > max_height):\\n continue\\n area = cv2.contourArea(contour)\\n if (area < min_area):\\n continue\\n if (cv2.arcLength(contour, True) < min_perimeter):\\n continue\\n hull = cv2.convexHull(contour)\\n solid = 100 * area / max(cv2.contourArea(hull),1)\\n if (solid < solidity[0] or solid > solidity[1]):\\n continue\\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\\n continue\\n ratio = (float)(w) / h\\n if (ratio < min_ratio or ratio > max_ratio):\\n continue\\n output.append(contour)\\n return output\",\n \"def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\\n return [\\n [sc.cVLS() for sc in scList]\\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\\n ]\",\n \"def watershed(img):\\n\\ttmp = img.copy()\\n\\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\\n\\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\\n\\tkernel = np.ones((3,3), np.uint8)\\n\\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\\n\\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\\n\\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\\n\\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\\n\\tsure_fg = np.uint8(sure_fg)\\n\\tunknown = cv2.subtract(sure_bg, sure_fg)\\n\\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\\n\\tmarkers = markers+1\\n\\tmarkers[unknown==255] = 0\\n\\tmarkers = cv2.watershed(tmp, markers)\\n\\ttmp[markers == -1] = [255,0,0]\\n\\treturn tmp\",\n \"def ShowOneContour(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt,figname):\\n plt.figure(figsize=(15,6))\\n spec_index_min=100 # cut the left border\\n spec_index_max=1900 # cut the right border\\n star_halfwidth=70\\n \\n YMIN=-15\\n YMAX=15\\n \\n figfilename=os.path.join(dir_top_img,figname) \\n \\n #center is approximately the one on the original raw image (may be changed)\\n #x0=int(all_pointing[index][0])\\n x0=int(thex0[index])\\n \\n \\n # Extract the image \\n full_image=np.copy(all_images[index])\\n \\n # refine center in X,Y\\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\\n \\n profile_X=np.sum(star_region_X,axis=0)\\n profile_Y=np.sum(star_region_X,axis=1)\\n\\n NX=profile_X.shape[0]\\n NY=profile_Y.shape[0]\\n \\n X_=np.arange(NX)\\n Y_=np.arange(NY)\\n \\n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\\n \\n x0=int(avX+x0-star_halfwidth)\\n \\n \\n # find the center in Y on the spectrum\\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\\n y0=np.where(yprofile==yprofile.max())[0][0]\\n\\n # cut the image in vertical and normalise by exposition time\\n reduc_image=full_image[y0-20:y0+20,x0:spec_index_max]/all_expo[index] \\n reduc_image[:,0:100]=0 # erase central star\\n \\n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\\n \\n # calibration in wavelength\\n #grating_name=all_filt[index].replace('dia ','')\\n grating_name=get_disperser_filtname(all_filt[index])\\n \\n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\\n \\n #if grating_name=='Ron200':\\n # holo = Hologram('Ron400',verbose=True)\\n #else: \\n # holo = Hologram(grating_name,verbose=True)\\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\\n #if grating_name=='Ron200':\\n # lambdas=lambdas*2.\\n \\n\\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \\n T=np.transpose(reduc_image)\\n \\n \\n plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\\n C = plt.contour(X, Y, reduc_image , 20, colors='black', linewidth=.5,origin='lower')\\n \\n \\n for line in LINES:\\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\\n plt.text(line['lambda'],YMAX-3,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\\n \\n \\n \\n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\\n plt.title(all_titles[index])\\n plt.grid(color='white', ls='solid')\\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\\n plt.xlabel('$\\\\lambda$ (nm)')\\n plt.ylabel('pixels')\\n plt.ylim(YMIN,YMAX)\\n plt.xlim(0.,1200.)\\n plt.savefig(figfilename)\",\n \"def extract_faces(self, img, list_face_coord):\\n #from the img array extract the facees\\n list_faces = []\\n #Go through each face coordinates and store the array\\n #or clip face region in the list\\n for i, coord in enumerate(list_face_coord):\\n left, top, right, bottom = coord\\n list_faces.append(img[top:bottom, left:right])\\n return list_faces\",\n \"def splitContours(contours):\\n split_contours = []\\n for contour in contours:\\n c = contour.reshape(-1, 2)\\n line_segments = splitLine(c)\\n for seg in line_segments:\\n # Turn it back to its original shape, so we can add it back to contours\\n new_contour = seg.reshape(-1,1,2)\\n # Dont add empty contours to our new list of contours\\n if new_contour.size != 0:\\n split_contours.append(new_contour)\\n\\n return split_contours\",\n \"def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\\n\\n kernel = np.ones((5, 5), np.float32)\\n\\n # Use a distance transform to find the seed points for watershed\\n tmp = class_mask\\n tmp[tmp>0] = 1 # here\\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\\n dist = (dist / np.max(dist)) * 255.\\n\\n # Since there may be multiple peaks, we use dilation to find them\\n dilate = cv2.dilate(dist, kernel, iterations=3)\\n peaks = np.float32(np.where(dilate == dist, 1, 0))\\n peaks = peaks * class_mask * 255\\n\\n sure_fg = np.where(peaks > 125, 255., 0.)\\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\\n sure_fg = np.uint8(sure_fg)\\n\\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\\n unknown = sure_bg - sure_fg\\n\\n # Add one to all labels so that known background is not 0, but 1\\n _, markers = cv2.connectedComponents(sure_fg)\\n markers = markers + 1\\n\\n markers[unknown == 255] = 0\\n\\n markers = cv2.watershed(self.image, markers)\\n\\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\\n watershed_superpixels[markers == -1] = 255\\n\\n return watershed_superpixels\",\n \"def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\\n min_ratio, max_ratio):\\n output = []\\n for contour in input_contours:\\n x, y, w, h = cv2.boundingRect(contour)\\n if (w < min_width or w > max_width):\\n continue\\n if (h < min_height or h > max_height):\\n continue\\n area = cv2.contourArea(contour)\\n if (area < min_area):\\n continue\\n if (cv2.arcLength(contour, True) < min_perimeter):\\n continue\\n hull = cv2.convexHull(contour)\\n solid = 100 * area / cv2.contourArea(hull)\\n if (solid < solidity[0] or solid > solidity[1]):\\n continue\\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\\n continue\\n ratio = (float)(w) / h\\n if (ratio < min_ratio or ratio > max_ratio):\\n continue\\n output.append(contour)\\n return output\",\n \"def active_contour_balloon(img, spline, debug=False, threshold='auto'):\\n init = spline.generate_mask(img.shape)\\n init[init == l.CONTOUR] = l.INSIDE\\n init[init == l.BG] = 0\\n init.clip(max=1)\\n debug and plot(init, \\\"init\\\")\\n prep_img = inverse_gaussian_gradient(np.array(img))\\n debug and plot(prep_img, \\\"inverse_gaussian_gradient\\\")\\n morph_GAC = morphological_geodesic_active_contour(\\n prep_img, 5, init, smoothing=1,\\n balloon=1, threshold=threshold,\\n # iter_callback=lambda x: plot(x * 255)\\n )\\n morph_GAC = np.array(morph_GAC * 255).astype(np.uint8)\\n if not morph_GAC.any():\\n return None\\n morph_GAC[morph_GAC > 0] = 255\\n debug and plot(morph_GAC, \\\"morphGAC\\\")\\n try:\\n contours, _ = cv2.findContours(morph_GAC, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n except:\\n return None\\n contours = sorted(contours, key=lambda x: cv2.contourArea(x), reverse=True)\\n contour = np.squeeze(contours[0])\\n\\n return contour\",\n \"def bound_shapes(contours):\\r\\n\\r\\n contours_poly = [None]*len(contours)\\r\\n boundRect = [None]*len(contours)\\r\\n centers = [None]*len(contours)\\r\\n radius = [None]*len(contours)\\r\\n for i, c in enumerate(contours):\\r\\n contours_poly[i] = cv2.approxPolyDP(c, 3, True)\\r\\n boundRect[i] = cv2.boundingRect(contours_poly[i])\\r\\n centers[i], radius[i] = cv2.minEnclosingCircle(contours_poly[i])\\r\\n \\r\\n return (contours_poly, boundRect, centers, radius)\",\n \"def get_sun_features(image): # Use grayscale images, outside val: NaN\\r\\n ratio = sun_isoperimetric_ratio(image)\\r\\n sun_features = {\\\"sun_circularity_ratio\\\": ratio}\\r\\n return sun_features\",\n \"def contour_sampling(contour, num,delta = 5):\\n \\n samples = []\\n step = len(contour)/num\\n\\n lefte = 0\\n \\n for i in range(num):\\n #for i in range(5):\\n samples.append(contour[i*step - i*delta])\\n samples.append((contour[i*step - i*delta][0],lefte))\\n\\n #samples.append(contour[len(contour) - 1])\\n\\n return samples\",\n \"def cfdGetFaceSfSubArrayForBoundaryPatch(self):\\r\\n\\r\\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\\r\\n \\r\\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\\r\\n \\r\\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\\r\\n \\r\\n iBFaces=list(range(int(startBFace),int(endBFace))) \\r\\n \\r\\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=[self.faceSf[i] for i in iBFaces] \\r\\n \\r\\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=np.asarray(self.cfdBoundaryPatchesArray[iBPatch]['facesSf'])\",\n \"def GetPointToIncidentFacesArray(self, p_int):\\n ...\",\n \"def get_contours_points(found, contours):\\n contours_points = []\\n for i in found:\\n c = contours[i]\\n for sublist in c:\\n for p in sublist:\\n contours_points.append(p)\\n return contours_points\",\n \"def getNewIntersections(self):\\n sections = []\\n sections2D = []\\n xs = np.array(self.XYProjections)[:,0]\\n L = xs[-1] - xs[0]\\n xis = xs / L\\n R = self.XYZCoordinate.T\\n if len(xis) != len(self.SkeletonPoints):\\n raise Exception(\\\"Conflit between xis and SkeletonPoints.\\\", self.SKeletonPoints)\\n for i in range(len(xis)):\\n xi = xis[i]\\n normalVec = self.returnTangentVectorAtXi(xi)\\n originPoint = self.SkeletonPoints[i]\\n \\n # define transform manually\\n T = np.zeros((4,4))\\n T[:3,:3] = R[:,np.array([1,2,0])]; # 3rd axis is reduced by projection\\n T[:3,3] = originPoint; \\n T[3,3] = 1.0\\n to_2D = (np.linalg.inv(T)).astype(float)\\n \\n try:\\n slice = self.mesh.section(plane_origin=originPoint, plane_normal=normalVec)\\n # 选取每个截面图中面积最大的子图，实现初步去噪\\n if slice is not None:\\n slice_2D, to_3D = slice.to_planar(to_2D=to_2D,check=False)\\n slices_splited = slice_2D.split()\\n sliceIndex = np.argmax([s.area for s in slices_splited])\\n slice_2D = slices_splited[sliceIndex]\\n if True: #slice_2D.area > 1e-1:\\n sections2D.append(slice_2D)\\n sections.append(slice_2D.to_3D(to_3D))\\n except:\\n pass\\n \\n self.Intersections2D = sections2D\\n self.Intersections = sections\",\n \"def find_contours(img_path, **kwargs):\\n threshold = kwargs['threshold']\\n image = cv2.imread(img_path)\\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\n blurred = cv2.GaussianBlur(gray, (5, 5), 0)\\n thresh = cv2.threshold(blurred, threshold, 255, cv2.THRESH_BINARY)[1]\\n contours, _ = cv2.findContours(thresh.copy(),\\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n\\n\\n contour_areas = [] # TODO: is there a faster way to keep the contors with n-largest areas?\\n for i, contour in enumerate(contours):\\n area = cv2.contourArea(contour)\\n contour_areas.append((i, area))\\n\\n rect = cv2.minAreaRect(contour)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n cv2.drawContours(image,[box],0,(0,0,255),2)\\n cv2.imwrite('rect_{}.png'.format(i), image)\\n # Contours that cover the largest areas are whole pieces\\n largest_contour_areas = nlargest(10, contour_areas, key=lambda x:x[1])\\n #print(largest_contour_areas)\\n\\n for i, area in largest_contour_areas:\\n print (i, area)\\n cv2.drawContours(image, contours, i, (100, 155, 100), 3)\\n cv2.imwrite('contor_{}.png'.format(i), image)\\n return True\",\n \"def get_integral_descriptors(image,filtered_coords,wid=5):\\n desc = []\\n for coords in filtered_coords:\\n patch = image[coords[0]-wid:coords[0]+wid+1,\\n coords[1]-wid:coords[1]+wid+1]\\n desc.append(patch)\\n return desc\",\n \"def contour_array(self, a, masked_values=None, head=None, **kwargs):\\n return self.__cls.contour_array(a=a, masked_values=masked_values,\\n head=head, **kwargs)\",\n \"def contours(subject, colour='gray'):\\n for row in data.get_contours(subject)['contours']:\\n for col in row:\\n xs = []\\n ys = []\\n for pair in col['arr']:\\n xs.append(pair['x'])\\n ys.append(pair['y'])\\n ys = config['surveys']['atlas']['fits_height'] - numpy.array(ys)\\n matplotlib.pyplot.plot(xs, ys, c=colour)\",\n \"def drawShadedContours(xlist, ylist, zmatrix, levels):\\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))\",\n \"def get_objects(color, depth, threshold1, threshold2):\\n\\n gray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)\\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\\n surf = cv2.xfeatures2d.SURF_create(500)\\n\\n # find and draw the keypoints\\n kp = surf.detect(blur,None)\\n\\n pts = [p.pt for p in kp]\\n xpts = []\\n ypts = []\\n\\n # evaluate the keypoints and only save the keypoints who are between the given threshold\\n depth_values = []\\n for i in range(0,len(pts)):\\n xco = int(pts[i][0])\\n yco = int(pts[i][1])\\n depth_value = depth[yco][xco]\\n if depth_value >= float(threshold1) and depth_value <= float(threshold2):\\n xpts.append(xco)\\n ypts.append(yco)\\n depth_values.append(depth_value)\\n\\n # make histogram of x coordinates of the saved keypoints\\n n, distr, _ = plt.hist(xpts)\\n plt.savefig('hist.png')\\n\\n # evaluate the histogram and make seperate arrays for the different objects\\n objectarray = []\\n temp = []\\n for i in range(len(n)):\\n if n[i] > 0:\\n temp.append(distr[i])\\n temp.append(distr[i+1])\\n else:\\n if len(temp)!=0:\\n objectarray.append(temp)\\n temp = []\\n objectarray.append(temp)\\n\\n objects = []\\n\\n # determine the objects with the previous calculated arrays\\n for i in range(len(objectarray)):\\n y_values = []\\n min_x = int(np.amin(objectarray[i]))\\n max_x = int(np.amax(objectarray[i]))\\n\\n for j in range(len(xpts)):\\n if xpts[j] > min_x and xpts[j] < max_x:\\n y_values.append(ypts[j])\\n\\n min_y = int(np.amin(y_values))\\n max_y = int(np.amax(y_values))\\n x = min_x\\n y = min_y\\n w = max_x - min_x\\n h = max_y - min_y\\n\\n depth_mean = round(get_depth_mean(depth, x, y, w, h), 3)\\n\\n object = DetectedObject(x, y, w, h, depth_mean)\\n objects.append(object)\\n\\n return objects\",\n \"def draw_contours(self, edged_image, image_cropped): \\n # Find contours. Since we are only intersted in the list of contours we use a dummy variable for the second thing that is also returned (hierarchy)\\n (contours, _) = cv2.findContours(edged_image.copy(), # using a copy of the image\\n cv2.RETR_EXTERNAL, # contour retrieval mode. RETR_EXTERNAL has to do with how contours are structured hierarchically. It performs a hierarchical structuring, which means that internal structures are filtered out leaving only external contours. Hence, if there are contours inside the object we filter those out, and only focus on the contours that surrounds the object itself. \\n cv2.CHAIN_APPROX_SIMPLE) # contours approximation method. This method only saves the most important boundary points of the contours rather than all of them in order to save memory. \\n \\n # Draw green contours around the letters on the cropped image\\n image_letters = cv2.drawContours(image_cropped.copy(), # using a copy of the image\\n contours, # list of contours\\n -1, # draw all contours\\n (0,255,0), # green following the BGR-color model of openCV\\n 2) # thickness of contours\\n \\n # Save cropped image with contours\\n cv2.imwrite(os.path.join(self.output_dir, f\\\"{self.input_image}_letters.jpg\\\"), image_letters)\",\n \"def findContours(img, thresh=127, val=255):\\n\\tgray = grayscale(img)\\n\\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\\n\\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\terrorCheckContour(contours)\\n\\treturn sort(contours)\",\n \"def extract(integral_channels, feature_stubs):\\n\\n features = []\\n for stub in feature_stubs:\\n ch, p_x, p_y, he, wi = stub\\n\\n ch = integral_channels[ch]\\n rect1 = ch.item(p_y, p_x)\\n rect2 = ch.item(p_y, p_x+wi)\\n rect3 = ch.item(p_y+he, p_x)\\n rect4 = ch.item(p_y+he, p_x+wi)\\n\\n fea = rect4 + rect1 - rect2 - rect3\\n features.append(fea)\\n\\n return features\",\n \"def find_contours(vertical, horizontal):\\n\\tmask = vertical + horizontal\\n\\n\\ttry:\\n\\t\\t__, contours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\texcept ValueError:\\n\\t\\t# for opencv backward compatibility\\n\\t\\tcontours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\t# sort in reverse based on contour area and use first 10 contours\\n\\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\\n\\n\\tcont = []\\n\\tfor c in contours:\\n\\t\\tc_poly = cv2.approxPolyDP(c, 3, True)\\n\\t\\tx, y, w, h = cv2.boundingRect(c_poly)\\n\\t\\tcont.append((x, y, w, h))\\n\\treturn cont\",\n \"def displayContours(self):\\n #obsolete?\\n profbox()\\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\\n for modelNode in modelNodes.values():\\n if modelNode.GetAttribute(\\\"contour\\\") == \\\"1\\\":\\n needleNode = slicer.mrmlScene.GetNodeByID(modelNode.GetAttribute(\\\"needleID\\\"))\\n if needleNode != None:\\n if needleNode.GetDisplayVisibility()==1:\\n modelNode.SetDisplayVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))\\n d = modelNode.GetDisplayNode()\\n d.SetSliceIntersectionVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))\",\n \"def get_cntr_points_from_center(self, contour, img_size):\\n res_arr = []\\n half_img_size = int(np.round(img_size/3))\\n diag_coord = np.random.randint(half_img_size,2*half_img_size)\\n # find the center point\\n center_point = [diag_coord,diag_coord]\\n # define all borders point\\n border = ([[0,i] for i in np.arange(0,img_size)] + \\n [[img_size,i] for i in np.arange(0,img_size)] +\\n [[i,0] for i in np.arange(0,img_size)] + \\n [[i,img_size] for i in np.arange(0,img_size)])\\n for point in border:\\n tmp_res = []\\n row_diff = point[0] - center_point[0]\\n col_diff = point[1] - center_point[1]\\n # find the distance between center point and border point\\n dist = int(np.round(np.sqrt(row_diff*row_diff+col_diff*col_diff)))\\n # find steps for row and column to go from center to border\\n row_step = row_diff/dist\\n col_step = col_diff/dist\\n \\n row_diff = center_point[0]\\n col_diff = center_point[1]\\n c_point = [int(np.round(row_diff)),\\n int(np.round(col_diff))]\\n\\n # go from center to border until points inside image\\n while ((c_point[0]>= 0) \\n and (c_point[0] < img_size) \\n and (c_point[1]>= 0) \\n and (c_point[1] < img_size)):\\n if cv2.pointPolygonTest(contour,(c_point[0],c_point[1]),True)> 0:\\n tmp_res.append(c_point)\\n row_diff = row_diff + row_step\\n col_diff = col_diff + col_step\\n c_point = [int(np.round(row_diff)),\\n int(np.round(col_diff))]\\n if len(tmp_res):\\n res_arr.append(tmp_res)\\n return res_arr\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6358348","0.62865835","0.61682415","0.61467576","0.6096353","0.60877997","0.6076599","0.60685176","0.6063275","0.6045179","0.6035992","0.6009514","0.59757787","0.5924858","0.5912952","0.5906821","0.5885125","0.5875746","0.5873737","0.5834278","0.58287823","0.5817759","0.5816798","0.5766043","0.5743229","0.5736688","0.5724109","0.56991154","0.56638753","0.56457525","0.5628987","0.5607718","0.5587124","0.5581518","0.5551621","0.55479777","0.5545625","0.55447555","0.55278903","0.5527196","0.5507236","0.55058247","0.55033946","0.5496353","0.5488345","0.5485537","0.54733187","0.54636776","0.54603267","0.5457368","0.54555476","0.5455235","0.5442473","0.5428946","0.5420398","0.5402088","0.5402088","0.54020876","0.5401681","0.53845024","0.5374717","0.53522104","0.534995","0.5346219","0.53461635","0.53455794","0.5336536","0.53268975","0.5326813","0.5323964","0.5320637","0.53170174","0.5315104","0.5311924","0.53056335","0.5298212","0.52976775","0.529763","0.5297154","0.5287246","0.5286198","0.52858925","0.5283051","0.5282336","0.5274046","0.5270818","0.52690077","0.5268381","0.5267941","0.52624816","0.5259773","0.5251867","0.5250712","0.52503186","0.524901","0.5233078","0.52290446","0.5212233","0.520951","0.52016574"],"string":"[\n \"0.6358348\",\n \"0.62865835\",\n \"0.61682415\",\n \"0.61467576\",\n \"0.6096353\",\n \"0.60877997\",\n \"0.6076599\",\n \"0.60685176\",\n \"0.6063275\",\n \"0.6045179\",\n \"0.6035992\",\n \"0.6009514\",\n \"0.59757787\",\n \"0.5924858\",\n \"0.5912952\",\n \"0.5906821\",\n \"0.5885125\",\n \"0.5875746\",\n \"0.5873737\",\n \"0.5834278\",\n \"0.58287823\",\n \"0.5817759\",\n \"0.5816798\",\n \"0.5766043\",\n \"0.5743229\",\n \"0.5736688\",\n \"0.5724109\",\n \"0.56991154\",\n \"0.56638753\",\n \"0.56457525\",\n \"0.5628987\",\n \"0.5607718\",\n \"0.5587124\",\n \"0.5581518\",\n \"0.5551621\",\n \"0.55479777\",\n \"0.5545625\",\n \"0.55447555\",\n \"0.55278903\",\n \"0.5527196\",\n \"0.5507236\",\n \"0.55058247\",\n \"0.55033946\",\n \"0.5496353\",\n \"0.5488345\",\n \"0.5485537\",\n \"0.54733187\",\n \"0.54636776\",\n \"0.54603267\",\n \"0.5457368\",\n \"0.54555476\",\n \"0.5455235\",\n \"0.5442473\",\n \"0.5428946\",\n \"0.5420398\",\n \"0.5402088\",\n \"0.5402088\",\n \"0.54020876\",\n \"0.5401681\",\n \"0.53845024\",\n \"0.5374717\",\n \"0.53522104\",\n \"0.534995\",\n \"0.5346219\",\n \"0.53461635\",\n \"0.53455794\",\n \"0.5336536\",\n \"0.53268975\",\n \"0.5326813\",\n \"0.5323964\",\n \"0.5320637\",\n \"0.53170174\",\n \"0.5315104\",\n \"0.5311924\",\n \"0.53056335\",\n \"0.5298212\",\n \"0.52976775\",\n \"0.529763\",\n \"0.5297154\",\n \"0.5287246\",\n \"0.5286198\",\n \"0.52858925\",\n \"0.5283051\",\n \"0.5282336\",\n \"0.5274046\",\n \"0.5270818\",\n \"0.52690077\",\n \"0.5268381\",\n \"0.5267941\",\n \"0.52624816\",\n \"0.5259773\",\n \"0.5251867\",\n \"0.5250712\",\n \"0.52503186\",\n \"0.524901\",\n \"0.5233078\",\n \"0.52290446\",\n \"0.5212233\",\n \"0.520951\",\n \"0.52016574\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6689849"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93473,"cells":{"query":{"kind":"string","value":"Gets lists of lists of CVLS's from a watershed array use GetSubContoursByFrame instead!"},"document":{"kind":"string","value":"def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\n return [\n [sc.cVLS() for sc in scList]\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\n ]"},"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 GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def take_contours(self):\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]","def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\n orderOfSCsByValueByFrame = [\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\n ]\n return scListByFrame, orderOfSCsByValueByFrame","def getContours(frame):\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def get_contours(self):\n depth_image = capture_images((self.w,self.h))\n\n thresh = threshold_depth_image(depth_image, min_depth=config.min_depth, max_depth=config.max_depth, threshold=config.min_depth, kernel=self.kernel)\n\n # extract contours\n im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\n if hierarchy!=None:\n hierarchy = hierarchy[0]\n return contours, hierarchy\n else:\n return [], []","def getContours(img,iteration):\n nP, IDrange = upDate(iteration)\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\n kernel = np.ones((nP, nP), np.uint8)\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\n contours = []\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n if iteration == 2 :\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n elif iteration == 3:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n else:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n return contours","def detect_contours(self):\r\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\r\n return [DbugContour(cv_contour=contour) for contour in contours]","def getContours( self,img ):\n if( len(img.shape) == 3):\n (_, contours, _) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n else:\n (contours,_) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def find_contours(thresh):\n thresh = thresh.astype(np.uint8)\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n\n # filter outer contours\n filtered_cont = []\n for i in range(len(contours)):\n if hierarchy[0, i, 3] == NO_PARENT:\n filtered_cont.append(contours[i])\n\n return filtered_cont","def extractFeatures(bwimage):\n \n \n # circularity\n img = bwimage.copy()\n img1, contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n \n if len(contours)==0:\n return []\n B = contours[0]\n C = B[:,0,0]\n l = C.size\n \n \n if abs(B[0,0,0] - B[l-1,0,0]) + abs(B[0,0,1] - B[l-1,0,1]) == 2:\n P8 = math.sqrt(2)\n else:\n P8 = 1 \n for j in range(0,l-1): \n if abs((B[j+1,0,0] - B[j,0,0])) + abs(B[j+1,0,1] - B[j,0,1]) == 2:\n P8 = P8 + math.sqrt(2)\n else:\n P8 = P8 + 1\n \n n = np.count_nonzero(bwimage)\n \n circularity = P8*P8/n\n \n \n # elongation\n idx = np.nonzero(bwimage);\n c = idx[1]\n r = idx[0]\n meanx = np.mean(c)\n meany = np.mean(r)\n \n \n pows = 2*np.ones(n)\n \n sigxx = np.sum(np.power((c-meanx),pows))/n\n sigyy = np.sum(np.power((r-meany),pows))/n\n sigxy = np.sum(np.multiply((r-meany),(c-meanx)))/n\n \n covMat = np.array([[sigxx, sigxy], [sigxy, sigyy]])\n val, vects = np.linalg.eig(covMat);\n \n maxEigenValue = np.amax(val) \n minEigenValue = np.amin(val.ravel()[np.flatnonzero(val)])\n \n \n elongation = math.sqrt(maxEigenValue/minEigenValue);\n \n \n # principal axis\n maxidx = np.argmax(val)\n principalAxisVector = vects[maxidx]\n \n \n return [circularity, elongation, principalAxisVector]","def find_contours(dframe):\n #Blur the image.\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\n #if debug:\n #plt.imshow(fixColor(blurred))\n #plt.show()\n #Get a threshold image, numbers where tested for the given video.\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \n cv2.CHAIN_APPROX_SIMPLE)\n return cnts","def __find_contours(input, external_only):\n if(external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\n return contours","def __find_contours(input, external_only):\r\n if(external_only):\r\n mode = cv2.RETR_EXTERNAL\r\n else:\r\n mode = cv2.RETR_LIST\r\n method = cv2.CHAIN_APPROX_SIMPLE\r\n _, contours, hierarchy = cv2.findContours(\r\n input, mode=mode, method=method)\r\n return contours","def __find_contours(input, external_only):\n if (external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n contours, hierarchy = cv2.findContours(input, mode=mode, method=method)\n return contours","def __find_contours(input, external_only):\n if(external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n im2, contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\n return contours","def get_contour_features(mask,selectcell=\"centered\"):\r\n \r\n #binarize image (everything above 0 becomes 1)\r\n mask = np.clip(mask,a_min=0,a_max=1)\r\n\r\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\r\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\r\n contours = list(contours)\r\n \r\n #in case there is no contour found, add a dummy contour\r\n if len(contours)==0:\r\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\r\n\r\n #Sort contours, longest first\r\n contours.sort(key=len,reverse=True)\r\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\r\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\r\n\r\n mu_origs = [cv2.moments(contour) for contour in contours]\r\n mu_hulls = [cv2.moments(hull) for hull in hulls]\r\n\r\n area_origs = [mu_orig[\"m00\"] for mu_orig in mu_origs]\r\n area_hulls = [mu_hull[\"m00\"] for mu_hull in mu_hulls]\r\n\r\n #drop events where area is zero\r\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \r\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\r\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\r\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\r\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\r\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\r\n \r\n \r\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\r\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\r\n\r\n \r\n if selectcell == \"smooth\":\r\n #compute the area ratio (roughness of contour)\r\n area_ratio = np.array(area_hulls)/np.array(area_origs)\r\n #get the contour with minimum roughness (smooth contour)\r\n sorter = np.argsort(area_ratio) #smallest first\r\n\r\n if selectcell == \"centered\":\r\n #select contour that is closest to the center of the image. \r\n #In iPAC, cells are usually in the center.\r\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\r\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\r\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\r\n sorter = np.argsort(distances) #smallest first\r\n \r\n #sort values with respect to chosen metric (area_ratio or distance)\r\n contours = [contours[s] for s in sorter]\r\n hulls = [hulls[s] for s in sorter]\r\n pos_x = [pos_x[s] for s in sorter]\r\n pos_y = [pos_y[s] for s in sorter]\r\n mu_origs = [mu_origs[s] for s in sorter]\r\n area_origs = [area_origs[s] for s in sorter]\r\n area_hulls = [area_hulls[s] for s in sorter]\r\n \r\n # draw mask of the chosen contour\r\n mask = np.zeros_like(mask)\r\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\r\n\r\n hull = hulls[0]#[0:n_contours]\r\n pos_x = pos_x[0]\r\n pos_y = pos_y[0] \r\n mu_orig = mu_origs[0]#[0:n_contours]\r\n area_orig = area_origs[0]#[0:n_contours]\r\n area_hull = area_hulls[0]#[0:n_contours]\r\n \r\n if area_orig>0:\r\n area_ratio = area_hull/area_orig\r\n else:\r\n area_ratio = np.nan\r\n\r\n arc = cv2.arcLength(hull, True) \r\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\"m00\"]) / arc\r\n\r\n\r\n dic = {\"mask\":mask,\"pos_x\":pos_x,\"pos_y\":pos_y,\"area_orig\":area_orig,\"area_hull\":area_hull,\\\r\n \"area_ratio\":area_ratio,\"circularity\":circularity}\r\n return dic","def preprocessing(self, img):\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def fun_contours(self, params):\n shape_coeffs = params[:self.num_shape_params]\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\n\n vertices3d = self.vertices3d\n vertices3d_from_mesh = np.zeros_like(vertices3d)\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\n\n inner_idx = 0\n for idx in range(vertices3d.shape[0]):\n lm_idx = idx % 66\n obs_num = int(np.floor(idx/66))\n\n if lm_idx in self.contour_lms_list[0]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_right[obs_num])\n elif lm_idx in self.contour_lms_list[1]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_left[obs_num])\n else:\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\n inner_idx += 1\n if inner_idx == 50:\n inner_idx = 0\n\n return (vertices3d_from_mesh - vertices3d).ravel()","def select_contours(img):\n # Find contours at a constant value\n contours = measure.find_contours(img, 300)\n # print(\"Found \" + str(len(contours)) + \" contour(s)\")\n # Select the nearest contours with respect to the center pixel of the image\n width = img.shape[1] # number of columms\n heigth = img.shape[0] # number of rows\n pixel_ref = (width / 2, heigth / 2)\n # Threshold distance is 10% of images smallest dimension\n dist_thresh = min(width, heigth) * 0.1\n contours_wanted = []\n pixel_mean_array = []\n for contour in contours:\n contour_3d = np.zeros([contour.shape[0], 3]) # 3rd dimension added for later conversion to patient coord space\n contour_3d[:, :2] = contour\n pixel_mean = np.mean(contour, axis=0)\n if distance.euclidean(pixel_ref, pixel_mean) <= dist_thresh:\n contours_wanted.append(contour_3d)\n pixel_mean_array.append(pixel_mean)\n # print(\"Set \" + str(len(contours_wanted)) + \" contours of interest\")\n return contours_wanted, pixel_mean_array","def generate_contours(threshold):\n \tcnts = cv2.findContours(threshold.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n \tcnts = imutils.grab_contours(cnts)\n \treturn cnts","def __find_contours(input1, external_only):\n if(external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n contours, hierarchy = cv2.findContours(input1, cv2.RETR_TREE, method=method)\n return contours","def find_contours(vertical, horizontal):\n\tmask = vertical + horizontal\n\n\ttry:\n\t\t__, contours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\texcept ValueError:\n\t\t# for opencv backward compatibility\n\t\tcontours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\t# sort in reverse based on contour area and use first 10 contours\n\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\n\n\tcont = []\n\tfor c in contours:\n\t\tc_poly = cv2.approxPolyDP(c, 3, True)\n\t\tx, y, w, h = cv2.boundingRect(c_poly)\n\t\tcont.append((x, y, w, h))\n\treturn cont","def get_instance_contours(img, contoured, instance):\n mask = np.zeros(img.shape, dtype=np.uint16)\n mask[img == instance] = 1\n ret, threshed = cv.threshold(mask, 0, 2 ** 16, cv.THRESH_BINARY)\n compressed = threshed.astype(np.uint8)\n contours, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n cv.drawContours(contoured, contours, -1, (randint(25, 255), randint(25, 255), randint(25, 255)), 3)\n img2 = contours = hierarchy = mask = None","def instance_contours(gti):\n # TODO: move to somewhere better\n import cv2\n\n rc_locs = np.where(gti > 0)\n grouped_cc_rcs = util.group_items(\n np.ascontiguousarray(np.vstack(rc_locs).T),\n gti[rc_locs], axis=0\n )\n\n def bounding_box(rcs):\n rc1 = rcs.min(axis=0)\n rc2 = rcs.max(axis=0)\n return rc1, rc2\n\n # slice out a bounding region around each instance, detect the contour and\n # then offset it back into image coordinates\n grouped_contours = {}\n for label, rcs in grouped_cc_rcs.items():\n rc1, rc2 = bounding_box(rcs)\n sl = (slice(rc1[0], rc2[0] + 2), slice(rc1[1], rc2[1] + 2))\n submask = (gti[sl] == label).astype(np.uint8)\n\n xy_offset = rc1[::-1]\n offset = xy_offset + [-2, -2]\n\n border = cv2.copyMakeBorder(submask, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=0 )\n _, contors, hierarchy = cv2.findContours(border, cv2.RETR_TREE,\n cv2.CHAIN_APPROX_SIMPLE,\n offset=tuple(offset))\n \"\"\"\n offset = [0, 0]\n BGR_GREEN = (0, 255, 0)\n x = np.ascontiguousarray(util.ensure_alpha_channel(submask)[:, :, 0:3]).astype(np.uint8)\n draw_img = cv2.drawContours(\n image=x, contours=contors,\n contourIdx=-1, color=BGR_GREEN, thickness=2)\n \"\"\"\n # note when len(contours > 1, there is a hole in the building)\n # assert len(contors) == 1\n grouped_contours[label] = contors\n return grouped_contours","def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\n\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\n\n # Since the watershed draws contours, we need to invert the predictions to\n # get the 'inside' blob portion. We also slightly compress the blob portion\n # so we can get a more defining border.\n inverted_contours = 255 - class_contours\n\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\n # remove areas that are not part of the class mask\n inverted_contours[class_mask==0]= 0 # here ?\n\n return inverted_contours","def get_contours(image, to_hsv=None, thresh=None, smooth=None, edge=None):\n if to_hsv is True:\n image=cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n \n if thresh is not None:\n if np.shape(thresh)!=(2, 3):\n raise TypeError('thresh must be a 2x3 array.')\n else:\n mask=cv2.inRange(image, thresh[0, :].astype(int), thresh[1, :].astype(int))\n\n if smooth is not None:\n if 'mask' in locals():\n mask=cv2.bilateralFilter(np.uint8(mask), smooth[0], smooth[1], smooth[2])\n else:\n mask=cv2.bilateralFilter(np.uint8(image), smooth[0], smooth[1], smooth[2])\n \n if edge is not None:\n if 'mask' in locals():\n mask=cv2.Canny(mask, edge[0], edge[1])\n else:\n mask=cv2.Canny(image, edge[0], edge[1])\n\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) \n return cnts[0] if imutils.is_cv2() else cnts[1]","def get_contours(self,pixel=True):\n if not self.has_wcs():\n raise NotImplementedError(\"Only WCS contours implemented and this has no wcs solution\")\n \n if pixel:\n return self.wcs.contours_pxl\n return self.wcs.contours","def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\n\n kernel = np.ones((5, 5), np.float32)\n\n # Use a distance transform to find the seed points for watershed\n tmp = class_mask\n tmp[tmp>0] = 1 # here\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\n dist = (dist / np.max(dist)) * 255.\n\n # Since there may be multiple peaks, we use dilation to find them\n dilate = cv2.dilate(dist, kernel, iterations=3)\n peaks = np.float32(np.where(dilate == dist, 1, 0))\n peaks = peaks * class_mask * 255\n\n sure_fg = np.where(peaks > 125, 255., 0.)\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\n sure_fg = np.uint8(sure_fg)\n\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\n unknown = sure_bg - sure_fg\n\n # Add one to all labels so that known background is not 0, but 1\n _, markers = cv2.connectedComponents(sure_fg)\n markers = markers + 1\n\n markers[unknown == 255] = 0\n\n markers = cv2.watershed(self.image, markers)\n\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\n watershed_superpixels[markers == -1] = 255\n\n return watershed_superpixels","def get_contours(img):\n contours, hierarchy = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours, hierarchy[0]","def find_contours(mask):\n\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,\n cv2.CHAIN_APPROX_SIMPLE)\n cnts = imutils.grab_contours(cnts)\n return cnts","def find_contours(mask):\n _, contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_KCOS)\n return contours","def cfdGetFaceSfSubArrayForBoundaryPatch(self):\r\n\r\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\r\n \r\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\r\n \r\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\r\n \r\n iBFaces=list(range(int(startBFace),int(endBFace))) \r\n \r\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=[self.faceSf[i] for i in iBFaces] \r\n \r\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=np.asarray(self.cfdBoundaryPatchesArray[iBPatch]['facesSf'])","def textDetectWatershed(thresh, original):\n # According to: http://docs.opencv.org/trunk/d3/db4/tutorial_py_watershed.html\n img = resize(original, 3000)\n thresh = resize(thresh, 3000)\n # noise removal\n kernel = np.ones((3,3),np.uint8)\n opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 3)\n \n # sure background area\n sure_bg = cv2.dilate(opening,kernel,iterations=3)\n\n # Finding sure foreground area\n dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\n ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0)\n\n # Finding unknown region\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg,sure_fg)\n \n # Marker labelling\n ret, markers = cv2.connectedComponents(sure_fg)\n\n # Add one to all labels so that sure background is not 0, but 1\n markers += 1\n\n # Now, mark the region of unknown with zero\n markers[unknown == 255] = 0\n \n markers = cv2.watershed(img, markers)\n implt(markers, t='Markers')\n image = img.copy()\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n \n # Creating result array\n boxes = []\n for mark in np.unique(markers):\n # mark == 0 --> background\n if mark == 0:\n continue\n\n # Draw it on mask and detect biggest contour\n mask = np.zeros(gray.shape, dtype=\"uint8\")\n mask[markers == mark] = 255\n\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\n c = max(cnts, key=cv2.contourArea)\n \n # Draw a bounding rectangle if it contains text\n x,y,w,h = cv2.boundingRect(c)\n cv2.drawContours(mask, c, 0, (255, 255, 255), cv2.FILLED)\n maskROI = mask[y:y+h, x:x+w]\n # Ratio of white pixels to area of bounding rectangle\n r = cv2.countNonZero(maskROI) / (w * h)\n \n # Limits for text\n if r > 0.1 and 2000 > w > 15 and 1500 > h > 15:\n boxes += [[x, y, w, h]]\n \n # Group intersecting rectangles\n boxes = group_rectangles(boxes)\n bounding_boxes = np.array([0,0,0,0])\n for (x, y, w, h) in boxes:\n cv2.rectangle(image, (x, y),(x+w,y+h), (0, 255, 0), 8)\n bounding_boxes = np.vstack((bounding_boxes, np.array([x, y, x+w, y+h])))\n \n implt(image)\n\n # Recalculate coordinates to original size\n boxes = bounding_boxes.dot(ratio(original, img.shape[0])).astype(np.int64)\n return boxes[1:]","def detectAll(self):\n\t\trects = self.cascade.detectMultiScale(self.frameImage, 1.3, 4, cv2.cv.CV_HAAR_SCALE_IMAGE, (20,20))\n\t\treturn rects","def get_contours(mask, threshold_area):\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\n\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy","def get_contours(mask, threshold_area):\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\n\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy","def get_contours(image):\n assert len(image.shape) == 2, 'Image should be binary'\n contour_image = image.copy()\n contour_image[contour_image == 1] = 255\n _, contours, _ = cv2.findContours(contour_image.astype('uint8'),\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n return contours","def findContours(image):\n thresh = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\n cv2.THRESH_BINARY, 11, 2)\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,\n cv2.CHAIN_APPROX_SIMPLE)\n return contours","def getCV(file1, type, imgOri,iteration):\n del s_arrays[:]\n del shapesContours[:]\n\n if type == 'shapes':\n spContours = getContours(imgOri,iteration)\n file1.write(str(len(spContours)) + '\\n')\n print(len(spContours))\n spContours = clean_Con(spContours)\n file1.write(str(len(spContours)) + '\\n')\n print(len(spContours))\n cv2.drawContours(imgOri, spContours, -1, (0, 255, 128), 5)\n # del s_arrays[:]\n # for each shape\n for cons in spContours:\n sampleComVector = []\n x, y, w, h = cv2.boundingRect(cons)\n cv2.rectangle(imgOri, (x, y), (x + w, y + h), (100, 100, 100), 1)\n\n # move the points to center\n for point in cons:\n sampleComVector.append(complex(point[0][0] - x, (point[0][1] - y)))\n # sampleComVectors store CV of all testees contours\n s_arrays.append(sampleComVector)\n # sampleContours store all testees contours, same order with sampleComVectors\n shapesContours.append(cons)\n\n elif type == 'temp':\n # Automatically find templete contour\n templetTrue = imgOri\n tpContour = getContours(templetTrue,iteration)\n for contour in tpContour:\n x, y, w, h = cv2.boundingRect(contour)\n #\n for point in contour:\n # -x and -y are to make left and upper boundry start from 0\n t_array.append(complex(point[0][0] - x, (point[0][1] - y)))","def watershed(img):\n\ttmp = img.copy()\n\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\n\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n\tkernel = np.ones((3,3), np.uint8)\n\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\n\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\n\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\n\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\n\tsure_fg = np.uint8(sure_fg)\n\tunknown = cv2.subtract(sure_bg, sure_fg)\n\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\n\tmarkers = markers+1\n\tmarkers[unknown==255] = 0\n\tmarkers = cv2.watershed(tmp, markers)\n\ttmp[markers == -1] = [255,0,0]\n\treturn tmp","def getMostContour(img,svm,knn,filterArr,digits,wThresh,hThresh):\r\n # append the filter to filter array, this approach is used in case of \r\n # multiple filter methods would be used.\r\n counts = []\r\n # iterare through every filter\r\n for flt in filterArr:\r\n # copy the image so we don't draw on same image\r\n flt_img = img.copy()\r\n last_img = img.copy()\r\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh) \r\n if not digits:\r\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh)\r\n flt_contour_map = []\r\n labels = []\r\n for crop,(x,y,w,h),contour in cropNwriteBBs(img,cntfound_fltr):\r\n #crop = np.array(crop,dtype='float32')\r\n crop = cv2.cvtColor(crop,cv2.COLOR_BGR2GRAY)\r\n crop = cv2.resize(crop,(25,25))\r\n # winSize is the size of the image cropped to an multiple of the cell size\r\n hog_fts = hog.compute(crop)\\\r\n .reshape(n_cells[1] - block_size[1] + 1,\r\n n_cells[0] - block_size[0] + 1,\r\n block_size[0], block_size[1], nbins) \\\r\n .transpose((1, 0, 2, 3, 4))\r\n hog_fts = np.resize(hog_fts.flatten(),(1,576))\r\n # make the resulted crop same type with the trained values\r\n hog_fts.dtype = 'float32'\r\n # get predicted labels\r\n label_svm=svm.predict(hog_fts)[1]\r\n label_knn = knn.findNearest(hog_fts,k=5)[1]\r\n # label 10 is considered as 'not digit' or 'thrash'\r\n # so if predicted label is not 10, draw the bounding box\r\n if digits:\r\n if(label_svm!=10 and label_knn != 10 and label_svm!=11 and label_knn != 11):\r\n flt_contour_map.append(contour)\r\n labels.append(str(label_knn[0])[1])\r\n else:\r\n if(label_svm!=2 and label_knn != 2):\r\n flt_contour_map.append(contour)\r\n labels.append(str(label_knn[0])[1])\r\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\r\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\r\n last_cnt,last_labels = secondElimination(flt_contour_map,labels)\r\n for cnt in last_cnt:\r\n x,y,w,h = cv2.boundingRect(cnt)\r\n cv2.rectangle(flt_img,(x,y),(x+w,y+h),[0,255,0],2)\r\n #showWait(flt_img,'fltres')\r\n _,xx,res_boxes,_,_ = mergeBoundingBoxes(flt_img,last_cnt,last_labels)\r\n cnt = len(res_boxes)\r\n counts.append([cnt,flt_img,last_cnt,last_labels])\r\n # append resulted image and contours to an array\r\n counts = np.asarray(counts)\r\n # get the resulted image which contain more digits (bounding boxes)\r\n tmp = counts[:,0]\r\n resulted_img = counts[np.argmax(tmp),1]\r\n result_labels = counts[np.argmax(tmp),3]\r\n resulted_contour = counts[np.argmax(tmp),2]\r\n return resulted_contour,result_labels,resulted_img","def findContours(img, thresh=127, val=255):\n\tgray = grayscale(img)\n\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\n\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\terrorCheckContour(contours)\n\treturn sort(contours)","def extract_features(self, clip):\n #sr, clip_array = wav_read(io.BytesIO(clip.data))\n sr = 16000\n # clip_decoded = base64.decodestring(clip.data)\n # clip_array = np.frombuffer(clip_decoded, dtype=np.float16)\n clip_array = np.array(clip.data)\n if clip_array.ndim > 1:\n clip_array = clip_array[:, 0]\n segments = frame_breaker.get_frames(clip_array, sample_rate=sr)\n segments_encoded = [self.np2base64(s, sr) for s in segments]\n segment_features = [\n [f.feature_value for f in self.extract_feats_for_segment(s).features]\n for s in segments_encoded\n ]\n return segment_features","def get_spoof_features2(img):\n roi = img # img_bgr[y:y+h, x:x+w]\n\n img_ycrcb = cv2.cvtColor(roi, cv2.COLOR_BGR2YCR_CB)\n img_luv = cv2.cvtColor(roi, cv2.COLOR_BGR2LUV)\n\n ycrcb_hist = calc_hist(img_ycrcb)\n luv_hist = calc_hist(img_luv)\n\n feature_vector = np.append(ycrcb_hist.ravel(), luv_hist.ravel())\n feature_vector = feature_vector.reshape(1, len(feature_vector))\n\n return feature_vector","def find_contours(image):\n # skimage.measure.find_contours is not only slow but impractical:\n # - interrupts hull polygon when it intersects the margins (!)\n # - uses 0.5-based coordinates (i.e. center of pixel instead of top/left)\n contours, _ = cv2.findContours(image.astype(uint8),\n cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n # convert to y,x tuples\n return [(contour[:,0,::-1], cv2.contourArea(contour))\n for contour in contours]","def get_building_contour(current_building_mask):\n ret, threshed = cv.threshold(current_building_mask, 0, 2 ** 16, cv.THRESH_BINARY)\n compressed = threshed.astype(np.uint8)\n current_building_contour, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n return current_building_contour, hierarchy","def contours_to_arrays(gdf, col): \n\n coords_zvals = []\n\n for i in range(0, len(gdf)):\n\n val = gdf.iloc[i][col]\n\n try:\n coords = np.concatenate([np.vstack(x.coords.xy).T \n for x in gdf.iloc[i].geometry])\n except:\n coords = np.vstack(gdf.iloc[i].geometry.coords.xy).T\n\n coords_zvals.append(np.column_stack((coords, \n np.full(np.shape(coords)[0], \n fill_value=val))))\n\n return np.concatenate(coords_zvals)","def contours(self, image,debug=False):\n imgray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\n if debug: cv2.imwrite('debug_pics/gray_scale_contour.jpg',imgray) # cv2.imshow('gray_scale_contour',imgray)\n im2, contours, hierarchy = cv2.findContours(imgray,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\n\n return contours,hierarchy","def contour(self) -> np.ndarray:\n return self.labels","def contextualcull(cnts):\n temp = []\n actualout = []\n indicesused = []\n for cnt in cnts:\n if cnt.area > CULL_MINIMUMS[cnt.spatialindex]:\n temp.append(cnt)\n if cnt.spatialindex not in indicesused:\n indicesused.append(cnt.spatialindex)\n if PRIORITIZE_FASTEST:\n for sindex in indicesused: #filter down to the fastest contour.\n _allatthisindex = [x for x in temp if x == sindex]\n highest = _allatthisindex.sort(key=lambda y: y.spd, reverse=False)[0]\n actualout.append(highest)\n else:\n actualout = temp\n print 'Contours after cull: ', len(actualout)\n return actualout","def readContours(self):\n if self.image==False:\n warning = QErrorMessage()\n warning.setWindowModality(Qt.WindowModal)\n warning.showMessage('Reading of contours failed. Images must be loaded prior to loading contours')\n warning.exec_()\n else:\n options=QFileDialog.Options()\n options |= QFileDialog.DontUseNativeDialog\n fileName, _ = QFileDialog.getOpenFileName(self, \"QFileDialog.getOpenFileName()\", \"\", \"XML file (*.xml)\", options=options)\n self.lumen, self.plaque, self.stent, self.resolution, frames = read_xml.read(fileName)\n self.lumen = self.mapToList(self.lumen)\n self.plaque = self.mapToList(self.plaque)\n self.stent = self.mapToList(self.stent)\n self.contours=True\n self.resizeContours()\n self.wid.setData(self.lumen, self.plaque, self.images)\n self.hideBox.setChecked(False)","def compute_contour(ptr_array):\n hull = ConvexHull(ptr_array)\n contour_index = hull.vertices.tolist() # indices are ordered\n # contour_index = hull.simplices.flatten()\n # contour_index = list(set(contour_index))\n return contour_index","def register_cells(contours: List[np.array]) -> np.array:\n def create_cell(contour: np.array) -> np.array:\n center, radius = cv2.minEnclosingCircle(contour)\n v = (0, 0)\n weight = -1\n\n return np.array([center[0], center[1], v[0], v[1], radius, weight])\n\n areas = np.array([cv2.contourArea(contour) for contour in contours]).astype(\"float32\")\n blobs = np.array([create_cell(contour) for contour in contours]).astype(\"int32\")\n\n return blobs[areas >= 100].astype(\"float32\")","def get_cntr_points(self, contour, img_size):\n res_arr = []\n # for each row\n for row in range(img_size):\n tmp_arr = []\n # for each column\n for col in range(img_size):\n # if point in contour\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\n # add point to current line\n tmp_arr.append([row,col])\n if len(tmp_arr):\n # add current line to result array\n res_arr.append(tmp_arr)\n return res_arr","def contours(subject, colour='gray'):\n for row in data.get_contours(subject)['contours']:\n for col in row:\n xs = []\n ys = []\n for pair in col['arr']:\n xs.append(pair['x'])\n ys.append(pair['y'])\n ys = config['surveys']['atlas']['fits_height'] - numpy.array(ys)\n matplotlib.pyplot.plot(xs, ys, c=colour)","def cfdGetFaceCentroidsSubArrayForBoundaryPatch(self):\r\n \r\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\r\n \r\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\r\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\r\n iBFaces=list(range(int(startBFace),int(endBFace))) \r\n \r\n self.cfdBoundaryPatchesArray[iBPatch]['faceCentroids']=[self.faceCentroids[i] for i in iBFaces]","def get_boxes(found, contours):\n boxes = []\n for i in found:\n rect = cv2.minAreaRect(contours[i])\n box = np.int0(cv2.cv.BoxPoints(rect))\n box = map(tuple, box)\n boxes.append(box)\n return boxes","def curvature_features(binary_image, step=2, min_prominance=0.1,min_width=5,dist_bwt_peaks=10):\n r_c=local_radius_curvature(binary_image,step,False)\n \n #calculate local curvature features\n local_curvature=[np.divide(1,r_c[x]) if r_c[x]!=0 else 0 for x in range(len(r_c))]\n \n #compute local and global features\n global_features = [global_curvature_features(np.array(local_curvature))]\n global_features = pd.DataFrame([o.__dict__ for o in global_features])\n \n prominant_features = [prominant_curvature_features(local_curvature,min_prominance=0.1,min_width=5,dist_bwt_peaks=10)]\n prominant_features = pd.DataFrame([o.__dict__ for o in prominant_features])\n\n all_features = pd.concat([global_features.reset_index(drop=True), prominant_features], axis=1)\n \n return all_features","def draw_contours(self, image_path):\n img = cv.imread(image_path, cv.IMREAD_ANYDEPTH)\n contoured = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\n unique, counts = np.unique(img, return_counts=True)\n for uni in unique:\n if uni == 0:\n continue\n self.get_instance_contours(img, contoured, uni)\n\n cv.namedWindow('building contours', cv.WINDOW_NORMAL)\n cv.imshow('building contours', contoured)\n cv.waitKey(0)\n cv.destroyAllWindows()","def splitContours(contours):\n split_contours = []\n for contour in contours:\n c = contour.reshape(-1, 2)\n line_segments = splitLine(c)\n for seg in line_segments:\n # Turn it back to its original shape, so we can add it back to contours\n new_contour = seg.reshape(-1,1,2)\n # Dont add empty contours to our new list of contours\n if new_contour.size != 0:\n split_contours.append(new_contour)\n\n return split_contours","def find_rects(image: np.ndarray) -> List[np.ndarray]:\n\n gray = cv.cvtColor(image.copy(), cv.COLOR_RGB2GRAY)\n gray = cv.GaussianBlur(gray, (5, 5), 0)\n #edged = cv.Canny(gray, 70, 180) # this numbers is hand picked guess from a few photos\n edged = auto_canny(gray)\n\n contours = cv.findContours(edged.copy(), cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)\n contours = contours[0] if len(contours) == 2 else contours[1]\n contours.sort(key=cv.contourArea, reverse=True)\n contours = [cnt for cnt in contours if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\n\n rects = list(map(cv.minAreaRect, contours))\n boxes = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), rects))\n\n boxes = Rect.nms_merge(boxes)\n\n return boxes or list()","def extract_roi(reg_with_roi, ir_with_roi, reg_unmarked, ir_unmarked):\n roi_pos = np.where( reg_with_roi[:,:,2] == 255 ) \n \n x = list(roi_pos[0])\n y = list(roi_pos[1])\n \n #make a 2-d mask\n \n mask = np.zeros_like(reg_with_roi[:,:,1])\n mask[x,y] = 255\n \n _, cntrs = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[:2]\n\n reg_roi_list = []\n ir_roi_list = []\n \n #masks = []\n for cnt in cntrs:\n \n if reg_unmarked.ndim == 3:\n reg_unmarked = cv2.cvtColor(reg_unmarked, cv2.COLOR_BGR2GRAY)\n \n if ir_unmarked.ndim == 3:\n ir_unmarked = cv2.cvtColor(ir_unmarked, cv2.COLOR_BGR2GRAY)\n \n temp_mask = np.zeros_like(reg_unmarked)\n cv2.fillPoly(temp_mask, [cnt], (255,255,255))\n #masks.append(temp_mask)\n \n reg_roi = cv2.bitwise_and(temp_mask, reg_unmarked)\n ir_roi = cv2.bitwise_and(temp_mask, ir_unmarked)\n \n x, y, w, h = cv2.boundingRect(cnt)\n reg_roi = reg_roi[y:y+h, x:x+w]\n ir_roi = ir_roi[y:y+h, x:x+w]\n \n reg_roi_list.append(reg_roi)\n ir_roi_list.append(ir_roi)\n \n return reg_roi_list, ir_roi_list, cntrs","def find_contour(ctx: Context):\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\n contours, _ = cv2.findContours(ctx.temp_image1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n\n # take the 5 biggest areas\n contours = sorted(contours, key=lambda c: math.fabs(cv2.contourArea(c)), reverse=True)[:5]\n\n # approximate contours with poly line\n ctx.contours = [cv2.approxPolyDP(c, 2, True) for c in contours]","def calculate_contours_fit(L_x, L_y, e, leaflet, ts, Plots, side):\n \n n = np.load(input_dir + 'directors_'+leaflet+'_tail_'+ str(ts) + '.npy') \n\n pos = np.load(input_dir + 'coordinates_'+leaflet+'_tail_' + str(ts) + '.npy') \n\n resid = np.load(input_dir + 'residues_'+leaflet+'_tail_' + str(ts) + '.npy')\n box = np.load(input_dir + 'box' + str(ts) + '.npy')\n\n \n chl = np.load(input_dir + 'cholesterol_'+leaflet+'_tail_' + str(ts) + '.npy')\n dlipc = np.load(input_dir + 'dlipc_'+leaflet+'_tail_' + str(ts) + '.npy') \n dspc = np.load(input_dir + 'dspc_'+leaflet+'_tail_' + str(ts) + '.npy')\n ssm = np.load(input_dir + 'ssm_'+leaflet+'_tail_' + str(ts) + '.npy')\n \n #n= np.ones(len(pos))\n \"\"\" END: read the input data \"\"\"\n\n\n field = order_vector_field(L_x, L_y, pos, n, e, box)\n\n c = pd.DataFrame(data=field).mean(axis=0).rolling(50, center=True, min_periods=1).mean() #50\n c.dropna(inplace=True)\n middle = 0.5*(np.max(c) + np.min(c)) \n #middle = 0.025\n contours = measure.find_contours(field, middle) # Marching Cubes algorith\n #save contours\n fac_x = box[0] / L_x #to get the right dimensions (range_x)\n fac_y = box[1] / L_y # (range_y)\n \n contours_x = []\n contours_y = []\n contours_x_y = []\n \n contours_all = []\n for m, contour in enumerate(contours):\n contours_x.append((contour[:, 1] * fac_x))\n contours_y.append((contour[:, 0] * fac_y))\n \n \n contours_x_y = np.column_stack((contours_x[m], contours_y[m]))\n contours_all.append(contours_x_y)\n np.save(output_contours + 'contours_'+leaflet+'.' + str(ts) + '.npy', contours_all)\n \n\n#===================================================\n#To assign resids to the different phases\n phase_belonging = np.zeros((len(pos)))\n ordered =[]\n disordered = []\n for i in np.arange(len(pos)):\n \n def apply_pbc(pos, box):\n if pos >= box:\n pos -= box\n if pos < 0:\n pos += box\n return pos\n \n idx_x = int(apply_pbc(pos[i,0], box[0]) / fac_x - 1.e-5) #the - 1.e-5 is because accuracy issue in the /\n idx_y = int(apply_pbc(pos[i,1], box[1]) / fac_y - 1.e-5) #this - 1.e-5 is because accuracy issue in the /\n #print(idx_x, idx_y)\n order= field[idx_y, idx_x]\n if (order > middle):\n ordered.append(order)\n order = 1 #ordered lipids\n \n else :\n disordered.append(order)\n order =0 #disordered lipids\n phase_belonging[i] = order\n \n\n resid_phases = np.column_stack((resid[:,0], phase_belonging))\n np.save(output_dir + 'resid_phases'+leaflet+'.'+ str(j) + '.npy', resid_phases)\n\n if Plots == True:\n plt.figure(figsize=(15,10)) \n \n contours_sorted = sorted(contours, key=len, reverse=True)\n \n for i in range(2):\n plt.plot(contours_sorted[i][:,1]* fac_x+0.5*fac_x, contours_sorted[i][:,0]* fac_y+0.5*fac_y, linewidth=3, color='#0000FF' ) ##00CC00\n \n #for m, contour in enumerate(contours_sorted):\n # print(contour[:,0])\n # for contour in contours: \n \n # plt.plot((contour[:, 1] * fac_x+0.5*fac_x),\n # (contour[:, 0] * fac_y+0.5*fac_y),\n # linewidth=4, color='#00CC00')\n \n plt.imshow(field, interpolation='nearest', \n cmap=plt.cm.gray_r,\n extent=[0, box[0], 0, box[1]], origin='lower', alpha=0.7) \n \n plt.axis('off')\n plot_scatter_order_field(pos, resid, dlipc, dspc, chl,ssm, n , box, ts, side) #phase_belonging.reshape(-1,1)\n plt.savefig(output_dir + 'contours-'+ leaflet + str(ts) + '.png', dpi=300) \n plt.close() \n \n return resid_phases #, ordered, disordered ","def contours_and_data(epoch, model, features, filters, figname, fgal=0.5,\n idx=-1, data='s82', N=60000):\n if data == 's82':\n # fetch Stripe 82 data\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\n filters, use_single=False)\n sind = np.abs(Xcoadd[:, idx]) < 0.03\n gind = np.abs(Xcoadd[:, idx]) > 0.03\n\n else:\n # fetch DR10 data\n X, Xcov = fetch_prepped_dr10data(N, fgal, features, filters)\n sind = np.abs(X[:, idx]) < 0.145\n gind = np.abs(X[:, idx]) > 0.145\n\n # unpickle the XD model\n if type(model) == str: \n f = open(model, 'rb')\n model = cPickle.load(f)\n f.close()\n\n fs = 5\n ms = 1\n lsize = 20\n idx = [[0, -1], [2, 3], [3, 4]]\n xlim = [(18., 22), (-0.5, 2.5), (-0.5, 2)]\n ylim = [(-0.1, 0.5), (-0.5, 2.5), (-0.5, 1.5)]\n xlab = ['psfmag $r$', 'modelmag $g-r$', 'modelmag $r-i$']\n ylab = ['psfmag - modelmag $r$', 'modelmag $r-i$', 'modelmag $i-z$']\n\n f = pl.figure(figsize=(3 * fs, 3 * fs))\n Nstar = len(np.where(model.fixed_means[:, idx] != np.inf)[0])\n pl.subplots_adjust(wspace=0.3)\n for i in range(1, 10):\n k = (i - 1) % 3\n if i < 4:\n ind = np.arange(X.shape[0], dtype=np.int)\n rng = range(model.n_components)\n elif 3 < i < 7:\n ind = sind\n rng = range(Nstar)\n else:\n ind = gind\n rng = range(Nstar, model.n_components)\n ax = pl.subplot(3, 3, i)\n for j in rng:\n if model.alpha[j] > 1.e-3:\n draw_ellipse(model.mu[j, idx[k]],\n model.V[j, idx[k]][:, idx[k]],\n scales=[2], ec='k', fc='gray', alpha=0.2)\n pl.plot(X[ind][::10, idx[k][0]],\n X[ind][::10, idx[k][1]], '.k',ms=ms)\n pl.xlim(xlim[k])\n pl.ylim(ylim[k])\n pl.xlabel(xlab[k], fontsize=lsize)\n pl.ylabel(ylab[k], fontsize=lsize)\n if ('psf' in ylab[k]) & ('model' in ylab[k]):\n ytick = ['%0.1f' % v for v in np.linspace(-.1, 0.4, 6)]\n ytick[0] = ''\n ax.set_yticklabels(ytick)\n if i == 1:\n s = 'All'\n elif i == 3:\n s = '\"Stars\"'\n else:\n s = '\"Galaxies\"'\n ax.text(-.3, 0.5, s, ha='center', va='center', fontsize=25,\n rotation='vertical', transform=ax.transAxes)\n f.savefig(figname, bbox_inches='tight')","def GetXYListAndPolyListFromCVLS(cVLS, allValsByFrame, orderOfSCsByValueByFrame):\n numFrames = len(cVLS)\n xyList = [\n sorted(list(set(tuple(pt) for c in cvlsByVal for pt in c[2])))\n for cvlsByVal in cVLS\n ]\n polyList = []\n\n for t in range(numFrames):\n polyList.append({})\n for v in allValsByFrame[t]:\n subContours = [\n (cVLS[t][-index][2][::-1] if index < 0 else cVLS[t][index][2])\n for index in orderOfSCsByValueByFrame[t][v]\n ] # reconstruct the sc's, flipping if index is negative\n polyList[-1][v] = [\n xyList[t].index(totuple(pt)) for sc in subContours for pt in sc[:-1]\n ]\n polyList[-1][v] = polyList[-1][v] + [\n polyList[-1][v][0]\n ] # Tack on the first point at the end to close the loop\n # VFMin doesn't like this format; make sure to remove this last point before saving to a file or passing to VFM...\n # polyList[-1][v] = removeDuplicates(polyList[-1][v])+[polyList[-1][v][0]] # Remove interior duplication...\n return xyList, polyList","def getContours(image, copyImage):\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n for contour in contours:\n area = cv.contourArea(contour)\n \n if area > 500.0:\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\n perimeter = cv.arcLength(contour, True)\n \n # Approximates to the nearest polygon\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\n objectCoordinates = len(approx)\n\n # Returns the x, y and height width of the polygon\n x, y, w, h = cv.boundingRect(approx)\n\n if objectCoordinates == 3:\n objectShape = \"Triangle\"\n elif objectCoordinates == 4:\n ratio = w / float(h)\n if ratio >= 0.95 and ratio <= 1.05:\n objectShape = \"Square\"\n else: objectShape = \"Rectangle\"\n else: objectShape = \"Circle\" \n\n \n\n # Draw rectangles around the images\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))","def voxelize_contours(self, contours,res,llc,voxSlice, direction):\n\t\t# generate each voxel slice\n\t\tvslices=[self.voxelize_single_contour(contour,res,llc,voxSlice, direction) for contour in contours]\n\t\tif len(vslices)>0:\n\t\t\tresult=vslices.pop(0)\n\t\t\tfor S in vslices:\n\t\t\t\tresult=numpy.logical_xor(result,S)\n\t\t\treturn result\n\t\telse:\n\t\t\treturn voxSlice","def cfdGetBoundaryElementsSubArrayForBoundaryPatch(self):\r\n\r\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\r\n \r\n startBElement=self.numberOfElements+self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']-self.numberOfInteriorFaces\r\n endBElement=startBElement+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\r\n \r\n self.cfdBoundaryPatchesArray[iBPatch]['iBElements']=list(range(int(startBElement),int(endBElement)))","def find_rects_white(image: np.ndarray) -> List[np.ndarray]:\n\n raise NotImplementedError()\n\n #gray = norm_color_test(image.copy())\n gray = cv.cvtColor(image.copy(), cv.COLOR_RGB2GRAY)\n gray = cv.GaussianBlur(gray, (5, 5), 0)\n #edged = cv.Canny(gray, 70, 180) # this numbers is hand picked guess from a few photos\n edged = auto_canny(gray) # this numbers is hand picked guess from a few photos\n\n # split to HSV, then pick up rouhly any white color zeroing out the rest\n hsv = cv.cvtColor(image.copy(), cv.COLOR_RGB2HSV)\n h,s,v = cv.split(hsv)\n h[h<145] = 0\n h[h>165] = 0\n #h = cv.GaussianBlur(h, (5, 5), 0)\n normed = cv.normalize(h, None, 0, 255, cv.NORM_MINMAX, cv.CV_8UC1)\n kernel = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(5,5))\n opened = cv.morphologyEx(normed, cv.MORPH_OPEN, kernel)\n\n # now find white regions contours\n whites = cv.findContours(opened, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)[0]\n whites.sort(key=cv.contourArea, reverse=True)\n whites = [cnt for cnt in whites if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\n\n whiterects = []\n for i in whites:\n rect = cv.minAreaRect(i)\n w,h = rect[1]\n if w*h > 150: # 150px area, or rougly 12x12 pixels\n whiterects.append(rect)\n\n #cv.drawContours(image, whites, -1, COLORS[2 % len(COLORS)], 2)\n #cv.imshow('test', image)\n #cv.waitKey()\n\n whites = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), whiterects))\n\n\n\n #cv.imshow('test', edged)\n #cv.waitKey()\n\n contours = cv.findContours(edged.copy(), cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)\n contours = contours[0] if len(contours) == 2 else contours[1]\n contours.sort(key=cv.contourArea, reverse=True)\n contours = [cnt for cnt in contours if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\n\n rects = list(map(cv.minAreaRect, contours))\n boxes = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), rects))\n\n # filter non overlapping contours\n for i in reversed(range(len(boxes))):\n overlaps = False\n for wbox in whites:\n if wbox.overlaps(boxes[i]):\n overlaps = True\n break\n if not overlaps:\n boxes.pop(i)\n\n boxes = Rect.nms_merge(boxes)\n\n for i in range(len(contours)):\n #peri = cv.arcLength(contours[i], True)\n #approx = cv.approxPolyDP(contours[i], 0.02 * peri, True)\n rect = cv.minAreaRect(contours[i])\n box = cv.boxPoints(rect)\n box = np.int0(box)\n #cv.drawContours(image, [box], -1, COLORS[i % len(COLORS)], 2)\n #cv.putText(image, f'{i}: {cv.contourArea(contours[i])}px', (int(rect[0][0]), int(rect[0][1])), cv.FONT_HERSHEY_SIMPLEX, 0.6, COLORS[i % len(COLORS)], 1)\n\n #cv.drawContours(image, contours, -1, COLORS[1], 2)\n\n for b in boxes:\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmax), int(b.ymin)), (0, 255, 255), 2)\n cv.line(image, (int(b.xmin), int(b.ymax)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmin), int(b.ymax)), (0, 255, 255), 2)\n cv.line(image, (int(b.xmax), int(b.ymin)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\n\n stacked = np.hstack( (cv.cvtColor(edged, cv.COLOR_GRAY2RGB), cv.cvtColor(opened, cv.COLOR_GRAY2RGB), image))\n cv.namedWindow('test', 0)\n cv.imshow('test', stacked)\n cv.waitKey()\n\n cv.imwrite('dump.jpg', stacked)\n\n\n return boxes or list()","def track_ball_generic(video):\n result = []\n frames = readFrames(video)\n\n # get background with background estimator method\n background = findBackground(frames)\n # Setup background subtractor object with parameters\n subtractor = cv2.BackgroundSubtractorMOG(30, 10, 0.7, 0)\n # Feed estimated background as first input to subtractor\n subtractor.apply(background)\n\n # Iterate over every frame in video\n i = 0\n while i < len(frames):\n frame = frames[i] # get the new frame\n\n # apply background subtraction to frame\n frame = subtractor.apply(frame)\n\n # find contours in the frame\n contours, _ = cv2.findContours(frame, cv2.RETR_TREE,\n cv2.CHAIN_APPROX_SIMPLE)\n\n # sort the contours in reverse order by width to eliminate small\n # contours caused by noise.\n sort_cnt = sorted(contours, key=lambda x: cv2.boundingRect(x)[2],\n reverse=True)\n\n # get the parameters of the bounding box for the largest width contour\n x, y, w, h = cv2.boundingRect(sort_cnt[0])\n # append to result list\n result.append((x, y, x + w, y + h))\n\n if VISUALIZE:\n orig_frame = frames[i]\n cv2.rectangle(orig_frame, (x, y), (x + w, y + h), (0, 255, 0), 2)\n cv2.imshow('frame', orig_frame)\n cv2.waitKey(30)\n\n i += 1\n\n return result","def get_contour_lims(frame: imageType) -> Tuple[int, int, int, int]:\n largest_contour = get_largest_contour(frame)\n if largest_contour is not None:\n (x, y, w, h) = cv2.boundingRect(largest_contour)\n else:\n (x, y, w, h) = (0, 0, 0, 0)\n return (x, y, w, h)","def contour_ice(dataarray):\n contours = dataarray.plot.contourf(vmin=0, vmax=100, levels=5)\n ice_json = json.loads(contourf_to_geojson(contourf=contours))\n print(ice_json['type'])\n # Remove land polygons\n rm_feats = [f for f in ice_json['features']\n if f['properties']['title'] == '<0.00 ']\n for rm in rm_feats:\n ice_json['features'].remove(rm)\n print([np.array(f['geometry']['coordinates']).shape\n for f in ice_json['features']])\n geodf_ice = gpd.GeoDataFrame.from_features(ice_json)\n return geodf_ice","def extract_features(image):\n\n return maximum_curvature(*preprocess(image), sigma = 3)","def get_bricks(self, contours):\n bricks = []\n for cnt in contours:\n epsilon = 0.04*cv2.arcLength(cnt,True)\n approx = cv2.approxPolyDP(cnt,epsilon,True) \n \n if len(approx) >= 4:\n rect = cv2.minAreaRect(approx)\n area = cv2.contourArea(approx)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n\n if area > 600 and area < 4000:\n\n brick = Brick()\n area = np.int0(area)\n center = np.int0(rect[0])\n angle = np.int0(rect[2])\n\n brick.set_area(area)\n brick.set_center(center)\n brick.set_angle(angle)\n brick.set_box(box)\n\n bricks.append(brick)\n\n # elif len(approx) > 4:\n # (x,y),radius = cv2.minEnclosingCircle(cnt)\n # center = (int(x),int(y))\n # radius = int(radius)\n # area = radius*radius*math.pi\n\n # if area > 600 and area < 2000:\n\n # brick = Brick()\n # area = np.int0(area)\n \n # brick.set_area(area)\n # brick.set_center(center)\n # brick.set_radius(radius)\n\n # bricks.append(brick)\n\n \n \n return bricks","def getContours(img):\n # mode: gets only exrteme outer contours\n # method: stores all contour points\n contours, hierarchy = cv2.findContours(img, mode=cv2.RETR_EXTERNAL,\n method=cv2.CHAIN_APPROX_NONE)\n \n x, y, w, h = 0, 0, 0, 0\n\n # improving accuracy of contours\n for cnt in contours:\n area = cv2.contourArea(cnt)\n if area > 500:\n # assumes cnt with area > 500 is closed contour \n perimeter = cv2.arcLength(cnt, True)\n\n # approximate polygonal curve of cnt\n # set max difference between original and approxCurve as \n # 0.02 * perimeter\n approxCurve = cv2.approxPolyDP(cnt, 0.02 * perimeter, closed=True)\n \n x, y, w, h = cv2.boundingRect(approxCurve)\n # wand point is is center-left tip\n return x + (w // 2), y","def find_objects(img, threshold=.3):\n thresholded_img = np.uint8(img > threshold)\n _, markers = cv2.connectedComponents(thresholded_img)\n object_centers = []\n for ii in range(1, np.max(markers)):\n masked_img = mask_img(img, markers == ii)\n object_index = np.argmax(masked_img)\n object_center = np.unravel_index(object_index, img.shape)\n object_centers.append(object_center)\n return np.array(object_centers)","def get_traffic_lights_obstacles(traffic_lights, depth_frame, segmented_frame,\n town_name):\n camera_transform = depth_frame.camera_setup.get_transform()\n # Iterate over all the traffic lights, and figure out which ones are\n # facing us and are visible in the camera view.\n detected = []\n for light in traffic_lights:\n if not light.is_traffic_light_visible(camera_transform, town_name):\n continue\n detected.extend(\n light.get_all_detected_traffic_light_boxes(\n town_name, depth_frame, segmented_frame.as_numpy_array()))\n return detected","def split_structure_mask(self):\n # If user has specified only 1 curve\n if not self.num_curves:\n contours = cv2.findContours(\n self.comb_structure_mask.astype(np.uint8),\n cv2.RETR_TREE,\n cv2.CHAIN_APPROX_SIMPLE,\n )[0]\n structure_masks = list()\n for contour in contours:\n contour_mask = np.zeros(self.comb_structure_mask.shape, dtype=np.uint8)\n structure_masks.append(\n cv2.fillPoly(contour_mask, pts=[contour], color=(255, 255, 255)).astype(\n np.bool\n )\n )\n return structure_masks\n return [self.comb_structure_mask]","def get_contours_points(found, contours):\n contours_points = []\n for i in found:\n c = contours[i]\n for sublist in c:\n for p in sublist:\n contours_points.append(p)\n return contours_points","def MakePolygonNetworkFromWaterSeg(\n waterArr, minSplit=30, allValsByFrame=None, cVLS=None\n):\n if allValsByFrame is None:\n allValsByFrame = [list(set(w.flat)) for w in waterArr]\n if cVLS is None:\n cVLS = GetContourValuesLengthsAndSubContoursByFrame(waterArr, allValsByFrame)\n allPtsList = []\n allSegsList = []\n for t in range(len(cVLS)):\n contours = [i[2] for i in cVLS[t]]\n nc = len(contours)\n lc = [len(i) for i in contours]\n div = [i // 30 for i in lc]\n sep = [(lc[i] if div[i] == 0 else lc[i] // div[i]) for i in range(nc)]\n # subPtsOld = [ ([] if div[i]==0 else contours[i][ ::(len(contours[i])//div[i]) ] )\n # for i in range(nc) ]\n inds = [\n (\n [0, lc[i] - 1]\n if (lc[i] - 1 < 2 * minSplit)\n else list(range(0, lc[i] - 2, sep[i])) + [lc[i] - 1]\n )\n for i in range(nc)\n ]\n\n subPts = [[tuple(contours[i][j]) for j in inds[i]] for i in range(nc)]\n allPts = sorted(list(set(flatten(subPts))))\n subPtsInds = [[allPts.index(j) for j in i] for i in subPts]\n allSegsInds = flatten([zip(i[:-1], i[1:]) for i in subPtsInds])\n allPtsList.append(allPts)\n allSegsList.append(allSegsInds)\n\n return allPtsList, allSegsList","def extract_patches_tumor(self, bounding_boxes):\n mag_factor = pow(2, self.level_used)\n\n print('No. of ROIs to extract patches from: %d' % len(bounding_boxes))\n\n for i, bounding_box in enumerate(bounding_boxes):\n b_x_start = int(bounding_box[0]) * mag_factor\n b_y_start = int(bounding_box[1]) * mag_factor\n b_x_end = (int(bounding_box[0]) + int(bounding_box[2])) * mag_factor\n b_y_end = (int(bounding_box[1]) + int(bounding_box[3])) * mag_factor\n# X = np.random.random_integers(b_x_start, high=b_x_end, size=500)\n# Y = np.random.random_integers(b_y_start, high=b_y_end, size=500)\n # X = np.arange(b_x_start, b_x_end-256, 5)\n # Y = np.arange(b_y_start, b_y_end-256, 5)\n\n for x in range(b_x_start,b_x_end,PATCH_SIZE):\n for y in range(b_y_start,b_y_end,PATCH_SIZE):\n patch = self.wsi_image.read_region((x, y), 0, (PATCH_SIZE, PATCH_SIZE))\n mask = self.mask_image.read_region((x, y), 0, (PATCH_SIZE, PATCH_SIZE))\n mask_gt = np.array(mask)\n # mask_gt = cv2.cvtColor(mask_gt, cv2.COLOR_BGR2GRAY)\n mask_gt = cv2.cvtColor(mask_gt, cv2.COLOR_BGR2GRAY)\n patch_array = np.array(patch)\n \n white_pixel_cnt_gt = cv2.countNonZero(mask_gt)\n \n if white_pixel_cnt_gt == 0: # mask_gt does not contain tumor area\n patch_hsv = cv2.cvtColor(patch_array, cv2.COLOR_BGR2HSV)\n lower_red = np.array([20, 20, 20])\n upper_red = np.array([200, 200, 200])\n mask_patch = cv2.inRange(patch_hsv, lower_red, upper_red)\n white_pixel_cnt = cv2.countNonZero(mask_patch)\n \n if white_pixel_cnt > ((PATCH_SIZE * PATCH_SIZE) * 0.50):\n # mask = Image.fromarray(mask)\n patch.save(PROCESSED_PATCHES_TUMOR_NEGATIVE_PATH + PATCH_NORMAL_PREFIX+'_'+str(x)+'_'+str(y)+'.jpg', 'JPEG')\n # mask.save(PROCESSED_PATCHES_NORMAL_PATH + PATCH_NORMAL_PREFIX + str(self.patch_index),\n # 'PNG')\n self.negative_patch_index += 1\n else: # mask_gt contains tumor area\n if white_pixel_cnt_gt >= ((PATCH_SIZE * PATCH_SIZE) * 0.85):\n patch.save(PROCESSED_PATCHES_POSITIVE_PATH + PATCH_TUMOR_PREFIX +'_'+str(x)+'_'+str(y)+'.jpg', 'JPEG')\n self.positive_patch_index += 1\n \n patch.close()\n mask.close()","def get_mask_puzzle_pieces_background(background: np.ndarray,\n image: np.ndarray) -> list:\n background = cv.cvtColor(background, cv.COLOR_BGR2GRAY)\n image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\n image_mask = cv.absdiff(background, image)\n image_mask = cv.medianBlur(image_mask, 11)\n ret, image_mask = cv.threshold(image_mask, 20, 255, cv.THRESH_BINARY)\n image_mask = cv.morphologyEx(image_mask,\n cv.MORPH_OPEN,\n (5, 5),\n iterations=3)\n image_mask = cv.filter2D(image_mask, -1, KERNEL_SHARPENING)\n puzzle_pieces, hiearchy = cv.findContours(image_mask,\n cv.RETR_EXTERNAL,\n cv.CHAIN_APPROX_NONE)\n pieces_mask = []\n for piece in range(len(puzzle_pieces)):\n blank = np.zeros((image_mask.shape[0], image_mask.shape[1]))\n single_piece = cv.drawContours(blank, puzzle_pieces, piece, 255,\n cv.FILLED)\n single_piece = cv.cvtColor(single_piece.astype(np.uint8),\n cv.COLOR_GRAY2BGR)\n pieces_mask.append(single_piece)\n return pieces_mask","def find_original_contours(self):\r\n\r\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\r\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\r\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\r\n int(self.cell_size), 5)\r\n self.thresh_orig = 255 - self.thresh_invert\r\n\r\n # Find the contours of the image. Each contour should correspond to a cell\r\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\r\n for block in orig_contours:\r\n area = cv2.contourArea(block)\r\n\r\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\r\n if area < self.min_cell_size:\r\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)","def opencv_watershed(masked, mask) -> JSON_TYPE:\n # For code and detailed explanation see:\n # http://datahacker.rs/007-opencv-projects-image-segmentation-with-watershed-algorithm/\n threshold: int = 30\n gray = cv2.cvtColor(masked, cv2.COLOR_RGB2GRAY)\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\n # Noise removal\n kernel = np.ones((3), np.uint8)\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\n # Noise removal\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\n\n n_increases: int = 0\n while local_max_location.shape[0] < 30 and n_increases < 15:\n threshold += 20\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\n # Noise removal\n kernel = np.ones((3), np.uint8)\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\n # Noise removal\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\n n_increases += 1\n # Reset threshold\n threshold = 30\n\n num_clusters: int = 30\n if n_increases >= 15:\n num_clusters = local_max_location.shape[0]\n kmeans = KMeans(n_clusters=num_clusters)\n # If local_max_location size is 0, return 0 predictions\n if not local_max_location.size:\n return {\n \"count\": 0\n }\n kmeans.fit(local_max_location)\n local_max_location = kmeans.cluster_centers_.copy()\n # Kmeans is returning a float data type so we need to convert it to an int. \n local_max_location = local_max_location.astype(int)\n dist_transform_copy = dist_transform.copy()\n for i in range(local_max_location.shape[0]):\n cv2.circle(dist_transform_copy, (local_max_location[i][1], local_max_location[i][0]), 5, 255)\n # markers = np.zeros_like(dist_transform)\n ret, sure = cv2.threshold(dist_transform, 0.01*dist_transform.max(), 255, 0)\n sure = np.uint8(sure)\n ret, markers = cv2.connectedComponents(sure)\n labels = np.arange(kmeans.n_clusters)\n markers[local_max_location[:,0], local_max_location[:,1]] = labels + 1\n # Convert all local markers to an integer. This because cluster centers will be float numbers. \n markers = markers.astype(int)\n markers_copy = markers.copy()\n index_non_zero_markers = np.argwhere(markers != 0)\n markers_copy = markers_copy.astype(np.uint8)\n font = cv2.FONT_HERSHEY_SIMPLEX\n for i in range(index_non_zero_markers.shape[0]):\n string_text = str(markers[index_non_zero_markers[i][0], index_non_zero_markers[i][1]])\n cv2.putText(markers_copy, string_text, (index_non_zero_markers[i][1], index_non_zero_markers[i][0]), font, 1, 255)\n markers = markers.astype(np.int32)\n segmented = cv2.watershed(masked, markers)\n count_segments(markers)\n #return {\n # \"count\": local_max_location.shape[0]\n #}\n return {\n \"count\": count_segments(markers),\n }","def CV_rectangles(self,XYSP):\n X,Y,S,P = XYSP\n rectangles=[]\n for i in range(3):\n for j in range(3):\n rectangles.append([(X+i*S+i*P,Y+j*S+j*P),\\\n (X+i*S+i*P+S,Y+j*S+j*P+S)])\n return rectangles","def draw_contours(self, image, maskImg):\r\n # Required variables..\r\n x, y, width, height = 0, 0, 0, 0\r\n # Find contours..\r\n contours, hierarchy = cv2.findContours(image=maskImg, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) # Playable Parameters..\r\n # Draw the contours..\r\n for contour in contours:\r\n # Calculate the area of the contour, so can remove unnecessary contours..\r\n area = cv2.contourArea(contour=contour)\r\n if area > 3000: # Playable adjustment..!! Found Good as 3000 for current light condition.. change this if light condition changes..\r\n # Draw the contours to the image -- actual frame..\r\n if self.debug_mode:\r\n cv2.drawContours(image=image, contours=contour, contourIdx=-1, color=(255, 255, 0), thickness=4)\r\n # Find the perimeter of the markers detected...\r\n perimeter = cv2.arcLength(curve=contour, closed=True)\r\n # Approximating/Finding the corners of the image from the obtained corners..\r\n approx_corners = cv2.approxPolyDP(curve=contour, epsilon=0.02 * perimeter, closed=True)\r\n # Find the bounding box rectangle for the approximated corners..\r\n x, y, width, height = cv2.boundingRect(approx_corners)\r\n # Return the values with which a rectangle can be drawn..\r\n return x, y, width, height","def draw_obj(img, video_frame):\n dets = []\n contours, hierarchy = cv.findContours(img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)\n dst = np.zeros(img.shape, dtype=np.uint8)\n if len(contours) > 20000:\n print(len(contours))\n return dets\n for i in range(len(contours)):\n cv.drawContours(dst, contours, i, (255, 0, 0), 1)\n cnt = contours[i]\n area = cv.contourArea(cnt)\n if area <= 60:\n continue\n x, y, w, h = cv.boundingRect(cnt)\n\n if x < 1 and y < 1:\n continue\n cv.rectangle(video_frame, (x, y), (x + w, y + h), (0, 0, 255), 2)\n dets.append([x, y, x + w, y + h, 0.9])\n dets = np.asarray(dets)\n\n cv.imshow('bbox', video_frame)\n\n return dets","def find_targets(contours, frame):\n # If there aren't any contours present, return frame without drawing\n if len(contours) == 0:\n return frame\n # Copy frame, TODO why do we need to do this?\n image = frame.copy()\n screen_height, screen_width, _ = image.shape;\n # TODO: Why subtract?\n center_x = screen_width / 2 - .5\n center_y = screen_height / 2 - .5\n # List for storing found targets\n targets = []\n\n if len(contours) >= 2:\n # Sort contours in descending order by size\n contours.sort(key=lambda contour: cv2.contourArea(contour), reverse=True)\n\n valid_contours = []\n for contour in contours:\n # Calculate areas of contour\n contour_area = cv2.contourArea(contour)\n if contour_area >= MIN_CONTOUR_SIZE:\n # Get moments of contour for centroid calculations\n moments = cv2.moments(contour)\n # Find centroid of contour\n if moments[\"m00\"] != 0:\n cx = int(moments[\"m10\"] / moments[\"m00\"])\n cy = int(moments[\"m01\"] / moments[\"m00\"])\n else:\n cx, cy = 0, 0\n\n ### CALCULATE CONTOUR ROTATION BY FITTING ELLIPSE ###\n rotation = get_ellipse_rotation(image, contour)\n\n ### DRAW CONTOUR ###\n # Draw white circle at center of contour\n cv2.circle(image, (cx, cy), 6, (255, 255, 255))\n\n # Draw contour in green\n cv2.drawContours(image, [contour], 0, (0, 200, 0), 1)\n\n # Append important info to array\n valid_contours.append({\"cx\": cx, \"cy\": cy, \"rotation\": rotation})\n\n # Sort array based on coordinates (left to right) to make sure contours are adjacent\n valid_contours.sort(key=lambda contour: contour[\"cx\"])\n\n # Find targets from contours\n for i in range(len(valid_contours) - 1):\n # Check rotation of adjacent contours\n tilt_left = valid_contours[i][\"rotation\"]\n tilt_right = valid_contours[i + 1][\"rotation\"]\n\n # Contour coordinates\n cx_left = valid_contours[i][\"cx\"]\n cx_right = valid_contours[i + 1][\"cx\"]\n cy_left = valid_contours[i][\"cy\"]\n cy_right = valid_contours[i + 1][\"cy\"]\n\n # If contour angles are opposite\n # Negative tilt -> Rotated to the right\n # NOTE: if using rotated rect (min area rectangle), negative tilt means rotated to left\n # If left contour rotation is tilted to the left then skip iteration\n # If right contour rotation is tilted to the right then skip iteration\n if (len(valid_contours) == 2) or (np.sign(tilt_left) != np.sign(tilt_right) and\n not (tilt_left > 0 and cx_left < cx_right or tilt_right > 0 and cx_right < cx_left)):\n\n target_cx = (cx_left + cx_right) / 2\n target_cy = (cy_left + cy_right) / 2\n\n target_yaw = calculate_yaw(target_cx, center_x)\n target_pitch = calculate_pitch(target_cy, center_y)\n\n targets.append({\"cx\": target_cx,\n \"cy\": target_cy,\n \"yaw\": target_yaw,\n \"pitch\": target_pitch})\n\n # Check if there are targets seen\n if len(targets) > 0:\n # Get target with smallest yaw\n nearest_target = min(targets, key=lambda target: math.fabs(target[\"yaw\"]))\n # Write yaw of target in corner of image\n cv2.putText(image, \"Yaw: %.3f\" % nearest_target[\"yaw\"], (1, 12), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255))\n # Draw line at center of target\n cv2.line(image, (int(nearest_target[\"cx\"]), screen_height), (int(nearest_target[\"cx\"]), 0), (255, 0, 0), 1)\n # Draw line at center of screen\n cv2.line(image, (round(center_x), screen_height), (round(center_x), 0), (255, 255, 255), 1)\n\n # Send our final data to NetworkTables\n table.putBoolean(\"target_present\", True)\n table.putNumber(\"targets_seen\", len(targets))\n table.putNumber(\"target_yaw\", nearest_target[\"yaw\"])\n table.putNumber(\"target_pitch\", nearest_target[\"pitch\"])\n else:\n table.putBoolean(\"target_present\", False)\n table.putNumber(\"targets_seen\", 0)\n table.putNumber(\"target_yaw\", 0)\n table.putNumber(\"target_pitch\", 0)\n table.putNumber(\"target_distance\", 0)\n\n return image","def getTasseledCap(img):\n\t\t\t\n\t\t\tcoefficients = ee.Array([\n\t\t\t\t[0.3037, 0.2793, 0.4743, 0.5585, 0.5082, 0.1863],\n\t\t\t\t[-0.2848, -0.2435, -0.5436, 0.7243, 0.0840, -0.1800],\n\t\t\t\t[0.1509, 0.1973, 0.3279, 0.3406, -0.7112, -0.4572],\n\t\t\t\t[-0.8242, 0.0849, 0.4392, -0.0580, 0.2012, -0.2768],\n\t\t\t\t[-0.3280, 0.0549, 0.1075, 0.1855, -0.4357, 0.8085],\n\t\t\t\t[0.1084, -0.9022, 0.4120, 0.0573, -0.0251, 0.0238]\n\t\t\t]);\n\t\t\n\t\t\tbands=ee.List(['blue','green','red','nir','swir1','swir2'])\n\t\t\t\n\t\t\t# Make an Array Image, with a 1-D Array per pixel.\n\t\t\tarrayImage1D = img.select(bands).toArray()\n\t\t\n\t\t\t# Make an Array Image with a 2-D Array per pixel, 6x1.\n\t\t\tarrayImage2D = arrayImage1D.toArray(1)\n\t\t\n\t\t\tcomponentsImage = ee.Image(coefficients).matrixMultiply(arrayImage2D).arrayProject([0]).arrayFlatten([['brightness', 'greenness', 'wetness', 'fourth', 'fifth', 'sixth']]).float();\n\t \n\t\t\t# Get a multi-band image with TC-named bands.\n\t\t\treturn img.addBands(componentsImage);","def __init__(self):\n\n self.__hsv_threshold_hue = [25.899280575539567, 29.11573068569659]\n self.__hsv_threshold_saturation = [185.74640287769785, 255.0]\n self.__hsv_threshold_value = [137.80585700930783, 255.0]\n\n self.hsv_threshold_output = None\n\n self.__find_contours_input = self.hsv_threshold_output\n self.__find_contours_external_only = False\n\n self.find_contours_output = None\n\n self.__filter_contours_contours = self.find_contours_output\n self.__filter_contours_min_area = 30.0\n self.__filter_contours_min_perimeter = 30.0\n self.__filter_contours_min_width = 0.0\n self.__filter_contours_max_width = 1000.0\n self.__filter_contours_min_height = 0.0\n self.__filter_contours_max_height = 1000.0\n self.__filter_contours_solidity = [0, 100]\n self.__filter_contours_max_vertices = 1000000.0\n self.__filter_contours_min_vertices = 0.0\n self.__filter_contours_min_ratio = 0.0\n self.__filter_contours_max_ratio = 1000.0\n\n self.filter_contours_output = None","def sort_filtered_contours(self):\r\n\r\n # Get the contours again\r\n invert = 255 - self.thresh_invert\r\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\r\n\r\n # Make sure that they're within the correct range for size\r\n # If too small, it is probably noise; if too large, then should be things around the grid\r\n for i, c in enumerate(real_contours, 1):\r\n contour_area = cv2.contourArea(c)\r\n if self.min_cell_size < contour_area < self.max_cell_size:\r\n self.good_contours.append(c)\r\n\r\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\r\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\r\n\r\n # Sort the contours from top to bottom\r\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\"top-to-bottom\")\r\n\r\n # We then sort each row from left to right\r\n row = []\r\n for i, c in enumerate(half_sorted_contours, 1):\r\n row.append(c)\r\n if i % self.board_dimension == 0:\r\n (full_sorted_contours, _) = contours.sort_contours(row, method=\"left-to-right\")\r\n self.game_board_contours.append(full_sorted_contours)\r\n row = []","def findFaces(self):\n\t\trects = self.detectAll()\n\t\tif len(rects)==0:\n\t\t\trects = []\n\t\telse:\n\t\t\trects[:, 2:] += rects[:, :2]\n\t\tself.analyzeFrame(rects)","def extract(integral_channels, feature_stubs):\n\n features = []\n for stub in feature_stubs:\n ch, p_x, p_y, he, wi = stub\n\n ch = integral_channels[ch]\n rect1 = ch.item(p_y, p_x)\n rect2 = ch.item(p_y, p_x+wi)\n rect3 = ch.item(p_y+he, p_x)\n rect4 = ch.item(p_y+he, p_x+wi)\n\n fea = rect4 + rect1 - rect2 - rect3\n features.append(fea)\n\n return features","def analyzeContours(contours):\n if len(contours[0]) != 4 and len(contours[0]) != 8:\n return 0\n\n first, second, prev = [1, 1], [1, 1], 0\n for i, val in enumerate(numpy.nditer(contours[0])):\n if i % 2:\n second = [prev, val]\n else:\n first = [prev, val]\n\n # compare pair to the previous pair\n for num in first:\n if num in second:\n break\n else:\n return 0\n\n prev = val\n\n return 1","def displayContours(self):\n #obsolete?\n profbox()\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\n for modelNode in modelNodes.values():\n if modelNode.GetAttribute(\"contour\") == \"1\":\n needleNode = slicer.mrmlScene.GetNodeByID(modelNode.GetAttribute(\"needleID\"))\n if needleNode != None:\n if needleNode.GetDisplayVisibility()==1:\n modelNode.SetDisplayVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))\n d = modelNode.GetDisplayNode()\n d.SetSliceIntersectionVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))","def analyze(self):\n result = []\n for frame_no, frame in enumerate(self.work.files('frames')):\n areas = self.blur.check_image(frame, self.work.files('templates'))\n for area in areas:\n index = find_area(result, area)\n if index == -1:\n result.append({'area': area, 'frames': [frame_no]})\n else:\n result[index]['frames'].append(frame_no)\n\n for values in result:\n sectors = [[values['frames'][0], values['frames'][0]]]\n for index in range(1, len(values['frames'])):\n if (values['frames'][index] - sectors[-1][1]) == 1:\n sectors[-1][1] = values['frames'][index]\n else:\n sectors.append([values['frames'][index], values['frames'][index]])\n values['sectors'] = sectors\n return result","def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\n\n device += 1\n\n if len(np.shape(img)) == 3:\n iy, ix, iz = np.shape(img)\n else:\n iy, ix, = np.shape(img)\n\n # get the break groups\n\n if nrow == 1:\n rbreaks = [0, iy]\n else:\n rstep = np.rint(iy / nrow)\n rstep1 = np.int(rstep)\n rbreaks = range(0, iy, rstep1)\n if ncol == 1:\n cbreaks = [0, ix]\n else:\n cstep = np.rint(ix / ncol)\n cstep1 = np.int(cstep)\n cbreaks = range(0, ix, cstep1)\n\n # categorize what bin the center of mass of each contour\n\n def digitize(a, step):\n if isinstance(step, int) == True:\n i = step\n else:\n i = len(step)\n for x in range(0, i):\n if x == 0:\n if a >= 0 and a < step[x + 1]:\n return x + 1\n elif a >= step[x - 1] and a < step[x]:\n return x\n elif a > step[x - 1] and a > np.max(step):\n return i\n\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\n coord = []\n for i in range(0, len(roi_objects)):\n m = cv2.moments(roi_objects[i])\n if m['m00'] == 0:\n pass\n else:\n cx = int(m['m10'] / m['m00'])\n cy = int(m['m01'] / m['m00'])\n # colbin = np.digitize(cx, cbreaks)\n # rowbin = np.digitize(cy, rbreaks)\n colbin = digitize(cx, cbreaks)\n rowbin = digitize(cy, rbreaks)\n a = (cx, cy, colbin, rowbin, i)\n coord.append(a)\n coord1 = np.array(coord, dtype=dtype)\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\n\n # get the list of unique coordinates and group the contours with the same bin coordinates\n\n groups = []\n for i, y in enumerate(coord2):\n col = y[3]\n row = y[2]\n location = str(row) + ',' + str(col)\n groups.append(location)\n\n unigroup = np.unique(groups)\n coordgroups = []\n\n for i, y in enumerate(unigroup):\n col = int(y[0])\n row = int(y[2])\n for a, b in enumerate(coord2):\n if b[2] == col and b[3] == row:\n grp = i\n contour = b[4]\n coordgroups.append((grp, contour))\n else:\n pass\n\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\n\n contours = roi_objects\n grouped_contour_indexes = coordlist\n\n # Debug image is rainbow printed contours\n\n if debug == 'print':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n print_image(img_copy, (str(device) + '_clusters.png'))\n\n elif debug == 'plot':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n plot_image(img_copy)\n\n return device, grouped_contour_indexes, contours","def extract_labels_cps(scene: \"Scenemaker\") -> List[Tuple[int, np.ndarray]]:\r\n objects = utils.select_collection(scene.target_collection)\r\n boxes_list = []\r\n\r\n for obj in objects:\r\n objclass = obj.name.split(\".\")[0]\r\n cornermatrix = np.empty((8, 3))\r\n for j, corner in enumerate(obj.bound_box):\r\n cornermatrix[j] = corner\r\n\r\n boxes_list.append((scene.name2num[objclass], cornermatrix))\r\n\r\n return boxes_list"],"string":"[\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def take_contours(self):\\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]\",\n \"def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\\n orderOfSCsByValueByFrame = [\\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\\n ]\\n return scListByFrame, orderOfSCsByValueByFrame\",\n \"def getContours(frame):\\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def get_contours(self):\\n depth_image = capture_images((self.w,self.h))\\n\\n thresh = threshold_depth_image(depth_image, min_depth=config.min_depth, max_depth=config.max_depth, threshold=config.min_depth, kernel=self.kernel)\\n\\n # extract contours\\n im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\\n if hierarchy!=None:\\n hierarchy = hierarchy[0]\\n return contours, hierarchy\\n else:\\n return [], []\",\n \"def getContours(img,iteration):\\n nP, IDrange = upDate(iteration)\\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\\n kernel = np.ones((nP, nP), np.uint8)\\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\\n contours = []\\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n if iteration == 2 :\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n elif iteration == 3:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\n return contours\",\n \"def detect_contours(self):\\r\\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\r\\n return [DbugContour(cv_contour=contour) for contour in contours]\",\n \"def getContours( self,img ):\\n if( len(img.shape) == 3):\\n (_, contours, _) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n (contours,_) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def find_contours(thresh):\\n thresh = thresh.astype(np.uint8)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n\\n # filter outer contours\\n filtered_cont = []\\n for i in range(len(contours)):\\n if hierarchy[0, i, 3] == NO_PARENT:\\n filtered_cont.append(contours[i])\\n\\n return filtered_cont\",\n \"def extractFeatures(bwimage):\\n \\n \\n # circularity\\n img = bwimage.copy()\\n img1, contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n \\n if len(contours)==0:\\n return []\\n B = contours[0]\\n C = B[:,0,0]\\n l = C.size\\n \\n \\n if abs(B[0,0,0] - B[l-1,0,0]) + abs(B[0,0,1] - B[l-1,0,1]) == 2:\\n P8 = math.sqrt(2)\\n else:\\n P8 = 1 \\n for j in range(0,l-1): \\n if abs((B[j+1,0,0] - B[j,0,0])) + abs(B[j+1,0,1] - B[j,0,1]) == 2:\\n P8 = P8 + math.sqrt(2)\\n else:\\n P8 = P8 + 1\\n \\n n = np.count_nonzero(bwimage)\\n \\n circularity = P8*P8/n\\n \\n \\n # elongation\\n idx = np.nonzero(bwimage);\\n c = idx[1]\\n r = idx[0]\\n meanx = np.mean(c)\\n meany = np.mean(r)\\n \\n \\n pows = 2*np.ones(n)\\n \\n sigxx = np.sum(np.power((c-meanx),pows))/n\\n sigyy = np.sum(np.power((r-meany),pows))/n\\n sigxy = np.sum(np.multiply((r-meany),(c-meanx)))/n\\n \\n covMat = np.array([[sigxx, sigxy], [sigxy, sigyy]])\\n val, vects = np.linalg.eig(covMat);\\n \\n maxEigenValue = np.amax(val) \\n minEigenValue = np.amin(val.ravel()[np.flatnonzero(val)])\\n \\n \\n elongation = math.sqrt(maxEigenValue/minEigenValue);\\n \\n \\n # principal axis\\n maxidx = np.argmax(val)\\n principalAxisVector = vects[maxidx]\\n \\n \\n return [circularity, elongation, principalAxisVector]\",\n \"def find_contours(dframe):\\n #Blur the image.\\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\\n #if debug:\\n #plt.imshow(fixColor(blurred))\\n #plt.show()\\n #Get a threshold image, numbers where tested for the given video.\\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \\n cv2.CHAIN_APPROX_SIMPLE)\\n return cnts\",\n \"def __find_contours(input, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def __find_contours(input, external_only):\\r\\n if(external_only):\\r\\n mode = cv2.RETR_EXTERNAL\\r\\n else:\\r\\n mode = cv2.RETR_LIST\\r\\n method = cv2.CHAIN_APPROX_SIMPLE\\r\\n _, contours, hierarchy = cv2.findContours(\\r\\n input, mode=mode, method=method)\\r\\n return contours\",\n \"def __find_contours(input, external_only):\\n if (external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy = cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def __find_contours(input, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n im2, contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def get_contour_features(mask,selectcell=\\\"centered\\\"):\\r\\n \\r\\n #binarize image (everything above 0 becomes 1)\\r\\n mask = np.clip(mask,a_min=0,a_max=1)\\r\\n\\r\\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\\r\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\r\\n contours = list(contours)\\r\\n \\r\\n #in case there is no contour found, add a dummy contour\\r\\n if len(contours)==0:\\r\\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\\r\\n\\r\\n #Sort contours, longest first\\r\\n contours.sort(key=len,reverse=True)\\r\\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\\r\\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\\r\\n\\r\\n mu_origs = [cv2.moments(contour) for contour in contours]\\r\\n mu_hulls = [cv2.moments(hull) for hull in hulls]\\r\\n\\r\\n area_origs = [mu_orig[\\\"m00\\\"] for mu_orig in mu_origs]\\r\\n area_hulls = [mu_hull[\\\"m00\\\"] for mu_hull in mu_hulls]\\r\\n\\r\\n #drop events where area is zero\\r\\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \\r\\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\\r\\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\\r\\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\\r\\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\\r\\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\\r\\n \\r\\n \\r\\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n\\r\\n \\r\\n if selectcell == \\\"smooth\\\":\\r\\n #compute the area ratio (roughness of contour)\\r\\n area_ratio = np.array(area_hulls)/np.array(area_origs)\\r\\n #get the contour with minimum roughness (smooth contour)\\r\\n sorter = np.argsort(area_ratio) #smallest first\\r\\n\\r\\n if selectcell == \\\"centered\\\":\\r\\n #select contour that is closest to the center of the image. \\r\\n #In iPAC, cells are usually in the center.\\r\\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\\r\\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\\r\\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\\r\\n sorter = np.argsort(distances) #smallest first\\r\\n \\r\\n #sort values with respect to chosen metric (area_ratio or distance)\\r\\n contours = [contours[s] for s in sorter]\\r\\n hulls = [hulls[s] for s in sorter]\\r\\n pos_x = [pos_x[s] for s in sorter]\\r\\n pos_y = [pos_y[s] for s in sorter]\\r\\n mu_origs = [mu_origs[s] for s in sorter]\\r\\n area_origs = [area_origs[s] for s in sorter]\\r\\n area_hulls = [area_hulls[s] for s in sorter]\\r\\n \\r\\n # draw mask of the chosen contour\\r\\n mask = np.zeros_like(mask)\\r\\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\\r\\n\\r\\n hull = hulls[0]#[0:n_contours]\\r\\n pos_x = pos_x[0]\\r\\n pos_y = pos_y[0] \\r\\n mu_orig = mu_origs[0]#[0:n_contours]\\r\\n area_orig = area_origs[0]#[0:n_contours]\\r\\n area_hull = area_hulls[0]#[0:n_contours]\\r\\n \\r\\n if area_orig>0:\\r\\n area_ratio = area_hull/area_orig\\r\\n else:\\r\\n area_ratio = np.nan\\r\\n\\r\\n arc = cv2.arcLength(hull, True) \\r\\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\\\"m00\\\"]) / arc\\r\\n\\r\\n\\r\\n dic = {\\\"mask\\\":mask,\\\"pos_x\\\":pos_x,\\\"pos_y\\\":pos_y,\\\"area_orig\\\":area_orig,\\\"area_hull\\\":area_hull,\\\\\\r\\n \\\"area_ratio\\\":area_ratio,\\\"circularity\\\":circularity}\\r\\n return dic\",\n \"def preprocessing(self, img):\\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def fun_contours(self, params):\\n shape_coeffs = params[:self.num_shape_params]\\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\\n\\n vertices3d = self.vertices3d\\n vertices3d_from_mesh = np.zeros_like(vertices3d)\\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\\n\\n inner_idx = 0\\n for idx in range(vertices3d.shape[0]):\\n lm_idx = idx % 66\\n obs_num = int(np.floor(idx/66))\\n\\n if lm_idx in self.contour_lms_list[0]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_right[obs_num])\\n elif lm_idx in self.contour_lms_list[1]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_left[obs_num])\\n else:\\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\\n inner_idx += 1\\n if inner_idx == 50:\\n inner_idx = 0\\n\\n return (vertices3d_from_mesh - vertices3d).ravel()\",\n \"def select_contours(img):\\n # Find contours at a constant value\\n contours = measure.find_contours(img, 300)\\n # print(\\\"Found \\\" + str(len(contours)) + \\\" contour(s)\\\")\\n # Select the nearest contours with respect to the center pixel of the image\\n width = img.shape[1] # number of columms\\n heigth = img.shape[0] # number of rows\\n pixel_ref = (width / 2, heigth / 2)\\n # Threshold distance is 10% of images smallest dimension\\n dist_thresh = min(width, heigth) * 0.1\\n contours_wanted = []\\n pixel_mean_array = []\\n for contour in contours:\\n contour_3d = np.zeros([contour.shape[0], 3]) # 3rd dimension added for later conversion to patient coord space\\n contour_3d[:, :2] = contour\\n pixel_mean = np.mean(contour, axis=0)\\n if distance.euclidean(pixel_ref, pixel_mean) <= dist_thresh:\\n contours_wanted.append(contour_3d)\\n pixel_mean_array.append(pixel_mean)\\n # print(\\\"Set \\\" + str(len(contours_wanted)) + \\\" contours of interest\\\")\\n return contours_wanted, pixel_mean_array\",\n \"def generate_contours(threshold):\\n \\tcnts = cv2.findContours(threshold.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n \\tcnts = imutils.grab_contours(cnts)\\n \\treturn cnts\",\n \"def __find_contours(input1, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy = cv2.findContours(input1, cv2.RETR_TREE, method=method)\\n return contours\",\n \"def find_contours(vertical, horizontal):\\n\\tmask = vertical + horizontal\\n\\n\\ttry:\\n\\t\\t__, contours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\texcept ValueError:\\n\\t\\t# for opencv backward compatibility\\n\\t\\tcontours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\t# sort in reverse based on contour area and use first 10 contours\\n\\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\\n\\n\\tcont = []\\n\\tfor c in contours:\\n\\t\\tc_poly = cv2.approxPolyDP(c, 3, True)\\n\\t\\tx, y, w, h = cv2.boundingRect(c_poly)\\n\\t\\tcont.append((x, y, w, h))\\n\\treturn cont\",\n \"def get_instance_contours(img, contoured, instance):\\n mask = np.zeros(img.shape, dtype=np.uint16)\\n mask[img == instance] = 1\\n ret, threshed = cv.threshold(mask, 0, 2 ** 16, cv.THRESH_BINARY)\\n compressed = threshed.astype(np.uint8)\\n contours, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n cv.drawContours(contoured, contours, -1, (randint(25, 255), randint(25, 255), randint(25, 255)), 3)\\n img2 = contours = hierarchy = mask = None\",\n \"def instance_contours(gti):\\n # TODO: move to somewhere better\\n import cv2\\n\\n rc_locs = np.where(gti > 0)\\n grouped_cc_rcs = util.group_items(\\n np.ascontiguousarray(np.vstack(rc_locs).T),\\n gti[rc_locs], axis=0\\n )\\n\\n def bounding_box(rcs):\\n rc1 = rcs.min(axis=0)\\n rc2 = rcs.max(axis=0)\\n return rc1, rc2\\n\\n # slice out a bounding region around each instance, detect the contour and\\n # then offset it back into image coordinates\\n grouped_contours = {}\\n for label, rcs in grouped_cc_rcs.items():\\n rc1, rc2 = bounding_box(rcs)\\n sl = (slice(rc1[0], rc2[0] + 2), slice(rc1[1], rc2[1] + 2))\\n submask = (gti[sl] == label).astype(np.uint8)\\n\\n xy_offset = rc1[::-1]\\n offset = xy_offset + [-2, -2]\\n\\n border = cv2.copyMakeBorder(submask, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=0 )\\n _, contors, hierarchy = cv2.findContours(border, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE,\\n offset=tuple(offset))\\n \\\"\\\"\\\"\\n offset = [0, 0]\\n BGR_GREEN = (0, 255, 0)\\n x = np.ascontiguousarray(util.ensure_alpha_channel(submask)[:, :, 0:3]).astype(np.uint8)\\n draw_img = cv2.drawContours(\\n image=x, contours=contors,\\n contourIdx=-1, color=BGR_GREEN, thickness=2)\\n \\\"\\\"\\\"\\n # note when len(contours > 1, there is a hole in the building)\\n # assert len(contors) == 1\\n grouped_contours[label] = contors\\n return grouped_contours\",\n \"def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\\n\\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\\n\\n # Since the watershed draws contours, we need to invert the predictions to\\n # get the 'inside' blob portion. We also slightly compress the blob portion\\n # so we can get a more defining border.\\n inverted_contours = 255 - class_contours\\n\\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\\n # remove areas that are not part of the class mask\\n inverted_contours[class_mask==0]= 0 # here ?\\n\\n return inverted_contours\",\n \"def get_contours(image, to_hsv=None, thresh=None, smooth=None, edge=None):\\n if to_hsv is True:\\n image=cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n \\n if thresh is not None:\\n if np.shape(thresh)!=(2, 3):\\n raise TypeError('thresh must be a 2x3 array.')\\n else:\\n mask=cv2.inRange(image, thresh[0, :].astype(int), thresh[1, :].astype(int))\\n\\n if smooth is not None:\\n if 'mask' in locals():\\n mask=cv2.bilateralFilter(np.uint8(mask), smooth[0], smooth[1], smooth[2])\\n else:\\n mask=cv2.bilateralFilter(np.uint8(image), smooth[0], smooth[1], smooth[2])\\n \\n if edge is not None:\\n if 'mask' in locals():\\n mask=cv2.Canny(mask, edge[0], edge[1])\\n else:\\n mask=cv2.Canny(image, edge[0], edge[1])\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) \\n return cnts[0] if imutils.is_cv2() else cnts[1]\",\n \"def get_contours(self,pixel=True):\\n if not self.has_wcs():\\n raise NotImplementedError(\\\"Only WCS contours implemented and this has no wcs solution\\\")\\n \\n if pixel:\\n return self.wcs.contours_pxl\\n return self.wcs.contours\",\n \"def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\\n\\n kernel = np.ones((5, 5), np.float32)\\n\\n # Use a distance transform to find the seed points for watershed\\n tmp = class_mask\\n tmp[tmp>0] = 1 # here\\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\\n dist = (dist / np.max(dist)) * 255.\\n\\n # Since there may be multiple peaks, we use dilation to find them\\n dilate = cv2.dilate(dist, kernel, iterations=3)\\n peaks = np.float32(np.where(dilate == dist, 1, 0))\\n peaks = peaks * class_mask * 255\\n\\n sure_fg = np.where(peaks > 125, 255., 0.)\\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\\n sure_fg = np.uint8(sure_fg)\\n\\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\\n unknown = sure_bg - sure_fg\\n\\n # Add one to all labels so that known background is not 0, but 1\\n _, markers = cv2.connectedComponents(sure_fg)\\n markers = markers + 1\\n\\n markers[unknown == 255] = 0\\n\\n markers = cv2.watershed(self.image, markers)\\n\\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\\n watershed_superpixels[markers == -1] = 255\\n\\n return watershed_superpixels\",\n \"def get_contours(img):\\n contours, hierarchy = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours, hierarchy[0]\",\n \"def find_contours(mask):\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,\\n cv2.CHAIN_APPROX_SIMPLE)\\n cnts = imutils.grab_contours(cnts)\\n return cnts\",\n \"def find_contours(mask):\\n _, contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_KCOS)\\n return contours\",\n \"def cfdGetFaceSfSubArrayForBoundaryPatch(self):\\r\\n\\r\\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\\r\\n \\r\\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\\r\\n \\r\\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\\r\\n \\r\\n iBFaces=list(range(int(startBFace),int(endBFace))) \\r\\n \\r\\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=[self.faceSf[i] for i in iBFaces] \\r\\n \\r\\n self.cfdBoundaryPatchesArray[iBPatch]['facesSf']=np.asarray(self.cfdBoundaryPatchesArray[iBPatch]['facesSf'])\",\n \"def textDetectWatershed(thresh, original):\\n # According to: http://docs.opencv.org/trunk/d3/db4/tutorial_py_watershed.html\\n img = resize(original, 3000)\\n thresh = resize(thresh, 3000)\\n # noise removal\\n kernel = np.ones((3,3),np.uint8)\\n opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 3)\\n \\n # sure background area\\n sure_bg = cv2.dilate(opening,kernel,iterations=3)\\n\\n # Finding sure foreground area\\n dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\\n ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0)\\n\\n # Finding unknown region\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg,sure_fg)\\n \\n # Marker labelling\\n ret, markers = cv2.connectedComponents(sure_fg)\\n\\n # Add one to all labels so that sure background is not 0, but 1\\n markers += 1\\n\\n # Now, mark the region of unknown with zero\\n markers[unknown == 255] = 0\\n \\n markers = cv2.watershed(img, markers)\\n implt(markers, t='Markers')\\n image = img.copy()\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n \\n # Creating result array\\n boxes = []\\n for mark in np.unique(markers):\\n # mark == 0 --> background\\n if mark == 0:\\n continue\\n\\n # Draw it on mask and detect biggest contour\\n mask = np.zeros(gray.shape, dtype=\\\"uint8\\\")\\n mask[markers == mark] = 255\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\\n c = max(cnts, key=cv2.contourArea)\\n \\n # Draw a bounding rectangle if it contains text\\n x,y,w,h = cv2.boundingRect(c)\\n cv2.drawContours(mask, c, 0, (255, 255, 255), cv2.FILLED)\\n maskROI = mask[y:y+h, x:x+w]\\n # Ratio of white pixels to area of bounding rectangle\\n r = cv2.countNonZero(maskROI) / (w * h)\\n \\n # Limits for text\\n if r > 0.1 and 2000 > w > 15 and 1500 > h > 15:\\n boxes += [[x, y, w, h]]\\n \\n # Group intersecting rectangles\\n boxes = group_rectangles(boxes)\\n bounding_boxes = np.array([0,0,0,0])\\n for (x, y, w, h) in boxes:\\n cv2.rectangle(image, (x, y),(x+w,y+h), (0, 255, 0), 8)\\n bounding_boxes = np.vstack((bounding_boxes, np.array([x, y, x+w, y+h])))\\n \\n implt(image)\\n\\n # Recalculate coordinates to original size\\n boxes = bounding_boxes.dot(ratio(original, img.shape[0])).astype(np.int64)\\n return boxes[1:]\",\n \"def detectAll(self):\\n\\t\\trects = self.cascade.detectMultiScale(self.frameImage, 1.3, 4, cv2.cv.CV_HAAR_SCALE_IMAGE, (20,20))\\n\\t\\treturn rects\",\n \"def get_contours(mask, threshold_area):\\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\\n\\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy\",\n \"def get_contours(mask, threshold_area):\\n contours, hierarchy = cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)\\n\\n return [x for x in contours if cv2.contourArea(x) > threshold_area], hierarchy\",\n \"def get_contours(image):\\n assert len(image.shape) == 2, 'Image should be binary'\\n contour_image = image.copy()\\n contour_image[contour_image == 1] = 255\\n _, contours, _ = cv2.findContours(contour_image.astype('uint8'),\\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n return contours\",\n \"def findContours(image):\\n thresh = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\\n cv2.THRESH_BINARY, 11, 2)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def getCV(file1, type, imgOri,iteration):\\n del s_arrays[:]\\n del shapesContours[:]\\n\\n if type == 'shapes':\\n spContours = getContours(imgOri,iteration)\\n file1.write(str(len(spContours)) + '\\\\n')\\n print(len(spContours))\\n spContours = clean_Con(spContours)\\n file1.write(str(len(spContours)) + '\\\\n')\\n print(len(spContours))\\n cv2.drawContours(imgOri, spContours, -1, (0, 255, 128), 5)\\n # del s_arrays[:]\\n # for each shape\\n for cons in spContours:\\n sampleComVector = []\\n x, y, w, h = cv2.boundingRect(cons)\\n cv2.rectangle(imgOri, (x, y), (x + w, y + h), (100, 100, 100), 1)\\n\\n # move the points to center\\n for point in cons:\\n sampleComVector.append(complex(point[0][0] - x, (point[0][1] - y)))\\n # sampleComVectors store CV of all testees contours\\n s_arrays.append(sampleComVector)\\n # sampleContours store all testees contours, same order with sampleComVectors\\n shapesContours.append(cons)\\n\\n elif type == 'temp':\\n # Automatically find templete contour\\n templetTrue = imgOri\\n tpContour = getContours(templetTrue,iteration)\\n for contour in tpContour:\\n x, y, w, h = cv2.boundingRect(contour)\\n #\\n for point in contour:\\n # -x and -y are to make left and upper boundry start from 0\\n t_array.append(complex(point[0][0] - x, (point[0][1] - y)))\",\n \"def watershed(img):\\n\\ttmp = img.copy()\\n\\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\\n\\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\\n\\tkernel = np.ones((3,3), np.uint8)\\n\\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\\n\\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\\n\\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\\n\\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\\n\\tsure_fg = np.uint8(sure_fg)\\n\\tunknown = cv2.subtract(sure_bg, sure_fg)\\n\\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\\n\\tmarkers = markers+1\\n\\tmarkers[unknown==255] = 0\\n\\tmarkers = cv2.watershed(tmp, markers)\\n\\ttmp[markers == -1] = [255,0,0]\\n\\treturn tmp\",\n \"def getMostContour(img,svm,knn,filterArr,digits,wThresh,hThresh):\\r\\n # append the filter to filter array, this approach is used in case of \\r\\n # multiple filter methods would be used.\\r\\n counts = []\\r\\n # iterare through every filter\\r\\n for flt in filterArr:\\r\\n # copy the image so we don't draw on same image\\r\\n flt_img = img.copy()\\r\\n last_img = img.copy()\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh) \\r\\n if not digits:\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh)\\r\\n flt_contour_map = []\\r\\n labels = []\\r\\n for crop,(x,y,w,h),contour in cropNwriteBBs(img,cntfound_fltr):\\r\\n #crop = np.array(crop,dtype='float32')\\r\\n crop = cv2.cvtColor(crop,cv2.COLOR_BGR2GRAY)\\r\\n crop = cv2.resize(crop,(25,25))\\r\\n # winSize is the size of the image cropped to an multiple of the cell size\\r\\n hog_fts = hog.compute(crop)\\\\\\r\\n .reshape(n_cells[1] - block_size[1] + 1,\\r\\n n_cells[0] - block_size[0] + 1,\\r\\n block_size[0], block_size[1], nbins) \\\\\\r\\n .transpose((1, 0, 2, 3, 4))\\r\\n hog_fts = np.resize(hog_fts.flatten(),(1,576))\\r\\n # make the resulted crop same type with the trained values\\r\\n hog_fts.dtype = 'float32'\\r\\n # get predicted labels\\r\\n label_svm=svm.predict(hog_fts)[1]\\r\\n label_knn = knn.findNearest(hog_fts,k=5)[1]\\r\\n # label 10 is considered as 'not digit' or 'thrash'\\r\\n # so if predicted label is not 10, draw the bounding box\\r\\n if digits:\\r\\n if(label_svm!=10 and label_knn != 10 and label_svm!=11 and label_knn != 11):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n else:\\r\\n if(label_svm!=2 and label_knn != 2):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n last_cnt,last_labels = secondElimination(flt_contour_map,labels)\\r\\n for cnt in last_cnt:\\r\\n x,y,w,h = cv2.boundingRect(cnt)\\r\\n cv2.rectangle(flt_img,(x,y),(x+w,y+h),[0,255,0],2)\\r\\n #showWait(flt_img,'fltres')\\r\\n _,xx,res_boxes,_,_ = mergeBoundingBoxes(flt_img,last_cnt,last_labels)\\r\\n cnt = len(res_boxes)\\r\\n counts.append([cnt,flt_img,last_cnt,last_labels])\\r\\n # append resulted image and contours to an array\\r\\n counts = np.asarray(counts)\\r\\n # get the resulted image which contain more digits (bounding boxes)\\r\\n tmp = counts[:,0]\\r\\n resulted_img = counts[np.argmax(tmp),1]\\r\\n result_labels = counts[np.argmax(tmp),3]\\r\\n resulted_contour = counts[np.argmax(tmp),2]\\r\\n return resulted_contour,result_labels,resulted_img\",\n \"def findContours(img, thresh=127, val=255):\\n\\tgray = grayscale(img)\\n\\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\\n\\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\terrorCheckContour(contours)\\n\\treturn sort(contours)\",\n \"def extract_features(self, clip):\\n #sr, clip_array = wav_read(io.BytesIO(clip.data))\\n sr = 16000\\n # clip_decoded = base64.decodestring(clip.data)\\n # clip_array = np.frombuffer(clip_decoded, dtype=np.float16)\\n clip_array = np.array(clip.data)\\n if clip_array.ndim > 1:\\n clip_array = clip_array[:, 0]\\n segments = frame_breaker.get_frames(clip_array, sample_rate=sr)\\n segments_encoded = [self.np2base64(s, sr) for s in segments]\\n segment_features = [\\n [f.feature_value for f in self.extract_feats_for_segment(s).features]\\n for s in segments_encoded\\n ]\\n return segment_features\",\n \"def get_spoof_features2(img):\\n roi = img # img_bgr[y:y+h, x:x+w]\\n\\n img_ycrcb = cv2.cvtColor(roi, cv2.COLOR_BGR2YCR_CB)\\n img_luv = cv2.cvtColor(roi, cv2.COLOR_BGR2LUV)\\n\\n ycrcb_hist = calc_hist(img_ycrcb)\\n luv_hist = calc_hist(img_luv)\\n\\n feature_vector = np.append(ycrcb_hist.ravel(), luv_hist.ravel())\\n feature_vector = feature_vector.reshape(1, len(feature_vector))\\n\\n return feature_vector\",\n \"def find_contours(image):\\n # skimage.measure.find_contours is not only slow but impractical:\\n # - interrupts hull polygon when it intersects the margins (!)\\n # - uses 0.5-based coordinates (i.e. center of pixel instead of top/left)\\n contours, _ = cv2.findContours(image.astype(uint8),\\n cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n # convert to y,x tuples\\n return [(contour[:,0,::-1], cv2.contourArea(contour))\\n for contour in contours]\",\n \"def get_building_contour(current_building_mask):\\n ret, threshed = cv.threshold(current_building_mask, 0, 2 ** 16, cv.THRESH_BINARY)\\n compressed = threshed.astype(np.uint8)\\n current_building_contour, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n return current_building_contour, hierarchy\",\n \"def contours_to_arrays(gdf, col): \\n\\n coords_zvals = []\\n\\n for i in range(0, len(gdf)):\\n\\n val = gdf.iloc[i][col]\\n\\n try:\\n coords = np.concatenate([np.vstack(x.coords.xy).T \\n for x in gdf.iloc[i].geometry])\\n except:\\n coords = np.vstack(gdf.iloc[i].geometry.coords.xy).T\\n\\n coords_zvals.append(np.column_stack((coords, \\n np.full(np.shape(coords)[0], \\n fill_value=val))))\\n\\n return np.concatenate(coords_zvals)\",\n \"def contours(self, image,debug=False):\\n imgray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\\n if debug: cv2.imwrite('debug_pics/gray_scale_contour.jpg',imgray) # cv2.imshow('gray_scale_contour',imgray)\\n im2, contours, hierarchy = cv2.findContours(imgray,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\\n\\n return contours,hierarchy\",\n \"def contour(self) -> np.ndarray:\\n return self.labels\",\n \"def contextualcull(cnts):\\n temp = []\\n actualout = []\\n indicesused = []\\n for cnt in cnts:\\n if cnt.area > CULL_MINIMUMS[cnt.spatialindex]:\\n temp.append(cnt)\\n if cnt.spatialindex not in indicesused:\\n indicesused.append(cnt.spatialindex)\\n if PRIORITIZE_FASTEST:\\n for sindex in indicesused: #filter down to the fastest contour.\\n _allatthisindex = [x for x in temp if x == sindex]\\n highest = _allatthisindex.sort(key=lambda y: y.spd, reverse=False)[0]\\n actualout.append(highest)\\n else:\\n actualout = temp\\n print 'Contours after cull: ', len(actualout)\\n return actualout\",\n \"def readContours(self):\\n if self.image==False:\\n warning = QErrorMessage()\\n warning.setWindowModality(Qt.WindowModal)\\n warning.showMessage('Reading of contours failed. Images must be loaded prior to loading contours')\\n warning.exec_()\\n else:\\n options=QFileDialog.Options()\\n options |= QFileDialog.DontUseNativeDialog\\n fileName, _ = QFileDialog.getOpenFileName(self, \\\"QFileDialog.getOpenFileName()\\\", \\\"\\\", \\\"XML file (*.xml)\\\", options=options)\\n self.lumen, self.plaque, self.stent, self.resolution, frames = read_xml.read(fileName)\\n self.lumen = self.mapToList(self.lumen)\\n self.plaque = self.mapToList(self.plaque)\\n self.stent = self.mapToList(self.stent)\\n self.contours=True\\n self.resizeContours()\\n self.wid.setData(self.lumen, self.plaque, self.images)\\n self.hideBox.setChecked(False)\",\n \"def compute_contour(ptr_array):\\n hull = ConvexHull(ptr_array)\\n contour_index = hull.vertices.tolist() # indices are ordered\\n # contour_index = hull.simplices.flatten()\\n # contour_index = list(set(contour_index))\\n return contour_index\",\n \"def register_cells(contours: List[np.array]) -> np.array:\\n def create_cell(contour: np.array) -> np.array:\\n center, radius = cv2.minEnclosingCircle(contour)\\n v = (0, 0)\\n weight = -1\\n\\n return np.array([center[0], center[1], v[0], v[1], radius, weight])\\n\\n areas = np.array([cv2.contourArea(contour) for contour in contours]).astype(\\\"float32\\\")\\n blobs = np.array([create_cell(contour) for contour in contours]).astype(\\\"int32\\\")\\n\\n return blobs[areas >= 100].astype(\\\"float32\\\")\",\n \"def get_cntr_points(self, contour, img_size):\\n res_arr = []\\n # for each row\\n for row in range(img_size):\\n tmp_arr = []\\n # for each column\\n for col in range(img_size):\\n # if point in contour\\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\\n # add point to current line\\n tmp_arr.append([row,col])\\n if len(tmp_arr):\\n # add current line to result array\\n res_arr.append(tmp_arr)\\n return res_arr\",\n \"def contours(subject, colour='gray'):\\n for row in data.get_contours(subject)['contours']:\\n for col in row:\\n xs = []\\n ys = []\\n for pair in col['arr']:\\n xs.append(pair['x'])\\n ys.append(pair['y'])\\n ys = config['surveys']['atlas']['fits_height'] - numpy.array(ys)\\n matplotlib.pyplot.plot(xs, ys, c=colour)\",\n \"def cfdGetFaceCentroidsSubArrayForBoundaryPatch(self):\\r\\n \\r\\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\\r\\n \\r\\n startBFace=self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']\\r\\n endBFace=startBFace+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\\r\\n iBFaces=list(range(int(startBFace),int(endBFace))) \\r\\n \\r\\n self.cfdBoundaryPatchesArray[iBPatch]['faceCentroids']=[self.faceCentroids[i] for i in iBFaces]\",\n \"def get_boxes(found, contours):\\n boxes = []\\n for i in found:\\n rect = cv2.minAreaRect(contours[i])\\n box = np.int0(cv2.cv.BoxPoints(rect))\\n box = map(tuple, box)\\n boxes.append(box)\\n return boxes\",\n \"def curvature_features(binary_image, step=2, min_prominance=0.1,min_width=5,dist_bwt_peaks=10):\\n r_c=local_radius_curvature(binary_image,step,False)\\n \\n #calculate local curvature features\\n local_curvature=[np.divide(1,r_c[x]) if r_c[x]!=0 else 0 for x in range(len(r_c))]\\n \\n #compute local and global features\\n global_features = [global_curvature_features(np.array(local_curvature))]\\n global_features = pd.DataFrame([o.__dict__ for o in global_features])\\n \\n prominant_features = [prominant_curvature_features(local_curvature,min_prominance=0.1,min_width=5,dist_bwt_peaks=10)]\\n prominant_features = pd.DataFrame([o.__dict__ for o in prominant_features])\\n\\n all_features = pd.concat([global_features.reset_index(drop=True), prominant_features], axis=1)\\n \\n return all_features\",\n \"def draw_contours(self, image_path):\\n img = cv.imread(image_path, cv.IMREAD_ANYDEPTH)\\n contoured = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\\n unique, counts = np.unique(img, return_counts=True)\\n for uni in unique:\\n if uni == 0:\\n continue\\n self.get_instance_contours(img, contoured, uni)\\n\\n cv.namedWindow('building contours', cv.WINDOW_NORMAL)\\n cv.imshow('building contours', contoured)\\n cv.waitKey(0)\\n cv.destroyAllWindows()\",\n \"def splitContours(contours):\\n split_contours = []\\n for contour in contours:\\n c = contour.reshape(-1, 2)\\n line_segments = splitLine(c)\\n for seg in line_segments:\\n # Turn it back to its original shape, so we can add it back to contours\\n new_contour = seg.reshape(-1,1,2)\\n # Dont add empty contours to our new list of contours\\n if new_contour.size != 0:\\n split_contours.append(new_contour)\\n\\n return split_contours\",\n \"def find_rects(image: np.ndarray) -> List[np.ndarray]:\\n\\n gray = cv.cvtColor(image.copy(), cv.COLOR_RGB2GRAY)\\n gray = cv.GaussianBlur(gray, (5, 5), 0)\\n #edged = cv.Canny(gray, 70, 180) # this numbers is hand picked guess from a few photos\\n edged = auto_canny(gray)\\n\\n contours = cv.findContours(edged.copy(), cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)\\n contours = contours[0] if len(contours) == 2 else contours[1]\\n contours.sort(key=cv.contourArea, reverse=True)\\n contours = [cnt for cnt in contours if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\\n\\n rects = list(map(cv.minAreaRect, contours))\\n boxes = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), rects))\\n\\n boxes = Rect.nms_merge(boxes)\\n\\n return boxes or list()\",\n \"def extract_roi(reg_with_roi, ir_with_roi, reg_unmarked, ir_unmarked):\\n roi_pos = np.where( reg_with_roi[:,:,2] == 255 ) \\n \\n x = list(roi_pos[0])\\n y = list(roi_pos[1])\\n \\n #make a 2-d mask\\n \\n mask = np.zeros_like(reg_with_roi[:,:,1])\\n mask[x,y] = 255\\n \\n _, cntrs = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[:2]\\n\\n reg_roi_list = []\\n ir_roi_list = []\\n \\n #masks = []\\n for cnt in cntrs:\\n \\n if reg_unmarked.ndim == 3:\\n reg_unmarked = cv2.cvtColor(reg_unmarked, cv2.COLOR_BGR2GRAY)\\n \\n if ir_unmarked.ndim == 3:\\n ir_unmarked = cv2.cvtColor(ir_unmarked, cv2.COLOR_BGR2GRAY)\\n \\n temp_mask = np.zeros_like(reg_unmarked)\\n cv2.fillPoly(temp_mask, [cnt], (255,255,255))\\n #masks.append(temp_mask)\\n \\n reg_roi = cv2.bitwise_and(temp_mask, reg_unmarked)\\n ir_roi = cv2.bitwise_and(temp_mask, ir_unmarked)\\n \\n x, y, w, h = cv2.boundingRect(cnt)\\n reg_roi = reg_roi[y:y+h, x:x+w]\\n ir_roi = ir_roi[y:y+h, x:x+w]\\n \\n reg_roi_list.append(reg_roi)\\n ir_roi_list.append(ir_roi)\\n \\n return reg_roi_list, ir_roi_list, cntrs\",\n \"def find_contour(ctx: Context):\\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\\n contours, _ = cv2.findContours(ctx.temp_image1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n\\n # take the 5 biggest areas\\n contours = sorted(contours, key=lambda c: math.fabs(cv2.contourArea(c)), reverse=True)[:5]\\n\\n # approximate contours with poly line\\n ctx.contours = [cv2.approxPolyDP(c, 2, True) for c in contours]\",\n \"def calculate_contours_fit(L_x, L_y, e, leaflet, ts, Plots, side):\\n \\n n = np.load(input_dir + 'directors_'+leaflet+'_tail_'+ str(ts) + '.npy') \\n\\n pos = np.load(input_dir + 'coordinates_'+leaflet+'_tail_' + str(ts) + '.npy') \\n\\n resid = np.load(input_dir + 'residues_'+leaflet+'_tail_' + str(ts) + '.npy')\\n box = np.load(input_dir + 'box' + str(ts) + '.npy')\\n\\n \\n chl = np.load(input_dir + 'cholesterol_'+leaflet+'_tail_' + str(ts) + '.npy')\\n dlipc = np.load(input_dir + 'dlipc_'+leaflet+'_tail_' + str(ts) + '.npy') \\n dspc = np.load(input_dir + 'dspc_'+leaflet+'_tail_' + str(ts) + '.npy')\\n ssm = np.load(input_dir + 'ssm_'+leaflet+'_tail_' + str(ts) + '.npy')\\n \\n #n= np.ones(len(pos))\\n \\\"\\\"\\\" END: read the input data \\\"\\\"\\\"\\n\\n\\n field = order_vector_field(L_x, L_y, pos, n, e, box)\\n\\n c = pd.DataFrame(data=field).mean(axis=0).rolling(50, center=True, min_periods=1).mean() #50\\n c.dropna(inplace=True)\\n middle = 0.5*(np.max(c) + np.min(c)) \\n #middle = 0.025\\n contours = measure.find_contours(field, middle) # Marching Cubes algorith\\n #save contours\\n fac_x = box[0] / L_x #to get the right dimensions (range_x)\\n fac_y = box[1] / L_y # (range_y)\\n \\n contours_x = []\\n contours_y = []\\n contours_x_y = []\\n \\n contours_all = []\\n for m, contour in enumerate(contours):\\n contours_x.append((contour[:, 1] * fac_x))\\n contours_y.append((contour[:, 0] * fac_y))\\n \\n \\n contours_x_y = np.column_stack((contours_x[m], contours_y[m]))\\n contours_all.append(contours_x_y)\\n np.save(output_contours + 'contours_'+leaflet+'.' + str(ts) + '.npy', contours_all)\\n \\n\\n#===================================================\\n#To assign resids to the different phases\\n phase_belonging = np.zeros((len(pos)))\\n ordered =[]\\n disordered = []\\n for i in np.arange(len(pos)):\\n \\n def apply_pbc(pos, box):\\n if pos >= box:\\n pos -= box\\n if pos < 0:\\n pos += box\\n return pos\\n \\n idx_x = int(apply_pbc(pos[i,0], box[0]) / fac_x - 1.e-5) #the - 1.e-5 is because accuracy issue in the /\\n idx_y = int(apply_pbc(pos[i,1], box[1]) / fac_y - 1.e-5) #this - 1.e-5 is because accuracy issue in the /\\n #print(idx_x, idx_y)\\n order= field[idx_y, idx_x]\\n if (order > middle):\\n ordered.append(order)\\n order = 1 #ordered lipids\\n \\n else :\\n disordered.append(order)\\n order =0 #disordered lipids\\n phase_belonging[i] = order\\n \\n\\n resid_phases = np.column_stack((resid[:,0], phase_belonging))\\n np.save(output_dir + 'resid_phases'+leaflet+'.'+ str(j) + '.npy', resid_phases)\\n\\n if Plots == True:\\n plt.figure(figsize=(15,10)) \\n \\n contours_sorted = sorted(contours, key=len, reverse=True)\\n \\n for i in range(2):\\n plt.plot(contours_sorted[i][:,1]* fac_x+0.5*fac_x, contours_sorted[i][:,0]* fac_y+0.5*fac_y, linewidth=3, color='#0000FF' ) ##00CC00\\n \\n #for m, contour in enumerate(contours_sorted):\\n # print(contour[:,0])\\n # for contour in contours: \\n \\n # plt.plot((contour[:, 1] * fac_x+0.5*fac_x),\\n # (contour[:, 0] * fac_y+0.5*fac_y),\\n # linewidth=4, color='#00CC00')\\n \\n plt.imshow(field, interpolation='nearest', \\n cmap=plt.cm.gray_r,\\n extent=[0, box[0], 0, box[1]], origin='lower', alpha=0.7) \\n \\n plt.axis('off')\\n plot_scatter_order_field(pos, resid, dlipc, dspc, chl,ssm, n , box, ts, side) #phase_belonging.reshape(-1,1)\\n plt.savefig(output_dir + 'contours-'+ leaflet + str(ts) + '.png', dpi=300) \\n plt.close() \\n \\n return resid_phases #, ordered, disordered \",\n \"def contours_and_data(epoch, model, features, filters, figname, fgal=0.5,\\n idx=-1, data='s82', N=60000):\\n if data == 's82':\\n # fetch Stripe 82 data\\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\\n filters, use_single=False)\\n sind = np.abs(Xcoadd[:, idx]) < 0.03\\n gind = np.abs(Xcoadd[:, idx]) > 0.03\\n\\n else:\\n # fetch DR10 data\\n X, Xcov = fetch_prepped_dr10data(N, fgal, features, filters)\\n sind = np.abs(X[:, idx]) < 0.145\\n gind = np.abs(X[:, idx]) > 0.145\\n\\n # unpickle the XD model\\n if type(model) == str: \\n f = open(model, 'rb')\\n model = cPickle.load(f)\\n f.close()\\n\\n fs = 5\\n ms = 1\\n lsize = 20\\n idx = [[0, -1], [2, 3], [3, 4]]\\n xlim = [(18., 22), (-0.5, 2.5), (-0.5, 2)]\\n ylim = [(-0.1, 0.5), (-0.5, 2.5), (-0.5, 1.5)]\\n xlab = ['psfmag $r$', 'modelmag $g-r$', 'modelmag $r-i$']\\n ylab = ['psfmag - modelmag $r$', 'modelmag $r-i$', 'modelmag $i-z$']\\n\\n f = pl.figure(figsize=(3 * fs, 3 * fs))\\n Nstar = len(np.where(model.fixed_means[:, idx] != np.inf)[0])\\n pl.subplots_adjust(wspace=0.3)\\n for i in range(1, 10):\\n k = (i - 1) % 3\\n if i < 4:\\n ind = np.arange(X.shape[0], dtype=np.int)\\n rng = range(model.n_components)\\n elif 3 < i < 7:\\n ind = sind\\n rng = range(Nstar)\\n else:\\n ind = gind\\n rng = range(Nstar, model.n_components)\\n ax = pl.subplot(3, 3, i)\\n for j in rng:\\n if model.alpha[j] > 1.e-3:\\n draw_ellipse(model.mu[j, idx[k]],\\n model.V[j, idx[k]][:, idx[k]],\\n scales=[2], ec='k', fc='gray', alpha=0.2)\\n pl.plot(X[ind][::10, idx[k][0]],\\n X[ind][::10, idx[k][1]], '.k',ms=ms)\\n pl.xlim(xlim[k])\\n pl.ylim(ylim[k])\\n pl.xlabel(xlab[k], fontsize=lsize)\\n pl.ylabel(ylab[k], fontsize=lsize)\\n if ('psf' in ylab[k]) & ('model' in ylab[k]):\\n ytick = ['%0.1f' % v for v in np.linspace(-.1, 0.4, 6)]\\n ytick[0] = ''\\n ax.set_yticklabels(ytick)\\n if i == 1:\\n s = 'All'\\n elif i == 3:\\n s = '\\\"Stars\\\"'\\n else:\\n s = '\\\"Galaxies\\\"'\\n ax.text(-.3, 0.5, s, ha='center', va='center', fontsize=25,\\n rotation='vertical', transform=ax.transAxes)\\n f.savefig(figname, bbox_inches='tight')\",\n \"def GetXYListAndPolyListFromCVLS(cVLS, allValsByFrame, orderOfSCsByValueByFrame):\\n numFrames = len(cVLS)\\n xyList = [\\n sorted(list(set(tuple(pt) for c in cvlsByVal for pt in c[2])))\\n for cvlsByVal in cVLS\\n ]\\n polyList = []\\n\\n for t in range(numFrames):\\n polyList.append({})\\n for v in allValsByFrame[t]:\\n subContours = [\\n (cVLS[t][-index][2][::-1] if index < 0 else cVLS[t][index][2])\\n for index in orderOfSCsByValueByFrame[t][v]\\n ] # reconstruct the sc's, flipping if index is negative\\n polyList[-1][v] = [\\n xyList[t].index(totuple(pt)) for sc in subContours for pt in sc[:-1]\\n ]\\n polyList[-1][v] = polyList[-1][v] + [\\n polyList[-1][v][0]\\n ] # Tack on the first point at the end to close the loop\\n # VFMin doesn't like this format; make sure to remove this last point before saving to a file or passing to VFM...\\n # polyList[-1][v] = removeDuplicates(polyList[-1][v])+[polyList[-1][v][0]] # Remove interior duplication...\\n return xyList, polyList\",\n \"def getContours(image, copyImage):\\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n for contour in contours:\\n area = cv.contourArea(contour)\\n \\n if area > 500.0:\\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\\n perimeter = cv.arcLength(contour, True)\\n \\n # Approximates to the nearest polygon\\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\\n objectCoordinates = len(approx)\\n\\n # Returns the x, y and height width of the polygon\\n x, y, w, h = cv.boundingRect(approx)\\n\\n if objectCoordinates == 3:\\n objectShape = \\\"Triangle\\\"\\n elif objectCoordinates == 4:\\n ratio = w / float(h)\\n if ratio >= 0.95 and ratio <= 1.05:\\n objectShape = \\\"Square\\\"\\n else: objectShape = \\\"Rectangle\\\"\\n else: objectShape = \\\"Circle\\\" \\n\\n \\n\\n # Draw rectangles around the images\\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))\",\n \"def voxelize_contours(self, contours,res,llc,voxSlice, direction):\\n\\t\\t# generate each voxel slice\\n\\t\\tvslices=[self.voxelize_single_contour(contour,res,llc,voxSlice, direction) for contour in contours]\\n\\t\\tif len(vslices)>0:\\n\\t\\t\\tresult=vslices.pop(0)\\n\\t\\t\\tfor S in vslices:\\n\\t\\t\\t\\tresult=numpy.logical_xor(result,S)\\n\\t\\t\\treturn result\\n\\t\\telse:\\n\\t\\t\\treturn voxSlice\",\n \"def cfdGetBoundaryElementsSubArrayForBoundaryPatch(self):\\r\\n\\r\\n for iBPatch, theBCInfo in self.cfdBoundaryPatchesArray.items():\\r\\n \\r\\n startBElement=self.numberOfElements+self.cfdBoundaryPatchesArray[iBPatch]['startFaceIndex']-self.numberOfInteriorFaces\\r\\n endBElement=startBElement+self.cfdBoundaryPatchesArray[iBPatch]['numberOfBFaces']\\r\\n \\r\\n self.cfdBoundaryPatchesArray[iBPatch]['iBElements']=list(range(int(startBElement),int(endBElement)))\",\n \"def find_rects_white(image: np.ndarray) -> List[np.ndarray]:\\n\\n raise NotImplementedError()\\n\\n #gray = norm_color_test(image.copy())\\n gray = cv.cvtColor(image.copy(), cv.COLOR_RGB2GRAY)\\n gray = cv.GaussianBlur(gray, (5, 5), 0)\\n #edged = cv.Canny(gray, 70, 180) # this numbers is hand picked guess from a few photos\\n edged = auto_canny(gray) # this numbers is hand picked guess from a few photos\\n\\n # split to HSV, then pick up rouhly any white color zeroing out the rest\\n hsv = cv.cvtColor(image.copy(), cv.COLOR_RGB2HSV)\\n h,s,v = cv.split(hsv)\\n h[h<145] = 0\\n h[h>165] = 0\\n #h = cv.GaussianBlur(h, (5, 5), 0)\\n normed = cv.normalize(h, None, 0, 255, cv.NORM_MINMAX, cv.CV_8UC1)\\n kernel = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(5,5))\\n opened = cv.morphologyEx(normed, cv.MORPH_OPEN, kernel)\\n\\n # now find white regions contours\\n whites = cv.findContours(opened, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)[0]\\n whites.sort(key=cv.contourArea, reverse=True)\\n whites = [cnt for cnt in whites if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\\n\\n whiterects = []\\n for i in whites:\\n rect = cv.minAreaRect(i)\\n w,h = rect[1]\\n if w*h > 150: # 150px area, or rougly 12x12 pixels\\n whiterects.append(rect)\\n\\n #cv.drawContours(image, whites, -1, COLORS[2 % len(COLORS)], 2)\\n #cv.imshow('test', image)\\n #cv.waitKey()\\n\\n whites = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), whiterects))\\n\\n\\n\\n #cv.imshow('test', edged)\\n #cv.waitKey()\\n\\n contours = cv.findContours(edged.copy(), cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)\\n contours = contours[0] if len(contours) == 2 else contours[1]\\n contours.sort(key=cv.contourArea, reverse=True)\\n contours = [cnt for cnt in contours if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\\n\\n rects = list(map(cv.minAreaRect, contours))\\n boxes = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), rects))\\n\\n # filter non overlapping contours\\n for i in reversed(range(len(boxes))):\\n overlaps = False\\n for wbox in whites:\\n if wbox.overlaps(boxes[i]):\\n overlaps = True\\n break\\n if not overlaps:\\n boxes.pop(i)\\n\\n boxes = Rect.nms_merge(boxes)\\n\\n for i in range(len(contours)):\\n #peri = cv.arcLength(contours[i], True)\\n #approx = cv.approxPolyDP(contours[i], 0.02 * peri, True)\\n rect = cv.minAreaRect(contours[i])\\n box = cv.boxPoints(rect)\\n box = np.int0(box)\\n #cv.drawContours(image, [box], -1, COLORS[i % len(COLORS)], 2)\\n #cv.putText(image, f'{i}: {cv.contourArea(contours[i])}px', (int(rect[0][0]), int(rect[0][1])), cv.FONT_HERSHEY_SIMPLEX, 0.6, COLORS[i % len(COLORS)], 1)\\n\\n #cv.drawContours(image, contours, -1, COLORS[1], 2)\\n\\n for b in boxes:\\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmax), int(b.ymin)), (0, 255, 255), 2)\\n cv.line(image, (int(b.xmin), int(b.ymax)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmin), int(b.ymax)), (0, 255, 255), 2)\\n cv.line(image, (int(b.xmax), int(b.ymin)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\\n\\n stacked = np.hstack( (cv.cvtColor(edged, cv.COLOR_GRAY2RGB), cv.cvtColor(opened, cv.COLOR_GRAY2RGB), image))\\n cv.namedWindow('test', 0)\\n cv.imshow('test', stacked)\\n cv.waitKey()\\n\\n cv.imwrite('dump.jpg', stacked)\\n\\n\\n return boxes or list()\",\n \"def track_ball_generic(video):\\n result = []\\n frames = readFrames(video)\\n\\n # get background with background estimator method\\n background = findBackground(frames)\\n # Setup background subtractor object with parameters\\n subtractor = cv2.BackgroundSubtractorMOG(30, 10, 0.7, 0)\\n # Feed estimated background as first input to subtractor\\n subtractor.apply(background)\\n\\n # Iterate over every frame in video\\n i = 0\\n while i < len(frames):\\n frame = frames[i] # get the new frame\\n\\n # apply background subtraction to frame\\n frame = subtractor.apply(frame)\\n\\n # find contours in the frame\\n contours, _ = cv2.findContours(frame, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE)\\n\\n # sort the contours in reverse order by width to eliminate small\\n # contours caused by noise.\\n sort_cnt = sorted(contours, key=lambda x: cv2.boundingRect(x)[2],\\n reverse=True)\\n\\n # get the parameters of the bounding box for the largest width contour\\n x, y, w, h = cv2.boundingRect(sort_cnt[0])\\n # append to result list\\n result.append((x, y, x + w, y + h))\\n\\n if VISUALIZE:\\n orig_frame = frames[i]\\n cv2.rectangle(orig_frame, (x, y), (x + w, y + h), (0, 255, 0), 2)\\n cv2.imshow('frame', orig_frame)\\n cv2.waitKey(30)\\n\\n i += 1\\n\\n return result\",\n \"def get_contour_lims(frame: imageType) -> Tuple[int, int, int, int]:\\n largest_contour = get_largest_contour(frame)\\n if largest_contour is not None:\\n (x, y, w, h) = cv2.boundingRect(largest_contour)\\n else:\\n (x, y, w, h) = (0, 0, 0, 0)\\n return (x, y, w, h)\",\n \"def contour_ice(dataarray):\\n contours = dataarray.plot.contourf(vmin=0, vmax=100, levels=5)\\n ice_json = json.loads(contourf_to_geojson(contourf=contours))\\n print(ice_json['type'])\\n # Remove land polygons\\n rm_feats = [f for f in ice_json['features']\\n if f['properties']['title'] == '<0.00 ']\\n for rm in rm_feats:\\n ice_json['features'].remove(rm)\\n print([np.array(f['geometry']['coordinates']).shape\\n for f in ice_json['features']])\\n geodf_ice = gpd.GeoDataFrame.from_features(ice_json)\\n return geodf_ice\",\n \"def extract_features(image):\\n\\n return maximum_curvature(*preprocess(image), sigma = 3)\",\n \"def get_bricks(self, contours):\\n bricks = []\\n for cnt in contours:\\n epsilon = 0.04*cv2.arcLength(cnt,True)\\n approx = cv2.approxPolyDP(cnt,epsilon,True) \\n \\n if len(approx) >= 4:\\n rect = cv2.minAreaRect(approx)\\n area = cv2.contourArea(approx)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n\\n if area > 600 and area < 4000:\\n\\n brick = Brick()\\n area = np.int0(area)\\n center = np.int0(rect[0])\\n angle = np.int0(rect[2])\\n\\n brick.set_area(area)\\n brick.set_center(center)\\n brick.set_angle(angle)\\n brick.set_box(box)\\n\\n bricks.append(brick)\\n\\n # elif len(approx) > 4:\\n # (x,y),radius = cv2.minEnclosingCircle(cnt)\\n # center = (int(x),int(y))\\n # radius = int(radius)\\n # area = radius*radius*math.pi\\n\\n # if area > 600 and area < 2000:\\n\\n # brick = Brick()\\n # area = np.int0(area)\\n \\n # brick.set_area(area)\\n # brick.set_center(center)\\n # brick.set_radius(radius)\\n\\n # bricks.append(brick)\\n\\n \\n \\n return bricks\",\n \"def getContours(img):\\n # mode: gets only exrteme outer contours\\n # method: stores all contour points\\n contours, hierarchy = cv2.findContours(img, mode=cv2.RETR_EXTERNAL,\\n method=cv2.CHAIN_APPROX_NONE)\\n \\n x, y, w, h = 0, 0, 0, 0\\n\\n # improving accuracy of contours\\n for cnt in contours:\\n area = cv2.contourArea(cnt)\\n if area > 500:\\n # assumes cnt with area > 500 is closed contour \\n perimeter = cv2.arcLength(cnt, True)\\n\\n # approximate polygonal curve of cnt\\n # set max difference between original and approxCurve as \\n # 0.02 * perimeter\\n approxCurve = cv2.approxPolyDP(cnt, 0.02 * perimeter, closed=True)\\n \\n x, y, w, h = cv2.boundingRect(approxCurve)\\n # wand point is is center-left tip\\n return x + (w // 2), y\",\n \"def find_objects(img, threshold=.3):\\n thresholded_img = np.uint8(img > threshold)\\n _, markers = cv2.connectedComponents(thresholded_img)\\n object_centers = []\\n for ii in range(1, np.max(markers)):\\n masked_img = mask_img(img, markers == ii)\\n object_index = np.argmax(masked_img)\\n object_center = np.unravel_index(object_index, img.shape)\\n object_centers.append(object_center)\\n return np.array(object_centers)\",\n \"def get_traffic_lights_obstacles(traffic_lights, depth_frame, segmented_frame,\\n town_name):\\n camera_transform = depth_frame.camera_setup.get_transform()\\n # Iterate over all the traffic lights, and figure out which ones are\\n # facing us and are visible in the camera view.\\n detected = []\\n for light in traffic_lights:\\n if not light.is_traffic_light_visible(camera_transform, town_name):\\n continue\\n detected.extend(\\n light.get_all_detected_traffic_light_boxes(\\n town_name, depth_frame, segmented_frame.as_numpy_array()))\\n return detected\",\n \"def split_structure_mask(self):\\n # If user has specified only 1 curve\\n if not self.num_curves:\\n contours = cv2.findContours(\\n self.comb_structure_mask.astype(np.uint8),\\n cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE,\\n )[0]\\n structure_masks = list()\\n for contour in contours:\\n contour_mask = np.zeros(self.comb_structure_mask.shape, dtype=np.uint8)\\n structure_masks.append(\\n cv2.fillPoly(contour_mask, pts=[contour], color=(255, 255, 255)).astype(\\n np.bool\\n )\\n )\\n return structure_masks\\n return [self.comb_structure_mask]\",\n \"def get_contours_points(found, contours):\\n contours_points = []\\n for i in found:\\n c = contours[i]\\n for sublist in c:\\n for p in sublist:\\n contours_points.append(p)\\n return contours_points\",\n \"def MakePolygonNetworkFromWaterSeg(\\n waterArr, minSplit=30, allValsByFrame=None, cVLS=None\\n):\\n if allValsByFrame is None:\\n allValsByFrame = [list(set(w.flat)) for w in waterArr]\\n if cVLS is None:\\n cVLS = GetContourValuesLengthsAndSubContoursByFrame(waterArr, allValsByFrame)\\n allPtsList = []\\n allSegsList = []\\n for t in range(len(cVLS)):\\n contours = [i[2] for i in cVLS[t]]\\n nc = len(contours)\\n lc = [len(i) for i in contours]\\n div = [i // 30 for i in lc]\\n sep = [(lc[i] if div[i] == 0 else lc[i] // div[i]) for i in range(nc)]\\n # subPtsOld = [ ([] if div[i]==0 else contours[i][ ::(len(contours[i])//div[i]) ] )\\n # for i in range(nc) ]\\n inds = [\\n (\\n [0, lc[i] - 1]\\n if (lc[i] - 1 < 2 * minSplit)\\n else list(range(0, lc[i] - 2, sep[i])) + [lc[i] - 1]\\n )\\n for i in range(nc)\\n ]\\n\\n subPts = [[tuple(contours[i][j]) for j in inds[i]] for i in range(nc)]\\n allPts = sorted(list(set(flatten(subPts))))\\n subPtsInds = [[allPts.index(j) for j in i] for i in subPts]\\n allSegsInds = flatten([zip(i[:-1], i[1:]) for i in subPtsInds])\\n allPtsList.append(allPts)\\n allSegsList.append(allSegsInds)\\n\\n return allPtsList, allSegsList\",\n \"def extract_patches_tumor(self, bounding_boxes):\\n mag_factor = pow(2, self.level_used)\\n\\n print('No. of ROIs to extract patches from: %d' % len(bounding_boxes))\\n\\n for i, bounding_box in enumerate(bounding_boxes):\\n b_x_start = int(bounding_box[0]) * mag_factor\\n b_y_start = int(bounding_box[1]) * mag_factor\\n b_x_end = (int(bounding_box[0]) + int(bounding_box[2])) * mag_factor\\n b_y_end = (int(bounding_box[1]) + int(bounding_box[3])) * mag_factor\\n# X = np.random.random_integers(b_x_start, high=b_x_end, size=500)\\n# Y = np.random.random_integers(b_y_start, high=b_y_end, size=500)\\n # X = np.arange(b_x_start, b_x_end-256, 5)\\n # Y = np.arange(b_y_start, b_y_end-256, 5)\\n\\n for x in range(b_x_start,b_x_end,PATCH_SIZE):\\n for y in range(b_y_start,b_y_end,PATCH_SIZE):\\n patch = self.wsi_image.read_region((x, y), 0, (PATCH_SIZE, PATCH_SIZE))\\n mask = self.mask_image.read_region((x, y), 0, (PATCH_SIZE, PATCH_SIZE))\\n mask_gt = np.array(mask)\\n # mask_gt = cv2.cvtColor(mask_gt, cv2.COLOR_BGR2GRAY)\\n mask_gt = cv2.cvtColor(mask_gt, cv2.COLOR_BGR2GRAY)\\n patch_array = np.array(patch)\\n \\n white_pixel_cnt_gt = cv2.countNonZero(mask_gt)\\n \\n if white_pixel_cnt_gt == 0: # mask_gt does not contain tumor area\\n patch_hsv = cv2.cvtColor(patch_array, cv2.COLOR_BGR2HSV)\\n lower_red = np.array([20, 20, 20])\\n upper_red = np.array([200, 200, 200])\\n mask_patch = cv2.inRange(patch_hsv, lower_red, upper_red)\\n white_pixel_cnt = cv2.countNonZero(mask_patch)\\n \\n if white_pixel_cnt > ((PATCH_SIZE * PATCH_SIZE) * 0.50):\\n # mask = Image.fromarray(mask)\\n patch.save(PROCESSED_PATCHES_TUMOR_NEGATIVE_PATH + PATCH_NORMAL_PREFIX+'_'+str(x)+'_'+str(y)+'.jpg', 'JPEG')\\n # mask.save(PROCESSED_PATCHES_NORMAL_PATH + PATCH_NORMAL_PREFIX + str(self.patch_index),\\n # 'PNG')\\n self.negative_patch_index += 1\\n else: # mask_gt contains tumor area\\n if white_pixel_cnt_gt >= ((PATCH_SIZE * PATCH_SIZE) * 0.85):\\n patch.save(PROCESSED_PATCHES_POSITIVE_PATH + PATCH_TUMOR_PREFIX +'_'+str(x)+'_'+str(y)+'.jpg', 'JPEG')\\n self.positive_patch_index += 1\\n \\n patch.close()\\n mask.close()\",\n \"def get_mask_puzzle_pieces_background(background: np.ndarray,\\n image: np.ndarray) -> list:\\n background = cv.cvtColor(background, cv.COLOR_BGR2GRAY)\\n image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\\n image_mask = cv.absdiff(background, image)\\n image_mask = cv.medianBlur(image_mask, 11)\\n ret, image_mask = cv.threshold(image_mask, 20, 255, cv.THRESH_BINARY)\\n image_mask = cv.morphologyEx(image_mask,\\n cv.MORPH_OPEN,\\n (5, 5),\\n iterations=3)\\n image_mask = cv.filter2D(image_mask, -1, KERNEL_SHARPENING)\\n puzzle_pieces, hiearchy = cv.findContours(image_mask,\\n cv.RETR_EXTERNAL,\\n cv.CHAIN_APPROX_NONE)\\n pieces_mask = []\\n for piece in range(len(puzzle_pieces)):\\n blank = np.zeros((image_mask.shape[0], image_mask.shape[1]))\\n single_piece = cv.drawContours(blank, puzzle_pieces, piece, 255,\\n cv.FILLED)\\n single_piece = cv.cvtColor(single_piece.astype(np.uint8),\\n cv.COLOR_GRAY2BGR)\\n pieces_mask.append(single_piece)\\n return pieces_mask\",\n \"def find_original_contours(self):\\r\\n\\r\\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\\r\\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\\r\\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\\r\\n int(self.cell_size), 5)\\r\\n self.thresh_orig = 255 - self.thresh_invert\\r\\n\\r\\n # Find the contours of the image. Each contour should correspond to a cell\\r\\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\\r\\n for block in orig_contours:\\r\\n area = cv2.contourArea(block)\\r\\n\\r\\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\\r\\n if area < self.min_cell_size:\\r\\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)\",\n \"def opencv_watershed(masked, mask) -> JSON_TYPE:\\n # For code and detailed explanation see:\\n # http://datahacker.rs/007-opencv-projects-image-segmentation-with-watershed-algorithm/\\n threshold: int = 30\\n gray = cv2.cvtColor(masked, cv2.COLOR_RGB2GRAY)\\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\\n # Noise removal\\n kernel = np.ones((3), np.uint8)\\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\\n # Noise removal\\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\\n\\n n_increases: int = 0\\n while local_max_location.shape[0] < 30 and n_increases < 15:\\n threshold += 20\\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\\n # Noise removal\\n kernel = np.ones((3), np.uint8)\\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\\n # Noise removal\\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\\n n_increases += 1\\n # Reset threshold\\n threshold = 30\\n\\n num_clusters: int = 30\\n if n_increases >= 15:\\n num_clusters = local_max_location.shape[0]\\n kmeans = KMeans(n_clusters=num_clusters)\\n # If local_max_location size is 0, return 0 predictions\\n if not local_max_location.size:\\n return {\\n \\\"count\\\": 0\\n }\\n kmeans.fit(local_max_location)\\n local_max_location = kmeans.cluster_centers_.copy()\\n # Kmeans is returning a float data type so we need to convert it to an int. \\n local_max_location = local_max_location.astype(int)\\n dist_transform_copy = dist_transform.copy()\\n for i in range(local_max_location.shape[0]):\\n cv2.circle(dist_transform_copy, (local_max_location[i][1], local_max_location[i][0]), 5, 255)\\n # markers = np.zeros_like(dist_transform)\\n ret, sure = cv2.threshold(dist_transform, 0.01*dist_transform.max(), 255, 0)\\n sure = np.uint8(sure)\\n ret, markers = cv2.connectedComponents(sure)\\n labels = np.arange(kmeans.n_clusters)\\n markers[local_max_location[:,0], local_max_location[:,1]] = labels + 1\\n # Convert all local markers to an integer. This because cluster centers will be float numbers. \\n markers = markers.astype(int)\\n markers_copy = markers.copy()\\n index_non_zero_markers = np.argwhere(markers != 0)\\n markers_copy = markers_copy.astype(np.uint8)\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n for i in range(index_non_zero_markers.shape[0]):\\n string_text = str(markers[index_non_zero_markers[i][0], index_non_zero_markers[i][1]])\\n cv2.putText(markers_copy, string_text, (index_non_zero_markers[i][1], index_non_zero_markers[i][0]), font, 1, 255)\\n markers = markers.astype(np.int32)\\n segmented = cv2.watershed(masked, markers)\\n count_segments(markers)\\n #return {\\n # \\\"count\\\": local_max_location.shape[0]\\n #}\\n return {\\n \\\"count\\\": count_segments(markers),\\n }\",\n \"def CV_rectangles(self,XYSP):\\n X,Y,S,P = XYSP\\n rectangles=[]\\n for i in range(3):\\n for j in range(3):\\n rectangles.append([(X+i*S+i*P,Y+j*S+j*P),\\\\\\n (X+i*S+i*P+S,Y+j*S+j*P+S)])\\n return rectangles\",\n \"def draw_contours(self, image, maskImg):\\r\\n # Required variables..\\r\\n x, y, width, height = 0, 0, 0, 0\\r\\n # Find contours..\\r\\n contours, hierarchy = cv2.findContours(image=maskImg, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) # Playable Parameters..\\r\\n # Draw the contours..\\r\\n for contour in contours:\\r\\n # Calculate the area of the contour, so can remove unnecessary contours..\\r\\n area = cv2.contourArea(contour=contour)\\r\\n if area > 3000: # Playable adjustment..!! Found Good as 3000 for current light condition.. change this if light condition changes..\\r\\n # Draw the contours to the image -- actual frame..\\r\\n if self.debug_mode:\\r\\n cv2.drawContours(image=image, contours=contour, contourIdx=-1, color=(255, 255, 0), thickness=4)\\r\\n # Find the perimeter of the markers detected...\\r\\n perimeter = cv2.arcLength(curve=contour, closed=True)\\r\\n # Approximating/Finding the corners of the image from the obtained corners..\\r\\n approx_corners = cv2.approxPolyDP(curve=contour, epsilon=0.02 * perimeter, closed=True)\\r\\n # Find the bounding box rectangle for the approximated corners..\\r\\n x, y, width, height = cv2.boundingRect(approx_corners)\\r\\n # Return the values with which a rectangle can be drawn..\\r\\n return x, y, width, height\",\n \"def draw_obj(img, video_frame):\\n dets = []\\n contours, hierarchy = cv.findContours(img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)\\n dst = np.zeros(img.shape, dtype=np.uint8)\\n if len(contours) > 20000:\\n print(len(contours))\\n return dets\\n for i in range(len(contours)):\\n cv.drawContours(dst, contours, i, (255, 0, 0), 1)\\n cnt = contours[i]\\n area = cv.contourArea(cnt)\\n if area <= 60:\\n continue\\n x, y, w, h = cv.boundingRect(cnt)\\n\\n if x < 1 and y < 1:\\n continue\\n cv.rectangle(video_frame, (x, y), (x + w, y + h), (0, 0, 255), 2)\\n dets.append([x, y, x + w, y + h, 0.9])\\n dets = np.asarray(dets)\\n\\n cv.imshow('bbox', video_frame)\\n\\n return dets\",\n \"def find_targets(contours, frame):\\n # If there aren't any contours present, return frame without drawing\\n if len(contours) == 0:\\n return frame\\n # Copy frame, TODO why do we need to do this?\\n image = frame.copy()\\n screen_height, screen_width, _ = image.shape;\\n # TODO: Why subtract?\\n center_x = screen_width / 2 - .5\\n center_y = screen_height / 2 - .5\\n # List for storing found targets\\n targets = []\\n\\n if len(contours) >= 2:\\n # Sort contours in descending order by size\\n contours.sort(key=lambda contour: cv2.contourArea(contour), reverse=True)\\n\\n valid_contours = []\\n for contour in contours:\\n # Calculate areas of contour\\n contour_area = cv2.contourArea(contour)\\n if contour_area >= MIN_CONTOUR_SIZE:\\n # Get moments of contour for centroid calculations\\n moments = cv2.moments(contour)\\n # Find centroid of contour\\n if moments[\\\"m00\\\"] != 0:\\n cx = int(moments[\\\"m10\\\"] / moments[\\\"m00\\\"])\\n cy = int(moments[\\\"m01\\\"] / moments[\\\"m00\\\"])\\n else:\\n cx, cy = 0, 0\\n\\n ### CALCULATE CONTOUR ROTATION BY FITTING ELLIPSE ###\\n rotation = get_ellipse_rotation(image, contour)\\n\\n ### DRAW CONTOUR ###\\n # Draw white circle at center of contour\\n cv2.circle(image, (cx, cy), 6, (255, 255, 255))\\n\\n # Draw contour in green\\n cv2.drawContours(image, [contour], 0, (0, 200, 0), 1)\\n\\n # Append important info to array\\n valid_contours.append({\\\"cx\\\": cx, \\\"cy\\\": cy, \\\"rotation\\\": rotation})\\n\\n # Sort array based on coordinates (left to right) to make sure contours are adjacent\\n valid_contours.sort(key=lambda contour: contour[\\\"cx\\\"])\\n\\n # Find targets from contours\\n for i in range(len(valid_contours) - 1):\\n # Check rotation of adjacent contours\\n tilt_left = valid_contours[i][\\\"rotation\\\"]\\n tilt_right = valid_contours[i + 1][\\\"rotation\\\"]\\n\\n # Contour coordinates\\n cx_left = valid_contours[i][\\\"cx\\\"]\\n cx_right = valid_contours[i + 1][\\\"cx\\\"]\\n cy_left = valid_contours[i][\\\"cy\\\"]\\n cy_right = valid_contours[i + 1][\\\"cy\\\"]\\n\\n # If contour angles are opposite\\n # Negative tilt -> Rotated to the right\\n # NOTE: if using rotated rect (min area rectangle), negative tilt means rotated to left\\n # If left contour rotation is tilted to the left then skip iteration\\n # If right contour rotation is tilted to the right then skip iteration\\n if (len(valid_contours) == 2) or (np.sign(tilt_left) != np.sign(tilt_right) and\\n not (tilt_left > 0 and cx_left < cx_right or tilt_right > 0 and cx_right < cx_left)):\\n\\n target_cx = (cx_left + cx_right) / 2\\n target_cy = (cy_left + cy_right) / 2\\n\\n target_yaw = calculate_yaw(target_cx, center_x)\\n target_pitch = calculate_pitch(target_cy, center_y)\\n\\n targets.append({\\\"cx\\\": target_cx,\\n \\\"cy\\\": target_cy,\\n \\\"yaw\\\": target_yaw,\\n \\\"pitch\\\": target_pitch})\\n\\n # Check if there are targets seen\\n if len(targets) > 0:\\n # Get target with smallest yaw\\n nearest_target = min(targets, key=lambda target: math.fabs(target[\\\"yaw\\\"]))\\n # Write yaw of target in corner of image\\n cv2.putText(image, \\\"Yaw: %.3f\\\" % nearest_target[\\\"yaw\\\"], (1, 12), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255))\\n # Draw line at center of target\\n cv2.line(image, (int(nearest_target[\\\"cx\\\"]), screen_height), (int(nearest_target[\\\"cx\\\"]), 0), (255, 0, 0), 1)\\n # Draw line at center of screen\\n cv2.line(image, (round(center_x), screen_height), (round(center_x), 0), (255, 255, 255), 1)\\n\\n # Send our final data to NetworkTables\\n table.putBoolean(\\\"target_present\\\", True)\\n table.putNumber(\\\"targets_seen\\\", len(targets))\\n table.putNumber(\\\"target_yaw\\\", nearest_target[\\\"yaw\\\"])\\n table.putNumber(\\\"target_pitch\\\", nearest_target[\\\"pitch\\\"])\\n else:\\n table.putBoolean(\\\"target_present\\\", False)\\n table.putNumber(\\\"targets_seen\\\", 0)\\n table.putNumber(\\\"target_yaw\\\", 0)\\n table.putNumber(\\\"target_pitch\\\", 0)\\n table.putNumber(\\\"target_distance\\\", 0)\\n\\n return image\",\n \"def getTasseledCap(img):\\n\\t\\t\\t\\n\\t\\t\\tcoefficients = ee.Array([\\n\\t\\t\\t\\t[0.3037, 0.2793, 0.4743, 0.5585, 0.5082, 0.1863],\\n\\t\\t\\t\\t[-0.2848, -0.2435, -0.5436, 0.7243, 0.0840, -0.1800],\\n\\t\\t\\t\\t[0.1509, 0.1973, 0.3279, 0.3406, -0.7112, -0.4572],\\n\\t\\t\\t\\t[-0.8242, 0.0849, 0.4392, -0.0580, 0.2012, -0.2768],\\n\\t\\t\\t\\t[-0.3280, 0.0549, 0.1075, 0.1855, -0.4357, 0.8085],\\n\\t\\t\\t\\t[0.1084, -0.9022, 0.4120, 0.0573, -0.0251, 0.0238]\\n\\t\\t\\t]);\\n\\t\\t\\n\\t\\t\\tbands=ee.List(['blue','green','red','nir','swir1','swir2'])\\n\\t\\t\\t\\n\\t\\t\\t# Make an Array Image, with a 1-D Array per pixel.\\n\\t\\t\\tarrayImage1D = img.select(bands).toArray()\\n\\t\\t\\n\\t\\t\\t# Make an Array Image with a 2-D Array per pixel, 6x1.\\n\\t\\t\\tarrayImage2D = arrayImage1D.toArray(1)\\n\\t\\t\\n\\t\\t\\tcomponentsImage = ee.Image(coefficients).matrixMultiply(arrayImage2D).arrayProject([0]).arrayFlatten([['brightness', 'greenness', 'wetness', 'fourth', 'fifth', 'sixth']]).float();\\n\\t \\n\\t\\t\\t# Get a multi-band image with TC-named bands.\\n\\t\\t\\treturn img.addBands(componentsImage);\",\n \"def __init__(self):\\n\\n self.__hsv_threshold_hue = [25.899280575539567, 29.11573068569659]\\n self.__hsv_threshold_saturation = [185.74640287769785, 255.0]\\n self.__hsv_threshold_value = [137.80585700930783, 255.0]\\n\\n self.hsv_threshold_output = None\\n\\n self.__find_contours_input = self.hsv_threshold_output\\n self.__find_contours_external_only = False\\n\\n self.find_contours_output = None\\n\\n self.__filter_contours_contours = self.find_contours_output\\n self.__filter_contours_min_area = 30.0\\n self.__filter_contours_min_perimeter = 30.0\\n self.__filter_contours_min_width = 0.0\\n self.__filter_contours_max_width = 1000.0\\n self.__filter_contours_min_height = 0.0\\n self.__filter_contours_max_height = 1000.0\\n self.__filter_contours_solidity = [0, 100]\\n self.__filter_contours_max_vertices = 1000000.0\\n self.__filter_contours_min_vertices = 0.0\\n self.__filter_contours_min_ratio = 0.0\\n self.__filter_contours_max_ratio = 1000.0\\n\\n self.filter_contours_output = None\",\n \"def sort_filtered_contours(self):\\r\\n\\r\\n # Get the contours again\\r\\n invert = 255 - self.thresh_invert\\r\\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\\r\\n\\r\\n # Make sure that they're within the correct range for size\\r\\n # If too small, it is probably noise; if too large, then should be things around the grid\\r\\n for i, c in enumerate(real_contours, 1):\\r\\n contour_area = cv2.contourArea(c)\\r\\n if self.min_cell_size < contour_area < self.max_cell_size:\\r\\n self.good_contours.append(c)\\r\\n\\r\\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\\r\\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\\r\\n\\r\\n # Sort the contours from top to bottom\\r\\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\\\"top-to-bottom\\\")\\r\\n\\r\\n # We then sort each row from left to right\\r\\n row = []\\r\\n for i, c in enumerate(half_sorted_contours, 1):\\r\\n row.append(c)\\r\\n if i % self.board_dimension == 0:\\r\\n (full_sorted_contours, _) = contours.sort_contours(row, method=\\\"left-to-right\\\")\\r\\n self.game_board_contours.append(full_sorted_contours)\\r\\n row = []\",\n \"def findFaces(self):\\n\\t\\trects = self.detectAll()\\n\\t\\tif len(rects)==0:\\n\\t\\t\\trects = []\\n\\t\\telse:\\n\\t\\t\\trects[:, 2:] += rects[:, :2]\\n\\t\\tself.analyzeFrame(rects)\",\n \"def extract(integral_channels, feature_stubs):\\n\\n features = []\\n for stub in feature_stubs:\\n ch, p_x, p_y, he, wi = stub\\n\\n ch = integral_channels[ch]\\n rect1 = ch.item(p_y, p_x)\\n rect2 = ch.item(p_y, p_x+wi)\\n rect3 = ch.item(p_y+he, p_x)\\n rect4 = ch.item(p_y+he, p_x+wi)\\n\\n fea = rect4 + rect1 - rect2 - rect3\\n features.append(fea)\\n\\n return features\",\n \"def analyzeContours(contours):\\n if len(contours[0]) != 4 and len(contours[0]) != 8:\\n return 0\\n\\n first, second, prev = [1, 1], [1, 1], 0\\n for i, val in enumerate(numpy.nditer(contours[0])):\\n if i % 2:\\n second = [prev, val]\\n else:\\n first = [prev, val]\\n\\n # compare pair to the previous pair\\n for num in first:\\n if num in second:\\n break\\n else:\\n return 0\\n\\n prev = val\\n\\n return 1\",\n \"def displayContours(self):\\n #obsolete?\\n profbox()\\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\\n for modelNode in modelNodes.values():\\n if modelNode.GetAttribute(\\\"contour\\\") == \\\"1\\\":\\n needleNode = slicer.mrmlScene.GetNodeByID(modelNode.GetAttribute(\\\"needleID\\\"))\\n if needleNode != None:\\n if needleNode.GetDisplayVisibility()==1:\\n modelNode.SetDisplayVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))\\n d = modelNode.GetDisplayNode()\\n d.SetSliceIntersectionVisibility(abs(int(slicer.modules.NeedleFinderWidget.displayContourButton.checked)-1))\",\n \"def analyze(self):\\n result = []\\n for frame_no, frame in enumerate(self.work.files('frames')):\\n areas = self.blur.check_image(frame, self.work.files('templates'))\\n for area in areas:\\n index = find_area(result, area)\\n if index == -1:\\n result.append({'area': area, 'frames': [frame_no]})\\n else:\\n result[index]['frames'].append(frame_no)\\n\\n for values in result:\\n sectors = [[values['frames'][0], values['frames'][0]]]\\n for index in range(1, len(values['frames'])):\\n if (values['frames'][index] - sectors[-1][1]) == 1:\\n sectors[-1][1] = values['frames'][index]\\n else:\\n sectors.append([values['frames'][index], values['frames'][index]])\\n values['sectors'] = sectors\\n return result\",\n \"def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\\n\\n device += 1\\n\\n if len(np.shape(img)) == 3:\\n iy, ix, iz = np.shape(img)\\n else:\\n iy, ix, = np.shape(img)\\n\\n # get the break groups\\n\\n if nrow == 1:\\n rbreaks = [0, iy]\\n else:\\n rstep = np.rint(iy / nrow)\\n rstep1 = np.int(rstep)\\n rbreaks = range(0, iy, rstep1)\\n if ncol == 1:\\n cbreaks = [0, ix]\\n else:\\n cstep = np.rint(ix / ncol)\\n cstep1 = np.int(cstep)\\n cbreaks = range(0, ix, cstep1)\\n\\n # categorize what bin the center of mass of each contour\\n\\n def digitize(a, step):\\n if isinstance(step, int) == True:\\n i = step\\n else:\\n i = len(step)\\n for x in range(0, i):\\n if x == 0:\\n if a >= 0 and a < step[x + 1]:\\n return x + 1\\n elif a >= step[x - 1] and a < step[x]:\\n return x\\n elif a > step[x - 1] and a > np.max(step):\\n return i\\n\\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\\n coord = []\\n for i in range(0, len(roi_objects)):\\n m = cv2.moments(roi_objects[i])\\n if m['m00'] == 0:\\n pass\\n else:\\n cx = int(m['m10'] / m['m00'])\\n cy = int(m['m01'] / m['m00'])\\n # colbin = np.digitize(cx, cbreaks)\\n # rowbin = np.digitize(cy, rbreaks)\\n colbin = digitize(cx, cbreaks)\\n rowbin = digitize(cy, rbreaks)\\n a = (cx, cy, colbin, rowbin, i)\\n coord.append(a)\\n coord1 = np.array(coord, dtype=dtype)\\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\\n\\n # get the list of unique coordinates and group the contours with the same bin coordinates\\n\\n groups = []\\n for i, y in enumerate(coord2):\\n col = y[3]\\n row = y[2]\\n location = str(row) + ',' + str(col)\\n groups.append(location)\\n\\n unigroup = np.unique(groups)\\n coordgroups = []\\n\\n for i, y in enumerate(unigroup):\\n col = int(y[0])\\n row = int(y[2])\\n for a, b in enumerate(coord2):\\n if b[2] == col and b[3] == row:\\n grp = i\\n contour = b[4]\\n coordgroups.append((grp, contour))\\n else:\\n pass\\n\\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\\n\\n contours = roi_objects\\n grouped_contour_indexes = coordlist\\n\\n # Debug image is rainbow printed contours\\n\\n if debug == 'print':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n print_image(img_copy, (str(device) + '_clusters.png'))\\n\\n elif debug == 'plot':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n plot_image(img_copy)\\n\\n return device, grouped_contour_indexes, contours\",\n \"def extract_labels_cps(scene: \\\"Scenemaker\\\") -> List[Tuple[int, np.ndarray]]:\\r\\n objects = utils.select_collection(scene.target_collection)\\r\\n boxes_list = []\\r\\n\\r\\n for obj in objects:\\r\\n objclass = obj.name.split(\\\".\\\")[0]\\r\\n cornermatrix = np.empty((8, 3))\\r\\n for j, corner in enumerate(obj.bound_box):\\r\\n cornermatrix[j] = corner\\r\\n\\r\\n boxes_list.append((scene.name2num[objclass], cornermatrix))\\r\\n\\r\\n return boxes_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75937665","0.6507299","0.6484516","0.6458244","0.6308807","0.62851155","0.6266374","0.62063503","0.60648507","0.59767586","0.5921466","0.5914407","0.5904614","0.58996433","0.58695424","0.58617276","0.5860281","0.584063","0.577641","0.5762255","0.57246906","0.56895113","0.5628092","0.5613775","0.56004417","0.55641323","0.5561068","0.55531305","0.5541117","0.5540935","0.5507035","0.54472184","0.5409614","0.5401465","0.5390013","0.53896964","0.53896964","0.53799325","0.53420436","0.5328344","0.53183484","0.53167665","0.5299688","0.5298088","0.5287556","0.52749914","0.5256589","0.5255929","0.5231668","0.52192014","0.5217905","0.52006745","0.5199","0.51988155","0.519866","0.5189343","0.51790476","0.51750755","0.5171878","0.51651907","0.5157356","0.5153962","0.51527685","0.51478076","0.51333827","0.5127352","0.5121331","0.5106861","0.5085162","0.5075164","0.50736696","0.507116","0.50514024","0.5047145","0.5042022","0.5039219","0.50356615","0.50229007","0.50225055","0.5021674","0.5018587","0.5015873","0.50120467","0.49990183","0.49980223","0.4987764","0.4986375","0.4985041","0.4976225","0.49695116","0.4968439","0.4966289","0.4955138","0.4949417","0.49475035","0.49431303","0.49387088","0.4937744","0.4933441","0.4921127"],"string":"[\n \"0.75937665\",\n \"0.6507299\",\n \"0.6484516\",\n \"0.6458244\",\n \"0.6308807\",\n \"0.62851155\",\n \"0.6266374\",\n \"0.62063503\",\n \"0.60648507\",\n \"0.59767586\",\n \"0.5921466\",\n \"0.5914407\",\n \"0.5904614\",\n \"0.58996433\",\n \"0.58695424\",\n \"0.58617276\",\n \"0.5860281\",\n \"0.584063\",\n \"0.577641\",\n \"0.5762255\",\n \"0.57246906\",\n \"0.56895113\",\n \"0.5628092\",\n \"0.5613775\",\n \"0.56004417\",\n \"0.55641323\",\n \"0.5561068\",\n \"0.55531305\",\n \"0.5541117\",\n \"0.5540935\",\n \"0.5507035\",\n \"0.54472184\",\n \"0.5409614\",\n \"0.5401465\",\n \"0.5390013\",\n \"0.53896964\",\n \"0.53896964\",\n \"0.53799325\",\n \"0.53420436\",\n \"0.5328344\",\n \"0.53183484\",\n \"0.53167665\",\n \"0.5299688\",\n \"0.5298088\",\n \"0.5287556\",\n \"0.52749914\",\n \"0.5256589\",\n \"0.5255929\",\n \"0.5231668\",\n \"0.52192014\",\n \"0.5217905\",\n \"0.52006745\",\n \"0.5199\",\n \"0.51988155\",\n \"0.519866\",\n \"0.5189343\",\n \"0.51790476\",\n \"0.51750755\",\n \"0.5171878\",\n \"0.51651907\",\n \"0.5157356\",\n \"0.5153962\",\n \"0.51527685\",\n \"0.51478076\",\n \"0.51333827\",\n \"0.5127352\",\n \"0.5121331\",\n \"0.5106861\",\n \"0.5085162\",\n \"0.5075164\",\n \"0.50736696\",\n \"0.507116\",\n \"0.50514024\",\n \"0.5047145\",\n \"0.5042022\",\n \"0.5039219\",\n \"0.50356615\",\n \"0.50229007\",\n \"0.50225055\",\n \"0.5021674\",\n \"0.5018587\",\n \"0.5015873\",\n \"0.50120467\",\n \"0.49990183\",\n \"0.49980223\",\n \"0.4987764\",\n \"0.4986375\",\n \"0.4985041\",\n \"0.4976225\",\n \"0.49695116\",\n \"0.4968439\",\n \"0.4966289\",\n \"0.4955138\",\n \"0.4949417\",\n \"0.49475035\",\n \"0.49431303\",\n \"0.49387088\",\n \"0.4937744\",\n \"0.4933441\",\n \"0.4921127\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6806032"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93474,"cells":{"query":{"kind":"string","value":"Identify every contour in the watershed segmentation for each frame as defined by each pair of cell IDs (vals). Also, return the order of contours that is needed to reconstruct the border surrounding each cell."},"document":{"kind":"string","value":"def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\n orderOfSCsByValueByFrame = [\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\n ]\n return scListByFrame, orderOfSCsByValueByFrame"},"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 GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def getContours(img,iteration):\n nP, IDrange = upDate(iteration)\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\n kernel = np.ones((nP, nP), np.uint8)\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\n contours = []\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n if iteration == 2 :\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n elif iteration == 3:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n else:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n return contours","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def get_contour_features(mask,selectcell=\"centered\"):\r\n \r\n #binarize image (everything above 0 becomes 1)\r\n mask = np.clip(mask,a_min=0,a_max=1)\r\n\r\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\r\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\r\n contours = list(contours)\r\n \r\n #in case there is no contour found, add a dummy contour\r\n if len(contours)==0:\r\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\r\n\r\n #Sort contours, longest first\r\n contours.sort(key=len,reverse=True)\r\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\r\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\r\n\r\n mu_origs = [cv2.moments(contour) for contour in contours]\r\n mu_hulls = [cv2.moments(hull) for hull in hulls]\r\n\r\n area_origs = [mu_orig[\"m00\"] for mu_orig in mu_origs]\r\n area_hulls = [mu_hull[\"m00\"] for mu_hull in mu_hulls]\r\n\r\n #drop events where area is zero\r\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \r\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\r\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\r\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\r\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\r\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\r\n \r\n \r\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\r\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\r\n\r\n \r\n if selectcell == \"smooth\":\r\n #compute the area ratio (roughness of contour)\r\n area_ratio = np.array(area_hulls)/np.array(area_origs)\r\n #get the contour with minimum roughness (smooth contour)\r\n sorter = np.argsort(area_ratio) #smallest first\r\n\r\n if selectcell == \"centered\":\r\n #select contour that is closest to the center of the image. \r\n #In iPAC, cells are usually in the center.\r\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\r\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\r\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\r\n sorter = np.argsort(distances) #smallest first\r\n \r\n #sort values with respect to chosen metric (area_ratio or distance)\r\n contours = [contours[s] for s in sorter]\r\n hulls = [hulls[s] for s in sorter]\r\n pos_x = [pos_x[s] for s in sorter]\r\n pos_y = [pos_y[s] for s in sorter]\r\n mu_origs = [mu_origs[s] for s in sorter]\r\n area_origs = [area_origs[s] for s in sorter]\r\n area_hulls = [area_hulls[s] for s in sorter]\r\n \r\n # draw mask of the chosen contour\r\n mask = np.zeros_like(mask)\r\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\r\n\r\n hull = hulls[0]#[0:n_contours]\r\n pos_x = pos_x[0]\r\n pos_y = pos_y[0] \r\n mu_orig = mu_origs[0]#[0:n_contours]\r\n area_orig = area_origs[0]#[0:n_contours]\r\n area_hull = area_hulls[0]#[0:n_contours]\r\n \r\n if area_orig>0:\r\n area_ratio = area_hull/area_orig\r\n else:\r\n area_ratio = np.nan\r\n\r\n arc = cv2.arcLength(hull, True) \r\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\"m00\"]) / arc\r\n\r\n\r\n dic = {\"mask\":mask,\"pos_x\":pos_x,\"pos_y\":pos_y,\"area_orig\":area_orig,\"area_hull\":area_hull,\\\r\n \"area_ratio\":area_ratio,\"circularity\":circularity}\r\n return dic","def trackCells(self): \n # variable initialization\n self.t_appearance = []\n self.id_seq = []\n self._n_cell = 0\n self.division = []\n self.dict_track = {}\n\n t_ini = self.configs[self.TIME_INI_KEY]\n\n # Initialize points with first frame\n self.dict_track[0] = {}\n for id_num in self.pos[0][4]:\n self._addTrack(0, id_num)\n\n # From frame=1 on...\n for t, data_t in enumerate(self.pos[1:]):\n self.dict_track[t+1] = {}\n # check all the cells in this frame\n for cell, id_num in enumerate(data_t[4]):\n parent = data_t[5][cell]\n if parent == -1:\n # new track\n self._addTrack(t+1, id_num)\n elif parent in self.dict_track[t]:\n # check if parent is in the previous list\n index = self.dict_track[t][parent]\n if index in self.dict_track[t+1].values():\n # then we have cell division, and we monitor the child separarely\n self._addDivision(t+1, id_num, index)\n else:\n # cell continues in the same track\n self.id_seq[index].append(id_num)\n self.dict_track[t+1][id_num] = index\n else:\n # weird things happened!\n print(\"Warning! Time %s, Cell ID %s lost track\"%(str(t+t_ini), str(id_num)))\n\n\n # all track indexes are included, no filter (yet)\n self.index_filter = list(range(len(self.id_seq)))\n\n return self.id_seq, self.t_appearance","def find_original_contours(self):\r\n\r\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\r\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\r\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\r\n int(self.cell_size), 5)\r\n self.thresh_orig = 255 - self.thresh_invert\r\n\r\n # Find the contours of the image. Each contour should correspond to a cell\r\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\r\n for block in orig_contours:\r\n area = cv2.contourArea(block)\r\n\r\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\r\n if area < self.min_cell_size:\r\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)","def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\n return [\n [sc.cVLS() for sc in scList]\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\n ]","def instance_contours(gti):\n # TODO: move to somewhere better\n import cv2\n\n rc_locs = np.where(gti > 0)\n grouped_cc_rcs = util.group_items(\n np.ascontiguousarray(np.vstack(rc_locs).T),\n gti[rc_locs], axis=0\n )\n\n def bounding_box(rcs):\n rc1 = rcs.min(axis=0)\n rc2 = rcs.max(axis=0)\n return rc1, rc2\n\n # slice out a bounding region around each instance, detect the contour and\n # then offset it back into image coordinates\n grouped_contours = {}\n for label, rcs in grouped_cc_rcs.items():\n rc1, rc2 = bounding_box(rcs)\n sl = (slice(rc1[0], rc2[0] + 2), slice(rc1[1], rc2[1] + 2))\n submask = (gti[sl] == label).astype(np.uint8)\n\n xy_offset = rc1[::-1]\n offset = xy_offset + [-2, -2]\n\n border = cv2.copyMakeBorder(submask, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=0 )\n _, contors, hierarchy = cv2.findContours(border, cv2.RETR_TREE,\n cv2.CHAIN_APPROX_SIMPLE,\n offset=tuple(offset))\n \"\"\"\n offset = [0, 0]\n BGR_GREEN = (0, 255, 0)\n x = np.ascontiguousarray(util.ensure_alpha_channel(submask)[:, :, 0:3]).astype(np.uint8)\n draw_img = cv2.drawContours(\n image=x, contours=contors,\n contourIdx=-1, color=BGR_GREEN, thickness=2)\n \"\"\"\n # note when len(contours > 1, there is a hole in the building)\n # assert len(contors) == 1\n grouped_contours[label] = contors\n return grouped_contours","def take_contours(self):\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]","def get_contours(self):\n depth_image = capture_images((self.w,self.h))\n\n thresh = threshold_depth_image(depth_image, min_depth=config.min_depth, max_depth=config.max_depth, threshold=config.min_depth, kernel=self.kernel)\n\n # extract contours\n im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\n if hierarchy!=None:\n hierarchy = hierarchy[0]\n return contours, hierarchy\n else:\n return [], []","def getMostContour(img,svm,knn,filterArr,digits,wThresh,hThresh):\r\n # append the filter to filter array, this approach is used in case of \r\n # multiple filter methods would be used.\r\n counts = []\r\n # iterare through every filter\r\n for flt in filterArr:\r\n # copy the image so we don't draw on same image\r\n flt_img = img.copy()\r\n last_img = img.copy()\r\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh) \r\n if not digits:\r\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh)\r\n flt_contour_map = []\r\n labels = []\r\n for crop,(x,y,w,h),contour in cropNwriteBBs(img,cntfound_fltr):\r\n #crop = np.array(crop,dtype='float32')\r\n crop = cv2.cvtColor(crop,cv2.COLOR_BGR2GRAY)\r\n crop = cv2.resize(crop,(25,25))\r\n # winSize is the size of the image cropped to an multiple of the cell size\r\n hog_fts = hog.compute(crop)\\\r\n .reshape(n_cells[1] - block_size[1] + 1,\r\n n_cells[0] - block_size[0] + 1,\r\n block_size[0], block_size[1], nbins) \\\r\n .transpose((1, 0, 2, 3, 4))\r\n hog_fts = np.resize(hog_fts.flatten(),(1,576))\r\n # make the resulted crop same type with the trained values\r\n hog_fts.dtype = 'float32'\r\n # get predicted labels\r\n label_svm=svm.predict(hog_fts)[1]\r\n label_knn = knn.findNearest(hog_fts,k=5)[1]\r\n # label 10 is considered as 'not digit' or 'thrash'\r\n # so if predicted label is not 10, draw the bounding box\r\n if digits:\r\n if(label_svm!=10 and label_knn != 10 and label_svm!=11 and label_knn != 11):\r\n flt_contour_map.append(contour)\r\n labels.append(str(label_knn[0])[1])\r\n else:\r\n if(label_svm!=2 and label_knn != 2):\r\n flt_contour_map.append(contour)\r\n labels.append(str(label_knn[0])[1])\r\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\r\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\r\n last_cnt,last_labels = secondElimination(flt_contour_map,labels)\r\n for cnt in last_cnt:\r\n x,y,w,h = cv2.boundingRect(cnt)\r\n cv2.rectangle(flt_img,(x,y),(x+w,y+h),[0,255,0],2)\r\n #showWait(flt_img,'fltres')\r\n _,xx,res_boxes,_,_ = mergeBoundingBoxes(flt_img,last_cnt,last_labels)\r\n cnt = len(res_boxes)\r\n counts.append([cnt,flt_img,last_cnt,last_labels])\r\n # append resulted image and contours to an array\r\n counts = np.asarray(counts)\r\n # get the resulted image which contain more digits (bounding boxes)\r\n tmp = counts[:,0]\r\n resulted_img = counts[np.argmax(tmp),1]\r\n result_labels = counts[np.argmax(tmp),3]\r\n resulted_contour = counts[np.argmax(tmp),2]\r\n return resulted_contour,result_labels,resulted_img","def detect_contours(self):\r\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\r\n return [DbugContour(cv_contour=contour) for contour in contours]","def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\n\n kernel = np.ones((5, 5), np.float32)\n\n # Use a distance transform to find the seed points for watershed\n tmp = class_mask\n tmp[tmp>0] = 1 # here\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\n dist = (dist / np.max(dist)) * 255.\n\n # Since there may be multiple peaks, we use dilation to find them\n dilate = cv2.dilate(dist, kernel, iterations=3)\n peaks = np.float32(np.where(dilate == dist, 1, 0))\n peaks = peaks * class_mask * 255\n\n sure_fg = np.where(peaks > 125, 255., 0.)\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\n sure_fg = np.uint8(sure_fg)\n\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\n unknown = sure_bg - sure_fg\n\n # Add one to all labels so that known background is not 0, but 1\n _, markers = cv2.connectedComponents(sure_fg)\n markers = markers + 1\n\n markers[unknown == 255] = 0\n\n markers = cv2.watershed(self.image, markers)\n\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\n watershed_superpixels[markers == -1] = 255\n\n return watershed_superpixels","def sort_filtered_contours(self):\r\n\r\n # Get the contours again\r\n invert = 255 - self.thresh_invert\r\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\r\n\r\n # Make sure that they're within the correct range for size\r\n # If too small, it is probably noise; if too large, then should be things around the grid\r\n for i, c in enumerate(real_contours, 1):\r\n contour_area = cv2.contourArea(c)\r\n if self.min_cell_size < contour_area < self.max_cell_size:\r\n self.good_contours.append(c)\r\n\r\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\r\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\r\n\r\n # Sort the contours from top to bottom\r\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\"top-to-bottom\")\r\n\r\n # We then sort each row from left to right\r\n row = []\r\n for i, c in enumerate(half_sorted_contours, 1):\r\n row.append(c)\r\n if i % self.board_dimension == 0:\r\n (full_sorted_contours, _) = contours.sort_contours(row, method=\"left-to-right\")\r\n self.game_board_contours.append(full_sorted_contours)\r\n row = []","def cell_detects(self, masked=False):\r\n grd = self.grd\r\n ncells = len(grd.cells['depth'])\r\n detects_i_tr = np.zeros(ncells, np.int32)\r\n if masked:\r\n not_flagged = np.where(self.rec_track.flagged==0)[0]\r\n rec_track = self.rec_track[not_flagged]\r\n else:\r\n rec_track = self.rec_track\r\n ndetects = len(rec_track)\r\n for nd in range(ndetects):\r\n tr = rec_track[nd]\r\n i = tr.i\r\n if i >= 0:\r\n detects_i_tr[i] += 1\r\n \r\n return detects_i_tr","def get_further_neighbours(self, cell):\n\t\tneighs = self.get_neighbours(cell)\n\t\ti, j = cell.find_id()\n\t\tneighbours = []\n\t\tfor neigh in neighs:\n\t\t\tx, y = neigh.find_id()\n\t\t\tif abs(x-i)+abs(y-j) > 1 or abs(x-i)+abs(y-j) == 0: \n\t\t\t\tneighbours.append(self.space[y,x])\n\t\treturn neighbours","def nondetects(self, masked=False):\r\n grd = self.grd\r\n xnd = []\r\n ynd = []\r\n ncells = len(grd.cells['depth'])\r\n non_detects_i_tr = np.zeros(ncells, np.int32)\r\n if masked:\r\n not_flagged = np.where(self.rec_track.flagged==0)[0]\r\n rec_track = self.rec_track[not_flagged]\r\n rec_seg = self.make_segments(set_depth=True, \r\n input_rec_track=rec_track)\r\n else:\r\n rec_seg = self.rec_seg\r\n for nr, rseg in enumerate(rec_seg):\r\n seg = rec_seg[nr]\r\n dt = seg.dt\r\n if dt > dt_signal+1:\r\n t1 = seg.t1\r\n t2 = seg.t2\r\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\r\n x1 = seg.x1\r\n x2 = seg.x2\r\n y1 = seg.y1\r\n y2 = seg.y2\r\n dx_nd = (x2 - x1)/float(nint+1)\r\n dy_nd = (y2 - y1)/float(nint+1)\r\n if nint < 120: # 10 minute cutoff for nondetect filling\r\n xint = [x1 + n*dx_nd for n in range(1,nint)]\r\n yint = [y1 + n*dy_nd for n in range(1,nint)]\r\n xnd = xnd + xint\r\n ynd = ynd + yint\r\n\r\n for nd in range(len(xnd)):\r\n xy = [xnd[nd], ynd[nd]]\r\n i = grd.select_cells_nearest(xy)\r\n if (i is not None) and (i >= 0):\r\n non_detects_i_tr[i] += 1\r\n\r\n return non_detects_i_tr","def fun_contours(self, params):\n shape_coeffs = params[:self.num_shape_params]\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\n\n vertices3d = self.vertices3d\n vertices3d_from_mesh = np.zeros_like(vertices3d)\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\n\n inner_idx = 0\n for idx in range(vertices3d.shape[0]):\n lm_idx = idx % 66\n obs_num = int(np.floor(idx/66))\n\n if lm_idx in self.contour_lms_list[0]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_right[obs_num])\n elif lm_idx in self.contour_lms_list[1]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_left[obs_num])\n else:\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\n inner_idx += 1\n if inner_idx == 50:\n inner_idx = 0\n\n return (vertices3d_from_mesh - vertices3d).ravel()","def get_winning_discs(self):\r\n for i in range(6):\r\n for j in range(7):\r\n if self.board[i][j] == 'O':\r\n continue\r\n if self.is_horizontal_four(i, j):\r\n return [(i, x) for x in range(j, j + 4)]\r\n if self.is_vertical_four(i, j):\r\n return [(x, j) for x in range(i, i - 4, -1)]\r\n if self.is_neg_diagonal_four(i, j):\r\n return [(x, y) for x, y in zip(\r\n range(i, i + 4), range(j, j - 4, -1))]\r\n if self.is_pos_diagonal_four(i, j):\r\n return [(x, y)\r\n for x, y in zip(range(i, i + 4), range(j, j + 4))]","def GetInteriorEdgesTri(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesTri()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesTri()\n\n sorted_all_edges = np.sort(self.all_edges,axis=1)\n sorted_boundary_edges = np.sort(self.edges,axis=1)\n\n x = []\n for i in range(self.edges.shape[0]):\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\n pos_interior_edges = np.where(interior_edges==0)[0]\n if pos_interior_edges.shape[0] != 0:\n x.append(pos_interior_edges)\n\n edge_aranger = np.arange(self.all_edges.shape[0])\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\n interior_edges = self.all_edges[edge_aranger,:]\n\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\n edge_flags[edge_aranger] = 0\n\n self.interior_edges = interior_edges\n return interior_edges, edge_flags","def get_connected_components(img):\n already_labeled = []\n connected_components = []\n pixel_queue = []\n\n def get_fg_neighbors(row,col):\n neighbors = []\n min_row = max(row-1,0)\n max_row = min(row+1, len(img)-1)\n min_col = max(col-1,0)\n max_col = min(col+1, len(img[0])-1)\n for r in xrange(min_row, max_row+1):\n for c in xrange(min_col, max_col+1):\n if img[r][c] == 1 and (r,c) not in already_labeled:\n neighbors.append((r,c))\n return neighbors\n\n for row in xrange(len(img)):\n for col in xrange(len(img[0])):\n if img[row][col] == 1 and (row,col) not in already_labeled:\n already_labeled.append((row,col))\n cc = []\n cc.append((row,col))\n pixel_queue.append((row,col))\n while len(pixel_queue) > 0:\n cur_pixel = pixel_queue[0]\n pixel_queue = pixel_queue[1:]\n neighbors = get_fg_neighbors(cur_pixel[0], cur_pixel[1])\n already_labeled += neighbors\n cc += neighbors\n pixel_queue += neighbors\n connected_components.append(cc)\n return connected_components","def findContours(img, thresh=127, val=255):\n\tgray = grayscale(img)\n\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\n\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\terrorCheckContour(contours)\n\treturn sort(contours)","def paintings_detection(query_image, mask):\n\n image = cv2.imread(query_image)\n\n image_width = mask.shape[0]\n image_height = mask.shape[1]\n x_box_1, y_box_1, w_box_1, h_box_1, x_box_2, y_box_2, w_box_2, h_box_2 = 0, 0, 0, 0, 0, 0, 0, 0, \n\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2:]\n\n for cnt in contours:\n x, y, w, h = cv2.boundingRect(cnt)\n \n if (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 == 0):\n x_box_1, y_box_1, w_box_1, h_box_1 = x, y, w, h\n elif (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 != 0):\n x_box_2, y_box_2, w_box_2, h_box_2 = x, y, w, h\n\n if x_box_2 == 0:\n x_value_to_split = 0\n else:\n x_value_to_split = (x_box_1 + w_box_1/2 + x_box_2 + w_box_2/2) / 2\n\n\n return(x_value_to_split)","def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\n\n device += 1\n\n if len(np.shape(img)) == 3:\n iy, ix, iz = np.shape(img)\n else:\n iy, ix, = np.shape(img)\n\n # get the break groups\n\n if nrow == 1:\n rbreaks = [0, iy]\n else:\n rstep = np.rint(iy / nrow)\n rstep1 = np.int(rstep)\n rbreaks = range(0, iy, rstep1)\n if ncol == 1:\n cbreaks = [0, ix]\n else:\n cstep = np.rint(ix / ncol)\n cstep1 = np.int(cstep)\n cbreaks = range(0, ix, cstep1)\n\n # categorize what bin the center of mass of each contour\n\n def digitize(a, step):\n if isinstance(step, int) == True:\n i = step\n else:\n i = len(step)\n for x in range(0, i):\n if x == 0:\n if a >= 0 and a < step[x + 1]:\n return x + 1\n elif a >= step[x - 1] and a < step[x]:\n return x\n elif a > step[x - 1] and a > np.max(step):\n return i\n\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\n coord = []\n for i in range(0, len(roi_objects)):\n m = cv2.moments(roi_objects[i])\n if m['m00'] == 0:\n pass\n else:\n cx = int(m['m10'] / m['m00'])\n cy = int(m['m01'] / m['m00'])\n # colbin = np.digitize(cx, cbreaks)\n # rowbin = np.digitize(cy, rbreaks)\n colbin = digitize(cx, cbreaks)\n rowbin = digitize(cy, rbreaks)\n a = (cx, cy, colbin, rowbin, i)\n coord.append(a)\n coord1 = np.array(coord, dtype=dtype)\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\n\n # get the list of unique coordinates and group the contours with the same bin coordinates\n\n groups = []\n for i, y in enumerate(coord2):\n col = y[3]\n row = y[2]\n location = str(row) + ',' + str(col)\n groups.append(location)\n\n unigroup = np.unique(groups)\n coordgroups = []\n\n for i, y in enumerate(unigroup):\n col = int(y[0])\n row = int(y[2])\n for a, b in enumerate(coord2):\n if b[2] == col and b[3] == row:\n grp = i\n contour = b[4]\n coordgroups.append((grp, contour))\n else:\n pass\n\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\n\n contours = roi_objects\n grouped_contour_indexes = coordlist\n\n # Debug image is rainbow printed contours\n\n if debug == 'print':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n print_image(img_copy, (str(device) + '_clusters.png'))\n\n elif debug == 'plot':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n plot_image(img_copy)\n\n return device, grouped_contour_indexes, contours","def get_nb_vals(i, pnts, dem, top_left_cor, cellsize, rows, cols):\n nb_x = np.zeros((5,5)) # this 5 by 5 max would contain the x coordinate of 16 neighbor pixels of a sample point\n nb_y = np.zeros((5,5)) # this 5 by 5 matrix would contain the y coordinate of 16 neighbor pixels of a sample point\n nb_z = np.zeros((5,5))\n # get index and value of cell in DEM containing current point\n (cell_X, cell_Y, cell_Z) = misc.getCellValue(pnts[i], \n dem, \n top_left_cor, \n cellsize)\n #Deal with sample points near boundary of the DEM\n point_within_dem = (cell_X-2) >=0 and (cell_Y-2>=0) and (cell_X+3)<=cols and (cell_Y+3)<=rows\n if point_within_dem:\n nb_z[0:5,0:5] = misc.RasterSubset(dem,(cell_Y-2),(cell_Y+3),(cell_X-2),(cell_X+3))\n else:\n #Get the part of moving window within the DEM domain\n in_data= misc.RasterSubset(dem,max((cell_Y-2),0),min((cell_Y+3),rows),max((cell_X-2),0),min((cell_X+3),cols))\n #in_data=dem[\"array\"][max((cell_Y-2),0):min((cell_Y+3),rows),max((cell_X-2),0):min((cell_X+3),cols)]\n nb_z[max((2-cell_Y),0):min((5-(cell_Y+3-rows)),5),max((2-cell_X),0):min((5-(cell_X+3-cols)),5)]=in_data[0:in_data.shape[0],0:in_data.shape[1]]\n in_data_avg=np.mean(in_data[in_data>-3.4e+10])\n nb_z[nb_z==0]=in_data_avg\n nb_z[nb_z<-3.4e+10]=in_data_avg\n\n\n \n # If there is missing data in the neighborhood of the sample point \n # use neighborhood average to replace the missing value \n has_missing_data = (nb_z>8848).sum()>0 or (nb_z<-413).sum()>0\n if has_missing_data:\n avgValue=np.mean(nb_z[np.where(np.logical_and(nb_z<8848, nb_z>-413))])\n nb_z[nb_z>8848]=avgValue\n nb_z[nb_z<-413]=avgValue\n \n # Obtain the coordinate of cell centroid of a 5*5 neighborhood around the sample point\n for ii in [0,1,2,3,4]:\n cor_y=ii-2\n dy = (cell_Y+cor_y+0.5) * cellsize[1]\n nb_y[ii,:] = top_left_cor[1] + dy\n for jj in [0,1,2,3,4]:\n cor_x=jj-2\n dx = (cell_X+cor_x+0.5) * cellsize[0]\n nb_x [:,jj] = top_left_cor[0] + dx\n return nb_x, nb_y, nb_z","def get_neighbours(self):\n shape=self.cubeshape[1:]\n neighboursx=np.arange(self.xpos-(self.blocksize-1)/2,(self.xpos+(self.blocksize-1)/2)+1,dtype='int' )\n neighboursx=[x if (x>=0) & (x<=shape[1]-1) else np.nan for x in neighboursx ]\n neighboursy=np.arange(self.ypos-(self.blocksize-1)/2,(self.ypos+(self.blocksize-1)/2)+1,dtype='int' )\n neighboursy=[y if (y>=0) & (y<=shape[0]-1) else np.nan for y in neighboursy ]\n keys=[np.ravel_multi_index([y,x], shape) if np.all(np.isfinite(np.asarray([y,x]))) else np.nan for y in neighboursy for x in neighboursx]\n\n return keys","def GetInteriorEdgesPent(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesPent()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesPent()\n\n sorted_all_edges = np.sort(self.all_edges,axis=1)\n sorted_boundary_edges = np.sort(self.edges,axis=1)\n\n x = []\n for i in range(self.edges.shape[0]):\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\n pos_interior_edges = np.where(interior_edges==0)[0]\n if pos_interior_edges.shape[0] != 0:\n x.append(pos_interior_edges)\n\n edge_aranger = np.arange(self.all_edges.shape[0])\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\n interior_edges = self.all_edges[edge_aranger,:]\n\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\n edge_flags[edge_aranger] = 0\n\n self.interior_edges = interior_edges\n return interior_edges, edge_flags","def footprint_corner_indices():","def draw_contours(self, image, maskImg):\r\n # Required variables..\r\n x, y, width, height = 0, 0, 0, 0\r\n # Find contours..\r\n contours, hierarchy = cv2.findContours(image=maskImg, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) # Playable Parameters..\r\n # Draw the contours..\r\n for contour in contours:\r\n # Calculate the area of the contour, so can remove unnecessary contours..\r\n area = cv2.contourArea(contour=contour)\r\n if area > 3000: # Playable adjustment..!! Found Good as 3000 for current light condition.. change this if light condition changes..\r\n # Draw the contours to the image -- actual frame..\r\n if self.debug_mode:\r\n cv2.drawContours(image=image, contours=contour, contourIdx=-1, color=(255, 255, 0), thickness=4)\r\n # Find the perimeter of the markers detected...\r\n perimeter = cv2.arcLength(curve=contour, closed=True)\r\n # Approximating/Finding the corners of the image from the obtained corners..\r\n approx_corners = cv2.approxPolyDP(curve=contour, epsilon=0.02 * perimeter, closed=True)\r\n # Find the bounding box rectangle for the approximated corners..\r\n x, y, width, height = cv2.boundingRect(approx_corners)\r\n # Return the values with which a rectangle can be drawn..\r\n return x, y, width, height","def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\n\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\n\n # Since the watershed draws contours, we need to invert the predictions to\n # get the 'inside' blob portion. We also slightly compress the blob portion\n # so we can get a more defining border.\n inverted_contours = 255 - class_contours\n\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\n # remove areas that are not part of the class mask\n inverted_contours[class_mask==0]= 0 # here ?\n\n return inverted_contours","def preprocessing(self, img):\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def watershed(img):\n\ttmp = img.copy()\n\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\n\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n\tkernel = np.ones((3,3), np.uint8)\n\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\n\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\n\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\n\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\n\tsure_fg = np.uint8(sure_fg)\n\tunknown = cv2.subtract(sure_bg, sure_fg)\n\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\n\tmarkers = markers+1\n\tmarkers[unknown==255] = 0\n\tmarkers = cv2.watershed(tmp, markers)\n\ttmp[markers == -1] = [255,0,0]\n\treturn tmp","def find_components(edges, max_components=16):\n # Perform increasingly aggressive dilation until there are just a few\n # connected components.\n\n count = 21\n dilation = 5\n n = 1\n while count > 16:\n n += 1\n dilated_image = dilate(edges, N=3, iterations=n)\n dilated_image = np.uint8(dilated_image)\n contours, hierarchy = cv2.findContours(dilated_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n count = len(contours)\n # print dilation\n # Image.fromarray(edges).show()\n # Image.fromarray(255 * dilated_image).show()\n return contours","def getContours(img):\n # mode: gets only exrteme outer contours\n # method: stores all contour points\n contours, hierarchy = cv2.findContours(img, mode=cv2.RETR_EXTERNAL,\n method=cv2.CHAIN_APPROX_NONE)\n \n x, y, w, h = 0, 0, 0, 0\n\n # improving accuracy of contours\n for cnt in contours:\n area = cv2.contourArea(cnt)\n if area > 500:\n # assumes cnt with area > 500 is closed contour \n perimeter = cv2.arcLength(cnt, True)\n\n # approximate polygonal curve of cnt\n # set max difference between original and approxCurve as \n # 0.02 * perimeter\n approxCurve = cv2.approxPolyDP(cnt, 0.02 * perimeter, closed=True)\n \n x, y, w, h = cv2.boundingRect(approxCurve)\n # wand point is is center-left tip\n return x + (w // 2), y","def identify_dbs(image):\n locations = {\"red\": Point(), \"green\": Point(), \"blue\": Point()}\n masks = {\"red\": [], \"green\": [], \"blue\": []}\n\n bridge = cv_bridge.CvBridge()\n image = bridge.imgmsg_to_cv2(image, \"bgr8\")\n hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n\n # upper and lower bounds for red\n # using python 3 bgr [0,0,188] = hsv [0, 255, 188]\n lower_red = numpy.array([0, 100, 100]) \n upper_red = numpy.array([10, 255, 255])\n masks[\"red\"] = cv2.inRange(hsv, lower_red, upper_red)\n\n # upper and lower bounds for green\n # using python 3 bgr [0,175,0] = hsv [60, 255, 175]\n lower_green = numpy.array([50, 100, 100]) \n upper_green = numpy.array([70, 255, 255])\n masks[\"green\"] = cv2.inRange(hsv, lower_green, upper_green)\n\n # upper and lower bounds for blue\n # using python 3 bgr [176, 0, 17] = hsv [123, 255, 176]\n lower_blue = numpy.array([113, 100, 100])\n upper_blue = numpy.array([133, 255, 255])\n masks[\"blue\"] = cv2.inRange(hsv, lower_blue, upper_blue)\n\n x, y, w, h = 0, 0, image.shape[1]//3, image.shape[0]\n\n for color, mask in masks.items():\n pixels = {\"left\": 0, \"middle\": 0, \"right\": 0}\n \n # define section of image to use for left, middle and right\n left = mask[y:y+h, x:x+w]\n middle = mask[y:y+h, x+w:x+w+w]\n right = mask[y:y+h, x+w+w:x+3*w]\n\n # count the number of pixels in each section\n pixels[\"left\"] = cv2.countNonZero(left)\n pixels[\"middle\"] = cv2.countNonZero(middle)\n pixels[\"right\"] = cv2.countNonZero(right)\n location = max(pixels, key=pixels.get)\n\n # map the relative position of the db (left, middle, right) to the correct Point()\n locations[color] = db_locations[location]\n \n return locations","def get_pair_rects(contours):\n\n rect_pairs = []\n for index, cnt in enumerate(contours):\n # Rotated rect - ( center (x,y), (width, height), angle of rotation )\n rect = cv2.minAreaRect(cnt)\n center_x, center_y = rect[0]\n rect_angle = -round(rect[2], 2)\n\n if rect_angle > 45.0:\n # Iterate through all of the potential matches\n min_x_dist = min_rect = min_index = None\n for pot_index, pot_match in enumerate(contours):\n if np.array_equal(pot_match, cnt):\n continue\n\n match_rect = cv2.minAreaRect(pot_match)\n\n # Check if match is to the right of the contour\n if match_rect[0][0] > rect[0][0] and abs(\n match_rect[2] - rect_angle) > ANGLE_TOLERANCE_DEG:\n x_distance = match_rect[0][0] - rect[0][0]\n\n if min_x_dist is None or x_distance < min_x_dist:\n min_x_dist = x_distance\n min_rect = match_rect\n min_index = pot_index\n\n if min_rect is not None:\n rect_pairs.append((rect, min_rect))\n np.delete(contours, index)\n np.delete(contours, min_index)\n\n return rect_pairs","def drawcntMap(orgimg,filteredimg,wThresh,hThresh):\r\n _, contour, _ = cv2.findContours(filteredimg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\r\n\r\n cnt = cv2.drawContours(orgimg.copy(), contour, -1, (0, 0, 255), 2) # To draw filtered contours on original image\r\n\r\n digitCnts = [] # contours to be surrounded by bounding boxes\r\n\r\n for c in contour:\r\n (x, y, w, h) = cv2.boundingRect(c)\r\n if w >= wThresh and h >= hThresh and w*h <20000: # Length filters to reduce noise\r\n cv2.rectangle(cnt,(x,y),(x+w,y+h),[0,255,0],2)\r\n digitCnts.append(c)\r\n\r\n return cnt, digitCnts","def cell_based_hist_segmentation(img, cells=[32, 32]):\n descriptor = []\n w,h = img.shape[:2]\n w_ranges = [(i*w)//cells[0] for i in range(cells[0])]+[-1]\n h_ranges = [(i*h)//cells[1] for i in range(cells[1])]+[-1]\n\n celled_hist = obtain_celled_histograms(img, cells, w_ranges, h_ranges)\n\n rectangular_segm = obtain_rectangular_segmentation(celled_hist, cells)\n mask = create_mask(rectangular_segm, img, cells)\n return mask","def find_shapes(im_bw, kernel, th):\n im_convolved = scipy.ndimage.filters.convolve(im_bw, kernel[::-1, ::-1])\n im_hotspots = im_convolved >= th\n bin_dy, bin_dx = kernel.shape\n radius_x = bin_dx // 2\n radius_y = bin_dy // 2\n positions = []\n open_for_interpretation = np.ones_like(im_convolved, dtype=bool)\n xmax = im_hotspots.shape[1] - 1\n ymax = im_hotspots.shape[0] - 1\n for x in range(xmax + 1):\n for y in range(ymax + 1):\n if open_for_interpretation[y, x] and im_hotspots[y, x]:\n x0 = max(0, x - radius_x)\n x1 = min(xmax, x + radius_x)\n y0 = max(0, y - radius_y)\n y1 = min(ymax, y + radius_y)\n window = im_hotspots[y0:y1, x0:x1]\n cx, cy = center_of_mass(window, x_offset=x - radius_x, y_offset=y - radius_y)\n positions.append([cx, cy])\n open_for_interpretation[y0:y1, x0:x1] = False\n return positions","def read_board_values(self):\r\n\r\n # Iterate through each contour/cell\r\n for row in self.game_board_contours:\r\n board_row = []\r\n\r\n # For each cell, we get its location and crop the original thresholded image to that location\r\n for c in row:\r\n x, y, w, h = cv2.boundingRect(c)\r\n x_margin = int(w * 0.05)\r\n y_margin = int(h * 0.05)\r\n cropped_image = self.thresh_orig[y + y_margin:y + h - 2 * y_margin, x + x_margin:x + w - 2 * x_margin]\r\n\r\n # If it's mostly white, we don't need to waste time with OCR and we know it is blank\r\n if np.average(cropped_image) > 253:\r\n board_row.append(0)\r\n\r\n # Otherwise we pass it to the OCR to see which character is present within that cell\r\n else:\r\n character = pytesseract.image_to_string(cropped_image, config=self.pytesseract_config)\r\n # If the character is a commonly mis-read one, use dictionary to find the real character\r\n if character in self.replacements:\r\n character = self.replacements[character]\r\n board_row.append(character)\r\n self.game_board.append(board_row)","def find_contours(mask):\n _, contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_KCOS)\n return contours","def get_neighbours(self, cell):\n\t\tx,y = cell.find_id()\n\t\tlength = self.space.shape[1]\n\t\twidth = self.space.shape[0]\n\t\tif (length == 0 or width == 0 or x < 0 or x >= length or y < 0 or y >= width):\n\t\t\treturn []\n\t\tneighs = [(i,j) for i in range(y-1,y+2) if 0<=i<width for j in range(x-1,x+2) if 0<=j<length]\n\t\tneighbours = []\n\t\tfor neigh in neighs:\n\t\t\tneighbours.append(self.space[neigh[0],neigh[1]])\n\t\treturn neighbours","def find_contours(mask):\n\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,\n cv2.CHAIN_APPROX_SIMPLE)\n cnts = imutils.grab_contours(cnts)\n return cnts","def contextualcull(cnts):\n temp = []\n actualout = []\n indicesused = []\n for cnt in cnts:\n if cnt.area > CULL_MINIMUMS[cnt.spatialindex]:\n temp.append(cnt)\n if cnt.spatialindex not in indicesused:\n indicesused.append(cnt.spatialindex)\n if PRIORITIZE_FASTEST:\n for sindex in indicesused: #filter down to the fastest contour.\n _allatthisindex = [x for x in temp if x == sindex]\n highest = _allatthisindex.sort(key=lambda y: y.spd, reverse=False)[0]\n actualout.append(highest)\n else:\n actualout = temp\n print 'Contours after cull: ', len(actualout)\n return actualout","def get_cntr_points_from_center(self, contour, img_size):\n res_arr = []\n half_img_size = int(np.round(img_size/3))\n diag_coord = np.random.randint(half_img_size,2*half_img_size)\n # find the center point\n center_point = [diag_coord,diag_coord]\n # define all borders point\n border = ([[0,i] for i in np.arange(0,img_size)] + \n [[img_size,i] for i in np.arange(0,img_size)] +\n [[i,0] for i in np.arange(0,img_size)] + \n [[i,img_size] for i in np.arange(0,img_size)])\n for point in border:\n tmp_res = []\n row_diff = point[0] - center_point[0]\n col_diff = point[1] - center_point[1]\n # find the distance between center point and border point\n dist = int(np.round(np.sqrt(row_diff*row_diff+col_diff*col_diff)))\n # find steps for row and column to go from center to border\n row_step = row_diff/dist\n col_step = col_diff/dist\n \n row_diff = center_point[0]\n col_diff = center_point[1]\n c_point = [int(np.round(row_diff)),\n int(np.round(col_diff))]\n\n # go from center to border until points inside image\n while ((c_point[0]>= 0) \n and (c_point[0] < img_size) \n and (c_point[1]>= 0) \n and (c_point[1] < img_size)):\n if cv2.pointPolygonTest(contour,(c_point[0],c_point[1]),True)> 0:\n tmp_res.append(c_point)\n row_diff = row_diff + row_step\n col_diff = col_diff + col_step\n c_point = [int(np.round(row_diff)),\n int(np.round(col_diff))]\n if len(tmp_res):\n res_arr.append(tmp_res)\n return res_arr","def find_contours(dframe):\n #Blur the image.\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\n #if debug:\n #plt.imshow(fixColor(blurred))\n #plt.show()\n #Get a threshold image, numbers where tested for the given video.\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \n cv2.CHAIN_APPROX_SIMPLE)\n return cnts","def get_contour(atom_list):\n initial = [atom for atom in atom_list if ((0 < len(identify_bonds(atom, atom_list)) < 3) and (check_connected(atom, identify_bonds(atom, atom_list)) == False))]\n \n extra_1 = []\n for atom in atom_list:\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\n for i in neighbours:\n neighbours2 = [bond[0] for bond in identify_bonds(i, atom_list)]\n for j in neighbours2:\n if j in initial:\n extra_1.append(atom)\n\n extra_2 = []\n for atom in atom_list:\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\n check = 0\n for i in neighbours:\n if i in initial:\n check += 1\n if ((check == 2) and (atom not in initial)):\n extra_2.append(atom) \n return (initial + extra_1 + extra_2)","def get_table_corner_points(img):\n\n img_height, img_width, img_channels = img.shape\n lower_bounds,upper_bounds = get_table_color_bounds() # Get the bounds for the table felt color\n\n \"\"\"\n Table Image Masking\n \"\"\"\n res = cv2.cvtColor(img,cv2.COLOR_BGR2HSV) # Convert image to HSV color space\n mask = cv2.inRange(res,lower_bounds,upper_bounds) # Get image mask from bounds\n res = cv2.bitwise_and(img,img,mask = mask) # Mask the image\n\n \"\"\"\n Contour Detection\n \"\"\"\n imgray = cv2.cvtColor(res,cv2.COLOR_BGR2GRAY) # Get res in gray color space\n tmp,thresh = cv2.threshold(imgray,255,255,255) # Threshold on the gray image\n retr = cv2.RETR_EXTERNAL # Contour parameters\n mode = cv2.CHAIN_APPROX_SIMPLE\n tmp, contours, hierarchy = cv2.findContours(thresh,retr,mode) # Get contours\n res = np.zeros((img_height,img_width,3),np.uint8) # Blank image for contours\n color = (255,255,255) # Contour drawing parameters\n thickness = 3\n cv2.drawContours(res,contours,-1,color,thickness) # Draw contours on blank image\n\n \"\"\"\n Canny Detection\n \"\"\"\n blur = 9 # Blur parameter \n res = cv2.medianBlur(res,blur) # Blur\n res = cv2.Canny(res,100,150,apertureSize = 3) # Canny edge detection\n\n \"\"\"\n Hough Line Detection\n \"\"\"\n rho = 0.75 # Hough parameters\n theta = np.pi/180\n threshold = 150\n lines = cv2.HoughLines(res,rho,theta,threshold) # Get lines\n\n \"\"\"\n K-Mean 4 Line Clustering\n \"\"\"\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,10,1.0) # K-Means parameters\n flags = cv2.KMEANS_PP_CENTERS\n n = 4\n max_iterations = 10 \n compactness,labels,centers = cv2.kmeans(np.float32(lines),n,None,criteria,max_iterations,flags) # K-Means\n \n \"\"\"\n Get And Return Points\n \"\"\"\n growth = 100 # Offset to expand corners\n pts = _get_table_corners_from_lines_hough_space(centers,growth,img_width,img_height) # Gets the corner points\n ''' \n mask = np.zeros((img_height,img_width,3),np.uint8)\n cv2.fillPoly(mask,np.array([pts],dtype = np.int32),(255,255,255))\n show_img(mask)\n cv2.resize(mask,(img.shape[0],img.shape[1]),fx = 2, fy = 2, interpolation = cv2.INTER_CUBIC)\n show_img(mask*2)\n res = cv2.bitwise_and(img,mask)\n '''\n return pts","def find_contour(hole_atoms, atom_list):\n contour_atoms = []\n extra_atoms = []\n global bond_list\n bond_list = bond_list_1\n for atom in hole_atoms:\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond[0] not in hole_atoms) and (bond[0] not in contour_atoms))]\n for element in c:\n contour_atoms.append(element)\n for atom in atom_list:\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\n count = 0\n for element in c:\n if element in contour_atoms:\n count += 1\n if (count >= 2):\n extra_atoms.append(atom)\n for atom in atom_list:\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\n for element in c:\n if ((element in contour_atoms) or (element in extra_atoms)):\n for i in [bond[0] for bond in identify_bonds(element, atom_list)]:\n if ((i in hole_atoms) and (atom not in hole_atoms) and (atom not in contour_atoms) and (atom not in extra_atoms)):\n extra_atoms.append(atom) \n \n contour_atoms = contour_atoms + extra_atoms\n \n extra_atoms2 = []\n for atom in contour_atoms:\n for atom2 in contour_atoms:\n if (atom != atom2):\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond in identify_bonds(atom2, atom_list)) and (bond[0] not in (contour_atoms)))]\n if (len(c) != 0):\n extra_atoms2.append(c[0]) \n for element in extra_atoms2:\n contour_atoms.append(element)\n return contour_atoms","def analyzeContours(contours):\n if len(contours[0]) != 4 and len(contours[0]) != 8:\n return 0\n\n first, second, prev = [1, 1], [1, 1], 0\n for i, val in enumerate(numpy.nditer(contours[0])):\n if i % 2:\n second = [prev, val]\n else:\n first = [prev, val]\n\n # compare pair to the previous pair\n for num in first:\n if num in second:\n break\n else:\n return 0\n\n prev = val\n\n return 1","def get_patch_centers(self):\n rows, cols = np.where(self.inv_overlap_mask)\n patch_centers = tuple(zip(rows, cols))\n # diff = np.diff(patch_centers)\n # ind_stop_cont = np.where(np.abs(np.diff(np.reshape(diff, diff.shape[0]))) > 1)[0][0]\n self.patch_centers = patch_centers[:: self.sampling_int // 2]\n print(\"# of samples: {}\".format(len(self.patch_centers)))","def get_position_patterns(contours, hierarchy):\n found = []\n for i in range(len(contours)):\n k = i\n c = 0\n while hierarchy[k][2] != -1:\n k = hierarchy[k][2]\n c += 1\n if c >= 5:\n found.append(i)\n return found","def obtain_rectangular_segmentation(celled_hist, cells):\n celled_hist = np.array(celled_hist).reshape(cells[0]*cells[1], -1)\n scores = l1_dist(celled_hist, celled_hist)\n\n layers = cells[0]//2\n \n left, right, top, bottom = compute_positions(scores, layers, cells, \"lr\"), compute_positions(scores, layers, cells, \"rl\"), \\\n compute_positions(scores, layers, cells, \"tb\"), compute_positions(scores, layers, cells, \"bt\")\n\n return left, right, top, bottom","def select_contours(img):\n # Find contours at a constant value\n contours = measure.find_contours(img, 300)\n # print(\"Found \" + str(len(contours)) + \" contour(s)\")\n # Select the nearest contours with respect to the center pixel of the image\n width = img.shape[1] # number of columms\n heigth = img.shape[0] # number of rows\n pixel_ref = (width / 2, heigth / 2)\n # Threshold distance is 10% of images smallest dimension\n dist_thresh = min(width, heigth) * 0.1\n contours_wanted = []\n pixel_mean_array = []\n for contour in contours:\n contour_3d = np.zeros([contour.shape[0], 3]) # 3rd dimension added for later conversion to patient coord space\n contour_3d[:, :2] = contour\n pixel_mean = np.mean(contour, axis=0)\n if distance.euclidean(pixel_ref, pixel_mean) <= dist_thresh:\n contours_wanted.append(contour_3d)\n pixel_mean_array.append(pixel_mean)\n # print(\"Set \" + str(len(contours_wanted)) + \" contours of interest\")\n return contours_wanted, pixel_mean_array","def computesWingConnexions(self):\n logger.warning(\"!!! WARINING !!!!\")\n logger.warning(\"BE CERTAIN THAT CPACS FILE HAS THE HORIZONTAL TAIL\")\n logger.warning(\"DEFINED BEFORE THE VERTICAL TAIL!!!!\")\n if self.nWings <= 1:\n logger.info(\"No wing connexions needed\")\n elif self.nWings > 1 and self.nFuselage < 1:\n logger.error(\"Multiple wings with no fuselage! Mesh can not be computed\")\n sys.exit()\n else:\n ws_connextionsPoints = self.nWings + self.nFuselage - 1\n # if self.nFuselage > 0:\n # ws_connextionsPoints = self.nWings\n # else:\n # ws_connextionsPoints = self.nWings -1\n\n # ws: wings\n # d: distance\n # L: left, R: right, c: center\n connectedNodes = np.zeros((ws_connextionsPoints,5))\n for i in range(ws_connextionsPoints):\n \"\"\"\n for each wing there is 3 points that need to be taken into\n account:\n 1) Left tip position[0]\n 2) center [np.floor(nNodes/2))]\n WARNING: keep in mind that symmetric wings always have \n an odd number of points!\n 3) right tip position[-1]\n \"\"\"\n if self.nFuselage > 0:\n wingIndex = i+1\n else:\n wingIndex = i\n # logger.debug(\"Wing index = \"+str(wingIndex))\n # N = len(self.aircraftNodesPoints[i])\n currentWingNpoints = len(self.aircraftNodesPoints[wingIndex])\n if currentWingNpoints > 2:\n c = int(np.floor(len(self.aircraftNodesPoints[wingIndex])/2))\n else:\n c = 0\n # logger.debug(\"c = \"+str(c))\n ws_identifiers = np.empty((ws_connextionsPoints,5))\n\n for j in range(ws_connextionsPoints+1):\n logger.debug(\"wingIndex,j = \"+str(wingIndex)+\" \"+str(j))\n if wingIndex != j:\n # c: stands for current\n logger.debug(\"True with wingIndex,j = \"+str(wingIndex)+\" \"+str(j))\n # Computes the distances between all point\n dist_l = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][0], axis=1)\n if currentWingNpoints > 2:\n dist_c = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][c], axis=1)\n else:\n dist_c = dist_l\n dist_r = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][-1],axis=1)\n\n # Gets the index of the minimal distance between all point\n index_l = np.argmin(dist_l)\n if currentWingNpoints > 2:\n index_c = np.argmin(dist_c)\n else:\n index_c = index_l\n index_r = np.argmin(dist_r)\n indexes = np.array([index_l, index_c, index_r])\n\n # gets the minimal distance for each wing part\n minDist_l = dist_l[index_l]\n if currentWingNpoints > 2:\n minDist_c = dist_c[index_c]\n else:\n minDist_c = minDist_l\n minDist_r = dist_r[index_r]\n minDist = np.array([minDist_l,minDist_c,minDist_r])\n\n k = np.argmin(minDist)\n minimalDistance = minDist[k]\n m = indexes[k]\n r = len(self.aircraftNodesPoints[wingIndex])\n tab = np.array([0,c,r])\n k = tab[k]\n\n # minimalDistance: distance between both of these points\n identifier = np.array([wingIndex,j,k,m,minimalDistance])\n # logger.debug(\"Identifier \\n\"+str(identifier))\n if j < wingIndex:\n ws_identifiers[j] = identifier\n else:\n ws_identifiers[j-1] = identifier\n \n index2 = np.argmin(ws_identifiers[:,4])\n old = np.array([ws_identifiers[index2,2],\n ws_identifiers[index2,3],\n ws_identifiers[index2,0],\n ws_identifiers[index2,1],\n ws_identifiers[index2,4]])\n if old in connectedNodes and i > 1:\n logger.warning(\"Found a matching connexion\")\n logger.debug(old)\n logger.debug(ws_identifiers)\n ws_identifiers = np.delete(ws_identifiers,index2,0)\n logger.debug(ws_identifiers)\n index2 = np.argmin(ws_identifiers[:,4])\n connectedNodes[i] = ws_identifiers[index2]\n logger.debug(\"connected Nodes: \\n\"+str(connectedNodes[i]))\n # logger.debug(connectedNodes)\n \n self.aircraftConnectedNodes.append(connectedNodes)\n self.rigidNodesAdder()\n # sys.exit()","def cell_merge(wsh, pred):\n wshshape=wsh.shape\n \n # masks for the original cells\n objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\t\n \n # masks for dilated cells\n dil_objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\n \n # bounding box coordinates\t\n obj_coords = np.zeros((wsh.max()+1,4))\n \n # cleaned watershed, output of function\t\n wshclean = np.zeros((wshshape[0],wshshape[1]))\n \n # kernel to dilate objects\n kernel = np.ones((3,3), dtype=bool)\t\n \n for obj1 in range(wsh.max()):\n # create masks and dilated masks for obj\n objs[obj1,:,:] = wsh==(obj1+1)\t\n dil_objs[obj1,:,:] = dilation(objs[obj1,:,:], kernel)\t\n \n # bounding box\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\n \n objcounter = 0\t# counter for new watershed objects\n \n for obj1 in range(wsh.max()):\t\n dil1 = dil_objs[obj1,:,:]\n\n # check if mask has been deleted\n if np.sum(dil1) == 0:\n continue\n \n objcounter = objcounter + 1\n orig1 = objs[obj1,:,:]\n\n for obj2 in range(obj1+1,wsh.max()):\n dil2 = dil_objs[obj2,:,:]\n \n # only check border if bounding box overlaps, and second mask \n # is not yet deleted\n if (do_box_overlap(obj_coords[obj1,:], obj_coords[obj2,:])\n and np.sum(dil2) > 0):\n \n border = dil1 * dil2\t\n border_pred = pred[border]\n \n # Border is too small to be considered\n if len(border_pred) < 32:\n continue\n \n # Sum of top 25% of predicted border values\n q75 = np.quantile(border_pred, .75)\n top_border_pred = border_pred[border_pred >= q75]\n top_border_height = top_border_pred.sum()\n top_border_area = len(top_border_pred)\n \n # merge cells\n if top_border_height / top_border_area > .99:\n orig1 = np.logical_or(orig1, objs[obj2,:,:])\n dil_objs[obj1,:,:] = np.logical_or(dil1, dil2)\n dil_objs[obj2,:,:] = np.zeros((wshshape[0], wshshape[1]))\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\n \n wshclean = wshclean + orig1*objcounter\n \n return wshclean","def find_rects_white(image: np.ndarray) -> List[np.ndarray]:\n\n raise NotImplementedError()\n\n #gray = norm_color_test(image.copy())\n gray = cv.cvtColor(image.copy(), cv.COLOR_RGB2GRAY)\n gray = cv.GaussianBlur(gray, (5, 5), 0)\n #edged = cv.Canny(gray, 70, 180) # this numbers is hand picked guess from a few photos\n edged = auto_canny(gray) # this numbers is hand picked guess from a few photos\n\n # split to HSV, then pick up rouhly any white color zeroing out the rest\n hsv = cv.cvtColor(image.copy(), cv.COLOR_RGB2HSV)\n h,s,v = cv.split(hsv)\n h[h<145] = 0\n h[h>165] = 0\n #h = cv.GaussianBlur(h, (5, 5), 0)\n normed = cv.normalize(h, None, 0, 255, cv.NORM_MINMAX, cv.CV_8UC1)\n kernel = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(5,5))\n opened = cv.morphologyEx(normed, cv.MORPH_OPEN, kernel)\n\n # now find white regions contours\n whites = cv.findContours(opened, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)[0]\n whites.sort(key=cv.contourArea, reverse=True)\n whites = [cnt for cnt in whites if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\n\n whiterects = []\n for i in whites:\n rect = cv.minAreaRect(i)\n w,h = rect[1]\n if w*h > 150: # 150px area, or rougly 12x12 pixels\n whiterects.append(rect)\n\n #cv.drawContours(image, whites, -1, COLORS[2 % len(COLORS)], 2)\n #cv.imshow('test', image)\n #cv.waitKey()\n\n whites = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), whiterects))\n\n\n\n #cv.imshow('test', edged)\n #cv.waitKey()\n\n contours = cv.findContours(edged.copy(), cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)\n contours = contours[0] if len(contours) == 2 else contours[1]\n contours.sort(key=cv.contourArea, reverse=True)\n contours = [cnt for cnt in contours if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\n\n rects = list(map(cv.minAreaRect, contours))\n boxes = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), rects))\n\n # filter non overlapping contours\n for i in reversed(range(len(boxes))):\n overlaps = False\n for wbox in whites:\n if wbox.overlaps(boxes[i]):\n overlaps = True\n break\n if not overlaps:\n boxes.pop(i)\n\n boxes = Rect.nms_merge(boxes)\n\n for i in range(len(contours)):\n #peri = cv.arcLength(contours[i], True)\n #approx = cv.approxPolyDP(contours[i], 0.02 * peri, True)\n rect = cv.minAreaRect(contours[i])\n box = cv.boxPoints(rect)\n box = np.int0(box)\n #cv.drawContours(image, [box], -1, COLORS[i % len(COLORS)], 2)\n #cv.putText(image, f'{i}: {cv.contourArea(contours[i])}px', (int(rect[0][0]), int(rect[0][1])), cv.FONT_HERSHEY_SIMPLEX, 0.6, COLORS[i % len(COLORS)], 1)\n\n #cv.drawContours(image, contours, -1, COLORS[1], 2)\n\n for b in boxes:\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmax), int(b.ymin)), (0, 255, 255), 2)\n cv.line(image, (int(b.xmin), int(b.ymax)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmin), int(b.ymax)), (0, 255, 255), 2)\n cv.line(image, (int(b.xmax), int(b.ymin)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\n\n stacked = np.hstack( (cv.cvtColor(edged, cv.COLOR_GRAY2RGB), cv.cvtColor(opened, cv.COLOR_GRAY2RGB), image))\n cv.namedWindow('test', 0)\n cv.imshow('test', stacked)\n cv.waitKey()\n\n cv.imwrite('dump.jpg', stacked)\n\n\n return boxes or list()","def find_contours(vertical, horizontal):\n\tmask = vertical + horizontal\n\n\ttry:\n\t\t__, contours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\texcept ValueError:\n\t\t# for opencv backward compatibility\n\t\tcontours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\t# sort in reverse based on contour area and use first 10 contours\n\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\n\n\tcont = []\n\tfor c in contours:\n\t\tc_poly = cv2.approxPolyDP(c, 3, True)\n\t\tx, y, w, h = cv2.boundingRect(c_poly)\n\t\tcont.append((x, y, w, h))\n\treturn cont","def register_cells(contours: List[np.array]) -> np.array:\n def create_cell(contour: np.array) -> np.array:\n center, radius = cv2.minEnclosingCircle(contour)\n v = (0, 0)\n weight = -1\n\n return np.array([center[0], center[1], v[0], v[1], radius, weight])\n\n areas = np.array([cv2.contourArea(contour) for contour in contours]).astype(\"float32\")\n blobs = np.array([create_cell(contour) for contour in contours]).astype(\"int32\")\n\n return blobs[areas >= 100].astype(\"float32\")","def getContours( self,img ):\n if( len(img.shape) == 3):\n (_, contours, _) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n else:\n (contours,_) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def findings_2_idx(findings, corner_2_idx, funcx, funcy):\n idx = []\n for finding in findings:\n x, y = finding\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\n idx.extend([corner_2_idx(c) for c in mesh])\n\n return np.unique(idx)","def _get_end_points(self, segmented_instances, i, stats, idx):\n\n end_points=[]\n\n # find all points intersecting the bbox\n #(tl_x, th_y, width, height, area)\n label_num=i+1\n leftmost_x = stats['bbox'][i][cv2.CC_STAT_LEFT]\n topmost_y = stats['bbox'][i][cv2.CC_STAT_TOP]\n width = stats['bbox'][i][cv2.CC_STAT_WIDTH]\n height = stats['bbox'][i][cv2.CC_STAT_HEIGHT]\n bottom_most_y = topmost_y + height-1\n right_most_x = leftmost_x + width-1\n\n segmented_instances_copy=segmented_instances.copy()\n edge_points = np.zeros(segmented_instances.shape).astype(np.uint8)\n segs = np.zeros(segmented_instances.shape).astype(np.uint8)\n segs[segmented_instances==label_num]=255\n cv2.rectangle(segmented_instances_copy,(leftmost_x, topmost_y), (right_most_x, bottom_most_y), 150, 2)\n\n #Get all points for the current stem segment\n label_points = np.argwhere(segmented_instances.copy()==label_num)\n\n # upper points from (tl_x,th_y) to (th_x, th_y) that instersect with the upper edge of the bouding box\n upper_points = [i for i in label_points if i[0]==topmost_y and i[1]>=leftmost_x and i[1]<=right_most_x]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(upper_points, edge_points, segs, 1)\n center_upper_pts = sorted(self._get_centeroids(x_pts))\n\n # left side points from (tl_x, tl_y) to (tl_x, th_y) that instersect with the left edge of the bouding box\n left_points = [i for i in label_points if i[1]==leftmost_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(left_points, edge_points, segs, 0)\n center_left_pts = sorted(self._get_centeroids(x_pts))\n\n #right side points form (th_x, tl_y) to (th_x, th_y) that instersect with the right edge of the bouding box\n right_points = [i for i in label_points if i[1]==right_most_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(right_points, edge_points, segs, 0)\n center_right_pts = sorted(self._get_centeroids(x_pts))\n\n #bottom points from (tl_x, tl_y) to (th_x,tl_y)\n bottom_points = [i for i in label_points if i[1]>=leftmost_x and i[1]<=right_most_x and i[0]==bottom_most_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(bottom_points, edge_points, segs, 1)\n center_bottom_pts = sorted(self._get_centeroids(x_pts))\n\n # If there are corner edges, get the centroid of that\n center_x_lb, center_y_lb, center_left_pts, center_bottom_pts = self._get_corner_centers(center_left_pts, \\\n center_bottom_pts, bottom_most_y, leftmost_x)\n if (center_x_lb != None) and (center_y_lb != None):\n end_points.append([center_x_lb, center_y_lb])\n else:\n if len(center_left_pts)>0:\n for pt_idx in range(0, len(center_left_pts)):\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\n if len(center_bottom_pts)>0:\n for pt_idx in range(0, len(center_bottom_pts)):\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\n\n # If there are corner edges, get the centroid of that\n center_x_ur, center_y_ur, center_right_pts, center_upper_pts = self._get_corner_centers(center_right_pts, \\\n center_upper_pts, topmost_y, right_most_x)\n if (center_x_ur != None) and (center_y_ur != None):\n end_points.append([center_x_ur, center_y_ur])\n else:\n if len(center_right_pts)>0:\n for pt_idx in range(0, len(center_right_pts)):\n end_points.append([right_most_x, center_right_pts[pt_idx]])\n if len(center_upper_pts)>0:\n for pt_idx in range(0, len(center_upper_pts)):\n end_points.append([center_upper_pts[pt_idx], topmost_y])\n\n # If there are corner edges, get the centroid of that\n center_x_ul, center_y_ul, center_left_pts, center_upper_pts = self._get_corner_centers(center_left_pts, \\\n center_upper_pts, topmost_y, leftmost_x)\n if (center_x_ul != None) and (center_y_ul != None):\n end_points.append([center_x_ul, center_y_ul])\n else:\n if len(center_left_pts)>0:\n for pt_idx in range(0, len(center_left_pts)):\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\n if len(center_upper_pts)>0:\n for pt_idx in range(0, len(center_upper_pts)):\n end_points.append([center_upper_pts[pt_idx], topmost_y])\n\n\n # If there are corner edges, get the centroid of that\n center_x_br, center_y_br, center_right_pts, center_bottom_pts = self._get_corner_centers(center_right_pts, \\\n center_bottom_pts, bottom_most_y, right_most_x)\n if (center_x_br != None) and (center_y_br != None):\n end_points.append([center_x_br, center_y_br])\n else:\n if len(center_right_pts)>0:\n for pt_idx in range(0, len(center_right_pts)):\n end_points.append([right_most_x, center_right_pts[pt_idx]])\n if len(center_bottom_pts)>0:\n for pt_idx in range(0, len(center_bottom_pts)):\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\n\n #self.showme(segmented_instances_copy, 'bbox')\n\n return end_points","def get_shapes(self):\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\n X = []\n backmap = {}\n rad = 3\n for k,((i,y),(j,x)) in enumerate(self.mids):\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\n colours[i][j] = m\n X.append(m)\n backmap[k] = (i,j)\n print(np.shape(X))\n Z = linkage(X, 'ward')\n Q = fcluster(Z, self.thresh, criterion='distance')\n\n closenesses = []\n for k,cls in enumerate(Q):\n i,j = backmap[k]\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\n minidx = np.argmin(closenesses)\n bgcls = Q[minidx]\n\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\n img4 = self.img2.copy()\n for k,((i,y),(j,x)) in enumerate(self.mids):\n cls = Q[k]\n if cls == bgcls:\n continue\n col = blibs[(cls-1)]\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\n\n write_img(\"./out/test_classes.png\", img4)\n self.classimg = img4\n\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\n mx = np.max(Q)\n for k,cls in enumerate(Q):\n if cls == bgcls:\n continue\n\n if cls == mx:\n plotcls = bgcls\n else:\n plotcls = cls\n i,j = backmap[k]\n A[i][j] = plotcls\n\n self.res = A","def find_neighbors(masks, i, r=1):\n \n mask = np.uint8(masks == i)\n # create the border in which we'll look at other masks\n kernel = morphology.disk(r)\n dilated = cv.dilate(mask, kernel, iterations=1)\n dilated = dilated.astype(np.bool)\n # detect potential touching masks\n neighbors = np.unique(masks[dilated])\n # discard the initial cell id of interest\n neighbors = neighbors[neighbors != i]\n # discard the background value\n return neighbors[neighbors != 0]","def get_integral_descriptors(image,filtered_coords,wid=5):\n desc = []\n for coords in filtered_coords:\n patch = image[coords[0]-wid:coords[0]+wid+1,\n coords[1]-wid:coords[1]+wid+1]\n desc.append(patch)\n return desc","def get_descriptors(image,filtered_coords,wid=5):\n desc = []\n for coords in filtered_coords:\n patch = image[coords[0]-wid:coords[0]+wid+1,\n coords[1]-wid:coords[1]+wid+1].flatten()\n desc.append(patch)\n return desc","def find_contours(img_path, **kwargs):\n threshold = kwargs['threshold']\n image = cv2.imread(img_path)\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n blurred = cv2.GaussianBlur(gray, (5, 5), 0)\n thresh = cv2.threshold(blurred, threshold, 255, cv2.THRESH_BINARY)[1]\n contours, _ = cv2.findContours(thresh.copy(),\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n\n\n contour_areas = [] # TODO: is there a faster way to keep the contors with n-largest areas?\n for i, contour in enumerate(contours):\n area = cv2.contourArea(contour)\n contour_areas.append((i, area))\n\n rect = cv2.minAreaRect(contour)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n cv2.drawContours(image,[box],0,(0,0,255),2)\n cv2.imwrite('rect_{}.png'.format(i), image)\n # Contours that cover the largest areas are whole pieces\n largest_contour_areas = nlargest(10, contour_areas, key=lambda x:x[1])\n #print(largest_contour_areas)\n\n for i, area in largest_contour_areas:\n print (i, area)\n cv2.drawContours(image, contours, i, (100, 155, 100), 3)\n cv2.imwrite('contor_{}.png'.format(i), image)\n return True","def recognize_pieces(edges, v, squares):\n\n pieces = []\n\n v = cv2.equalizeHist(v)\n for p1, p2 in squares:\n # count the number of slightly centered edges\n occupancy = sum(edges[y][x]\n for x in range(p1.x + 5, p2.x - 5)\n for y in range(p1.y + 5, p2.y - 5))\n\n if occupancy > 70*255:\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\n v[p2.y][p1.x], v[p2.y][p2.x])\n\n # average v-component of the corners\n avg = sum(map(float, corners)) / len(corners)\n\n # black pixels should be relatively black\n # when compared to the corner average\n black = sum(v[y][x] / avg < 0.2\n for x in range(p1.x, p2.x + 1)\n for y in range(p1.y, p2.y + 1))\n\n if black >= 1000 and black != 1049:\n color = \"B\"\n else:\n color = \"W\"\n\n pieces.append(color)\n else:\n pieces.append(None)\n\n return pieces","def findFours(self):\n\n for i in range(6):\n for j in range(7):\n if self.board[i][j] != ' ':\n # check if a vertical four-in-a-row starts at (i, j)\n if self.verticalCheck(i, j):\n self.highlightFour(i, j, 'vertical')\n \n # check if a horizontal four-in-a-row starts at (i, j)\n if self.horizontalCheck(i, j):\n self.highlightFour(i, j, 'horizontal')\n \n # check if a diagonal (either way) four-in-a-row starts at (i, j)\n # also, get the slope of the four if there is one\n diag_fours, slope = self.diagonalCheck(i, j)\n if diag_fours:\n self.highlightFour(i, j, 'diagonal', slope)","def get_building_contour(current_building_mask):\n ret, threshed = cv.threshold(current_building_mask, 0, 2 ** 16, cv.THRESH_BINARY)\n compressed = threshed.astype(np.uint8)\n current_building_contour, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n return current_building_contour, hierarchy","def index_by_border(tiles):\n by_border = {\n \"north\": defaultdict(lambda: []),\n \"east\": defaultdict(lambda: []),\n \"south\": defaultdict(lambda: []),\n \"west\": defaultdict(lambda: []),\n }\n borders = {}\n inners = {}\n for tile_id, tile_rows in tiles.items():\n north, east, south, west, inner = get_borders(tile_rows)\n by_border[\"north\"][north].append(tile_id)\n by_border[\"east\"][east].append(tile_id)\n by_border[\"south\"][south].append(tile_id)\n by_border[\"west\"][west].append(tile_id)\n inners[tile_id] = inner\n borders[tile_id] = (north, east, south, west)\n return by_border, borders, inners","def segment_cells(frame, mask=None):\n \n blurred = filters.gaussian(frame, 2)\n ridges = enhance_ridges(frame)\n \n # threshold ridge image\n thresh = filters.threshold_otsu(ridges)\n thresh_factor = 0.5\n prominent_ridges = ridges > thresh_factor*thresh\n prominent_ridges = morphology.remove_small_objects(prominent_ridges, min_size=256)\n prominent_ridges = morphology.binary_closing(prominent_ridges)\n prominent_ridges = morphology.binary_dilation(prominent_ridges)\n \n # skeletonize\n ridge_skeleton = morphology.medial_axis(prominent_ridges)\n ridge_skeleton = morphology.binary_dilation(ridge_skeleton)\n ridge_skeleton *= mask\n ridge_skeleton = np.bitwise_xor(ridge_skeleton, mask)\n \n # label\n cell_label_im = measure.label(ridge_skeleton)\n \n # morphological closing to fill in the cracks\n for cell_num in range(1, cell_label_im.max()+1):\n cell_mask = cell_label_im==cell_num\n cell_mask = morphology.binary_closing(cell_mask, disk(3))\n cell_label_im[cell_mask] = cell_num\n \n return cell_label_im","def _check_intrusion(self, detections):\n width, height = self.frame_size\n\n results = []\n for i in range(len(detections)):\n (bboxes, scores, classes, num_candidates) = detections[i]\n\n in_roi_cands = {}\n for j in range(int(num_candidates[0])):\n # Check if score passes the threshold.\n if scores[0][j] < self.detect_threshold:\n continue\n # Check if the object in in the trigger list.\n # XXX: Is it posssible to generate index that is not in the\n # category_index list?\n try:\n label = self._category_index[int(classes[0][j])]\n except KeyError:\n continue\n else:\n if label not in self.triggers:\n continue\n # Check whether the object's bbox is in roi or not.\n ymin, xmin, ymax, xmax = bboxes[0][j]\n unnormalized_bbox = (xmin * width, ymin * height,\n xmax * width, ymax * height)\n if self._is_in_roi(unnormalized_bbox):\n if not bool(in_roi_cands):\n # This is the first detected object candidate\n in_roi_cands = {\"bboxes\": [], \"scores\": [], \"labels\": []}\n in_roi_cands[\"bboxes\"].append(bboxes[0][j].tolist())\n in_roi_cands[\"scores\"].append(scores[0][j].tolist())\n in_roi_cands[\"labels\"].append(label)\n results.append(in_roi_cands)\n return results","def textDetectWatershed(thresh, original):\n # According to: http://docs.opencv.org/trunk/d3/db4/tutorial_py_watershed.html\n img = resize(original, 3000)\n thresh = resize(thresh, 3000)\n # noise removal\n kernel = np.ones((3,3),np.uint8)\n opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 3)\n \n # sure background area\n sure_bg = cv2.dilate(opening,kernel,iterations=3)\n\n # Finding sure foreground area\n dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\n ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0)\n\n # Finding unknown region\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg,sure_fg)\n \n # Marker labelling\n ret, markers = cv2.connectedComponents(sure_fg)\n\n # Add one to all labels so that sure background is not 0, but 1\n markers += 1\n\n # Now, mark the region of unknown with zero\n markers[unknown == 255] = 0\n \n markers = cv2.watershed(img, markers)\n implt(markers, t='Markers')\n image = img.copy()\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n \n # Creating result array\n boxes = []\n for mark in np.unique(markers):\n # mark == 0 --> background\n if mark == 0:\n continue\n\n # Draw it on mask and detect biggest contour\n mask = np.zeros(gray.shape, dtype=\"uint8\")\n mask[markers == mark] = 255\n\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\n c = max(cnts, key=cv2.contourArea)\n \n # Draw a bounding rectangle if it contains text\n x,y,w,h = cv2.boundingRect(c)\n cv2.drawContours(mask, c, 0, (255, 255, 255), cv2.FILLED)\n maskROI = mask[y:y+h, x:x+w]\n # Ratio of white pixels to area of bounding rectangle\n r = cv2.countNonZero(maskROI) / (w * h)\n \n # Limits for text\n if r > 0.1 and 2000 > w > 15 and 1500 > h > 15:\n boxes += [[x, y, w, h]]\n \n # Group intersecting rectangles\n boxes = group_rectangles(boxes)\n bounding_boxes = np.array([0,0,0,0])\n for (x, y, w, h) in boxes:\n cv2.rectangle(image, (x, y),(x+w,y+h), (0, 255, 0), 8)\n bounding_boxes = np.vstack((bounding_boxes, np.array([x, y, x+w, y+h])))\n \n implt(image)\n\n # Recalculate coordinates to original size\n boxes = bounding_boxes.dot(ratio(original, img.shape[0])).astype(np.int64)\n return boxes[1:]","def detect(image):\n markers = []\n # Stage 1: Detect edges in image\n gray = cvtColor(image, COLOR_BGR2GRAY)\n clahe = createCLAHE(clipLimit=1, tileGridSize=(6, 6))\n cl1 = clahe.apply(gray)\n _, thresh = threshold(cl1, 60, 255, THRESH_OTSU)\n blurred = GaussianBlur(thresh, (5, 5), 0)\n edges = Canny(blurred, 75, 100)\n\n # Stage 2: Find contours\n contours = findContours(edges, RETR_TREE, CHAIN_APPROX_SIMPLE)\n contours = sorted(contours, key=contourArea, reverse=True)[:]\n\n for contour in contours:\n # Stage 3: Shape check\n perimeter = arcLength(contour, True)\n approx = approxPolyDP(contour, 0.01*perimeter, True)\n\n if len(approx) == QUADRILATERAL_POINTS:\n area = contourArea(approx)\n # (x, y, w, h) = boundingRect(approx)\n # ar = float(h) / float(w)\n # if area > 100 and ar >= 0.8 and ar <= 1.2:\n if area > 700:\n # putText(image, str(area), (10, 30), FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)\n drawContours(image, [contour], -1, (0, 255, 0), 1)\n\n # Stage 4: Perspective warping\n topdown_quad = get_topdown_quad(thresh, approx.reshape(4, 2))\n\n # Stage 5: Border check\n if topdown_quad[int((topdown_quad.shape[0]/100.0)*5), int((topdown_quad.shape[1]/100.0)*5)] > BLACK_THRESHOLD:\n continue\n\n # Stage 6: Get marker pattern\n marker_pattern = None\n\n try:\n marker_pattern = get_marker_pattern(topdown_quad, THRESHOLD_PERCENT)\n except:\n continue\n\n if not marker_pattern:\n continue\n\n # Stage 7: Match marker pattern\n marker_found, marker_rotation, marker_name = match_marker_pattern(marker_pattern)\n\n if marker_found:\n markers.append([marker_name, marker_rotation])\n\n return markers, image","def cross_junctions(I, bounds, Wpts):\n #--- FILL ME IN ---\n\n Ipts = np.zeros((2, 48))\n\n#parameters\n alpha = 0.15 #typically 0.04 to 0.06\n threshold = 1500 #default 2000\n sigma = 2\n ws = 12 #window size for saddle point\n\n#building Harris Detecter\n I = I/255.0\n gradx, grady = np.gradient(I)\n IxIx = gaussian_filter(gradx*gradx,sigma)\n IxIy = gaussian_filter(gradx*grady,sigma)\n IyIy = gaussian_filter(grady*grady,sigma)\n print(I.shape)\n\n #get harris score\n cand_score = []\n cand_index = []\n cand = []\n s_cand = []\n\n for j in range(len(I)):\n for i in range(len(I[0])):\n a11 = IxIx[j][i]\n a12 = IxIy[j][i]\n a21 = a12\n a22 = IyIy[j][i]\n A = np.array([[a11, a12],[a21, a22]])\n ev0, ev1 = np.linalg.eigvals(A)\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\n cand_score.append(-h_score)\n cand_index.append([i, j])\n\n #get the coordinates of the top 5000 scores\n sorted_ind = np.argsort(cand_score)\n sorted_score = np.sort(cand_score).tolist()\n\n for ind in sorted_ind[:threshold]:\n cand.append(cand_index[ind])\n s_cand = sorted_score[:threshold]\n\n\n#clustering\n #using homography to project candidate points to a up-front view\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\n H = dlt_homography(bounds, new_bbox)\n cand = np.array(cand).T\n cand = np.vstack((cand, np.ones(cand.shape[1])))\n Ho_cand = np.matmul(H,cand).T\n for pt in Ho_cand:\n pt[0] = pt[0]/pt[2]\n pt[1] = pt[1]/pt[2]\n Ho_cand = Ho_cand[:,:2]\n Ho_cand = Ho_cand.tolist()\n\n #get rid of points that are not in the boundry\n temp_Ho_cand = []\n temp_s_cand = []\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\n continue\n else:\n temp_Ho_cand.append(pt)\n temp_s_cand.append(s_cand[i])\n Ho_cand = np.array(temp_Ho_cand)\n s_cand = temp_s_cand\n #divide candidates into clusters\n assignment = []\n assignment_score = []\n\n #first put in the point that has the highest score\n assignment.append([Ho_cand[0]])\n assignment_score.append([s_cand[0]])\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n if min(dist) > 6:\n assignment.append([pt])\n assignment_score.append([s_cand[i]])\n\n assignment = np.array(assignment)\n\n #assign points to clusters\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\n continue\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n index = np.argsort(dist)[-1]\n np.append(assignment[index], pt)\n assignment_score[index].append(s_cand[i])\n\n #get centroids for each cluster\n Ho_centroids = []\n for i in range(len(assignment)):\n cl = assignment[i]\n cl = np.array(cl)\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\n assignment_score[i] = sum(assignment_score[i])\n\n print(len(assignment_score))\n\n Ho_centroids = np.array(Ho_centroids)\n #get rid of edge points\n\n xmin = np.amin(Ho_centroids.T[0])\n xmax = np.amax(Ho_centroids.T[0]) \n ymin = np.amin(Ho_centroids.T[1])\n ymax = np.amax(Ho_centroids.T[1])\n\n final_cand = []\n final_score = []\n for i in range(len(Ho_centroids)):\n pt = Ho_centroids[i]\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\n continue\n else:\n final_cand.append(pt)\n final_score.append(assignment_score[i])\n print(\"Number of corner found: \")\n print(len(final_cand))\n\n #get rid of fake corners\n if (len(final_cand)>48):\n ultimate_cand =[]\n for ind in np.argsort(final_score)[:48]:\n ultimate_cand.append(final_cand[ind])\n final_cand = ultimate_cand\n print(\"real corners count:\", len(ultimate_cand))\n\n\n #sort the points\n final_cand = np.array(final_cand)\n y_sort_ind = np.argsort(final_cand.T[1])\n final_cand = final_cand.tolist()\n rows = []\n for i in range(6):\n row = []\n for ind in y_sort_ind[i*8:(i+1)*8]:\n row.append(final_cand[ind])\n rows.append(row)\n\n ordered = []\n for row in rows:\n r = []\n x_sort_ind = np.argsort(np.array(row).T[0])\n for ind in x_sort_ind:\n r.append(row[ind])\n ordered.append(r)\n\n final_cand = []\n for row in ordered:\n for pt in row:\n final_cand.append(pt)\n \n\n\n #get coordinates of the centroids in the original frame\n Ho_centroids = np.array(final_cand)\n\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\n centroids = np.matmul(np.linalg.inv(H), centroids).T\n for pt in centroids:\n pt[0] = int(pt[0]/pt[2])\n pt[1] = int(pt[1]/pt[2])\n centroids = centroids[:,:2]\n\n#finding saddle points around the centroids\n saddle_points = []\n for pt in centroids:\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\n saddle = saddle_point(img)\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\n saddle_points.append(saddle)\n\n saddle_points = np.array(saddle_points)\n #------------------\n print(saddle_points.T)\n return saddle_points.T","def findCrossings(img):\n\tcrossings = 0\n\n\t# 2d list of pixel values\n\toriginalImg = []\n\tfor x in range(img.size[0]):\n\t\tcolValues = []\n\t\tfor y in range(img.size[1]):\n\t\t\tcolValues.append(img.getpixel((x, y)))\n\t\toriginalImg.append(colValues)\n\n\t# iterate over 9 pixel sections\n\tfor x in range(1, img.size[0] - 1):\n\t\tfor y in range(1, img.size[1] - 1):\n\t\t\tif originalImg[x][y] == (0, 0, 0, 255) and numZeroesAround(originalImg, (x,y)) >= 4:\n\t\t\t\timg = colorCross(img, (x, y))\n\t\t\t\tcrossings += 1\n\n\tprint \"Crossings that occur:\", crossings\n\treturn img","def get_cntr_points(self, contour, img_size):\n res_arr = []\n # for each row\n for row in range(img_size):\n tmp_arr = []\n # for each column\n for col in range(img_size):\n # if point in contour\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\n # add point to current line\n tmp_arr.append([row,col])\n if len(tmp_arr):\n # add current line to result array\n res_arr.append(tmp_arr)\n return res_arr","def watershed(self, debug=False):\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg, sure_fg)\n ret, markers = cv2.connectedComponents(sure_fg)\n markers += 1\n markers[unknown == 255] = 0\n markers = cv2.watershed(self.img, markers)\n self.add_color(markers)\n if debug:\n cv2.imshow(\"fg\", unknown)\n cv2.imshow(\"op\", opening)\n cv2.imshow(\"o3\", sure_bg)","def get_indices(waves):\n prob_ = np.abs(waves)**2\n # batch\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\n prob = np.asarray(prob)\n prob_tot = np.sum(prob, axis=0)\n \n # cutoff\n length = np.size(prob[:,0])\n len10 = int(length/10)\n flags = np.zeros((prob.shape[1]), dtype=int)\n # hinges\n # 50% within 10% of corners\n\n # surface\n # 50% within 10% of surfaces\n # not already labelled hinges\n prob_left = np.sum(prob[0:len10,:], axis=0)\n frac_left = prob_left/prob_tot\n\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\n frac_right = np.divide(prob_right, prob_tot)\n\n for i in range(len(flags)):\n if frac_left[i]>0.5 or frac_right[i]>0.5:\n flags[i] = 1\n \n indices = [i for i, x in enumerate(flags) if x == 1]\n indices0 = [i for i, x in enumerate(flags) if x == 0]\n \n return indices, indices0","def generate_contours(edges, colorimg, img):\n cv2.destroyAllWindows()\n cv2.namedWindow(\"Contours\")\n lengthlimit = 20\n arealimit = 20\n\n # create trackbars for length and area filters\n cv2.createTrackbar(\"length\", \"Contours\", 0, 200, nothing)\n cv2.createTrackbar(\"area\", \"Contours\", 0, 2000, nothing)\n\n # find all possible contours in the image\n ret, thresh = cv2.threshold(edges, 127, 255, 0)\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n while 1:\n cv2.imshow(\"Contours\", colorimg)\n\n # filter based on area and length\n lengthlimit = cv2.getTrackbarPos(\"length\", \"Contours\")\n arealimit = cv2.getTrackbarPos(\"area\", \"Contours\")\n\n for idx, contour in enumerate(contours):\n if len(contour) > lengthlimit:\n area = cv2.contourArea(contour)\n if area > arealimit:\n isconvex = cv2.isContourConvex(contour)\n circle = cv2.minEnclosingCircle(contour)\n cv2.drawContours(colorimg, contours, idx, (0, 255, 0), 2)\n else:\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\n else:\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\n\n k = cv2.waitKey(1) & 0xFF\n # print k\n if k == 27:\n exit()\n if k == 32:\n show_final(colorimg, contours, arealimit, lengthlimit)","def getContours(frame):\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def find_contour(ctx: Context):\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\n contours, _ = cv2.findContours(ctx.temp_image1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n\n # take the 5 biggest areas\n contours = sorted(contours, key=lambda c: math.fabs(cv2.contourArea(c)), reverse=True)[:5]\n\n # approximate contours with poly line\n ctx.contours = [cv2.approxPolyDP(c, 2, True) for c in contours]","def checkNeighbours(data):\n features = 0\n background = 0\n neighbours = [data[0,0],data[0,1],data[0,2],data[1,2],data[2,2],data[2,1],data[2,0],data[1,0]]\n fourConnected = False\n lastPoint = neighbours[-1] #Needed for checking a complete transition cycle\n for n in neighbours:\n if not n:\n features += 1\n elif fourConnected:\n background += 1\n\n fourConnected = not fourConnected\n lastPoint = n\n\n for pos,corner in enumerate(corners):\n if numpy.alltrue(data == corner):\n cornerPos = pos+1\n break\n else:\n cornerPos = 0\n return (features,background,cornerPos)","def boundary_contour(self, time):\n ti = np.where(time == self.times)[0][0]\n image_mask = binary_erosion(binary_fill_holes(binary_dilation(self.masks[ti])))\n padded_mask = np.pad(image_mask, 1, 'constant', constant_values=0)\n c_out = find_contours(padded_mask, level=0.5, fully_connected=\"high\")\n x_cont = self.x[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\n y_cont = self.y[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\n ordered_coords = np.vstack([x_cont, y_cont])\n return ordered_coords","def opencv_watershed(masked, mask) -> JSON_TYPE:\n # For code and detailed explanation see:\n # http://datahacker.rs/007-opencv-projects-image-segmentation-with-watershed-algorithm/\n threshold: int = 30\n gray = cv2.cvtColor(masked, cv2.COLOR_RGB2GRAY)\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\n # Noise removal\n kernel = np.ones((3), np.uint8)\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\n # Noise removal\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\n\n n_increases: int = 0\n while local_max_location.shape[0] < 30 and n_increases < 15:\n threshold += 20\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\n # Noise removal\n kernel = np.ones((3), np.uint8)\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\n # Noise removal\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\n n_increases += 1\n # Reset threshold\n threshold = 30\n\n num_clusters: int = 30\n if n_increases >= 15:\n num_clusters = local_max_location.shape[0]\n kmeans = KMeans(n_clusters=num_clusters)\n # If local_max_location size is 0, return 0 predictions\n if not local_max_location.size:\n return {\n \"count\": 0\n }\n kmeans.fit(local_max_location)\n local_max_location = kmeans.cluster_centers_.copy()\n # Kmeans is returning a float data type so we need to convert it to an int. \n local_max_location = local_max_location.astype(int)\n dist_transform_copy = dist_transform.copy()\n for i in range(local_max_location.shape[0]):\n cv2.circle(dist_transform_copy, (local_max_location[i][1], local_max_location[i][0]), 5, 255)\n # markers = np.zeros_like(dist_transform)\n ret, sure = cv2.threshold(dist_transform, 0.01*dist_transform.max(), 255, 0)\n sure = np.uint8(sure)\n ret, markers = cv2.connectedComponents(sure)\n labels = np.arange(kmeans.n_clusters)\n markers[local_max_location[:,0], local_max_location[:,1]] = labels + 1\n # Convert all local markers to an integer. This because cluster centers will be float numbers. \n markers = markers.astype(int)\n markers_copy = markers.copy()\n index_non_zero_markers = np.argwhere(markers != 0)\n markers_copy = markers_copy.astype(np.uint8)\n font = cv2.FONT_HERSHEY_SIMPLEX\n for i in range(index_non_zero_markers.shape[0]):\n string_text = str(markers[index_non_zero_markers[i][0], index_non_zero_markers[i][1]])\n cv2.putText(markers_copy, string_text, (index_non_zero_markers[i][1], index_non_zero_markers[i][0]), font, 1, 255)\n markers = markers.astype(np.int32)\n segmented = cv2.watershed(masked, markers)\n count_segments(markers)\n #return {\n # \"count\": local_max_location.shape[0]\n #}\n return {\n \"count\": count_segments(markers),\n }","def get_neighbors(self, cell, count):\n row, col = cell\n # get all the neighbors\n neighbors = set([(min(self.height - 1, max(row + i, 0)), min(self.width - 1, max(col + j, 0))) \n for i in range(-1, 2)\n for j in range(-1, 2)])\n\n for neighbor in deepcopy(neighbors):\n if neighbor in self.safes or neighbor == cell:\n neighbors.remove(neighbor)\n elif neighbor in self.mines:\n neighbors.remove(neighbor)\n count -= 1\n\n return neighbors, count","def get_nearest_neighbours(self, cell):\n\t\tneighs = self.get_neighbours(cell)\n\t\ti, j = cell.find_id()\n\t\tneighbours = []\n\t\tfor neigh in neighs:\n\t\t\tx, y = neigh.find_id()\n\t\t\tif abs(x-i)+abs(y-j) <= 1: \n\t\t\t\tneighbours.append(self.space[y,x])\n\t\treturn neighbours","def get_background_pixels(img, rect):\n mask = np.zeros(img.shape[:2], np.uint8)\n bg_model = np.zeros((1,65), np.float64)\n fg_model = np.zeros((1,65), np.float64)\n cv2.grabCut(img, mask, rect, bg_model, fg_model, 5, cv2.GC_INIT_WITH_RECT)\n flattened = mask.flatten()\n background_coords = np.where((flattened == 0) | (flattened == 2))\n return background_coords","def cfdProcessElementTopology(self):\r\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \r\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\r\n\r\n ## (list of lists) list of face indices forming each element\r\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\r\n \r\n #populates self.elementNeighbours\r\n for iFace in range(self.numberOfInteriorFaces):\r\n own=self.owners[iFace]\r\n nei=self.neighbours[iFace]\r\n \r\n #adds indices of neighbour cells\r\n self.elementNeighbours[own].append(nei)\r\n self.elementNeighbours[nei].append(own)\r\n \r\n #adds interior faces\r\n self.elementFaces[own].append(iFace)\r\n self.elementFaces[nei].append(iFace)\r\n \r\n #adds boundary faces ('patches')\r\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\r\n own=self.owners[iFace]\r\n self.elementFaces[own].append(iFace)\r\n \r\n ## List of lists containing points forming each element\r\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n \r\n for faceIndex in self.elementFaces[iElement]:\r\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\r\n \r\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\r\n \r\n ## Upper coefficient indices (owners)\r\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n ## Lower coefficient indices (owners)\r\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n ## Element number from 1 to numberOfElements + 1\r\n iNb=1\r\n for faceIndex in self.elementFaces[iElement]:\r\n \r\n #skip if it is a boundary face\r\n if faceIndex > self.numberOfInteriorFaces-1:\r\n continue\r\n \r\n own = self.owners[faceIndex]\r\n nei = self.neighbours[faceIndex]\r\n \r\n if iElement == own:\r\n self.upperAnbCoeffIndex[faceIndex] = iNb\r\n elif iElement == nei:\r\n self.lowerAnbCoeffIndex[faceIndex] = iNb\r\n \r\n iNb = iNb +1","def detect_lanes(binary_warped):\n histogram = np.sum(binary_warped[(binary_warped.shape[0] // 2):, :], axis=0)\n out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255\n\n midpoint = np.int(histogram.shape[0] / 2)\n leftx_base = np.argmax(histogram[:midpoint])\n rightx_base = np.argmax(histogram[midpoint:]) + midpoint\n\n nwindows = 9\n\n window_height = np.int(binary_warped.shape[0] / nwindows)\n\n nonzero = binary_warped.nonzero()\n nonzeroy = np.array(nonzero[0])\n nonzerox = np.array(nonzero[1])\n\n # Current positions to be updated for each window\n leftx_current = leftx_base\n rightx_current = rightx_base\n\n # Set the width of the windows +/- margin\n margin = 100\n\n # Set minimum number of pixels found to recenter window\n minpix = 50\n\n # Create empty lists to receive left and right lane pixel indices\n left_lane_inds = []\n right_lane_inds = []\n\n # Step through the windows one by one\n for window in range(nwindows):\n # Identify window boundaries in x and y (and right and left)\n win_y_low = binary_warped.shape[0] - (window + 1) * window_height\n win_y_high = binary_warped.shape[0] - window * window_height\n win_xleft_low = leftx_current - margin\n win_xleft_high = leftx_current + margin\n win_xright_low = rightx_current - margin\n win_xright_high = rightx_current + margin\n\n # Draw the windows on the visualization image\n cv2.rectangle(out_img, (win_xleft_low, win_y_low), (win_xleft_high, win_y_high), (0, 255, 0), 2)\n cv2.rectangle(out_img, (win_xright_low, win_y_low), (win_xright_high, win_y_high), (0, 255, 0), 2)\n\n # Identify the nonzero pixels in x and y within the window\n good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xleft_low) &\n (nonzerox < win_xleft_high)).nonzero()[0]\n good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xright_low) &\n (nonzerox < win_xright_high)).nonzero()[0]\n\n # Append these indices to the lists\n left_lane_inds.append(good_left_inds)\n right_lane_inds.append(good_right_inds)\n\n # If you found > minpix pixels, recenter next window on their mean position\n if len(good_left_inds) > minpix:\n leftx_current = np.int(np.mean(nonzerox[good_left_inds]))\n if len(good_right_inds) > minpix:\n rightx_current = np.int(np.mean(nonzerox[good_right_inds]))\n\n # Concatenate the arrays of indices\n left_lane_inds = np.concatenate(left_lane_inds)\n right_lane_inds = np.concatenate(right_lane_inds)\n\n # 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 # Visualize\n ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.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\n return Lane(left_fit, right_fit, left_fitx, right_fitx, leftx, rightx, lefty, righty), out_img","def cellNeighbours((cell_x,cell_y)):\n dict = {}\n dict[\"neighbour_up\"] = (cell_x, cell_y - CELL_HEIGHT)\n dict[\"neighbour_down\"] = (cell_x, cell_y + CELL_HEIGHT)\n dict[\"neighbour_left\"] = (cell_x - CELL_WIDTH, cell_y)\n dict[\"neighbour_right\"] = (cell_x + CELL_WIDTH, cell_y)\n dict[\"neighbour_up_left\"] = (cell_x - CELL_WIDTH, cell_y - CELL_HEIGHT)\n dict[\"neighbour_up_right\"] = (cell_x + CELL_WIDTH, cell_y - CELL_HEIGHT)\n dict[\"neighbour_down_left\"] = (cell_x - CELL_WIDTH, cell_y + CELL_HEIGHT)\n dict[\"neighbour_down_right\"] = (cell_x + CELL_WIDTH, cell_y + CELL_HEIGHT)\n keys_to_delete = []\n for key,value in dict.iteritems():\n if not inWindow(value):\n keys_to_delete.append(key)\n for key in keys_to_delete:\n del dict[key]\n return dict","def getContours(image, copyImage):\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n for contour in contours:\n area = cv.contourArea(contour)\n \n if area > 500.0:\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\n perimeter = cv.arcLength(contour, True)\n \n # Approximates to the nearest polygon\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\n objectCoordinates = len(approx)\n\n # Returns the x, y and height width of the polygon\n x, y, w, h = cv.boundingRect(approx)\n\n if objectCoordinates == 3:\n objectShape = \"Triangle\"\n elif objectCoordinates == 4:\n ratio = w / float(h)\n if ratio >= 0.95 and ratio <= 1.05:\n objectShape = \"Square\"\n else: objectShape = \"Rectangle\"\n else: objectShape = \"Circle\" \n\n \n\n # Draw rectangles around the images\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))","def findCluster(path, bound_img_path):\r\n image = cv2.imread(path, cv2.IMREAD_COLOR)\r\n img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\r\n blur = cv2.medianBlur(img, 3)\r\n thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]\r\n\r\n # Creating a structuring element to perform morphological operations\r\n k_size = (3, 3)\r\n kernelMorph = cv2.getStructuringElement(cv2.MORPH_RECT, k_size)\r\n\r\n # Performing opening on the image\r\n morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernelMorph, iterations=1)\r\n\r\n # Performing dilation on the image\r\n ksizeKernelDilate = (50, 1)\r\n dilated = cv2.dilate(morph, ksizeKernelDilate, iterations= 5)\r\n\r\n # Identifying contours in the image\r\n cnts = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n cnts = cnts[0] if len(cnts) == 2 else cnts[1]\r\n clr1, clr2, clr3 = 225, 255, 0,\r\n b = 10\r\n\r\n bounding_box_created = False\r\n if len(cnts) != 0:\r\n contour_rect_box = []\r\n conimage = []\r\n for c in cnts:\r\n # Identifying bounding box dimensions for each contour\r\n x, y, w, h = cv2.boundingRect(c)\r\n # Enclosing the contours in a rectangle\r\n if (w > 10 and h > 10 and w < img.shape[0] and h < img.shape[1]):\r\n conimage = cv2.rectangle(image, (x - b, y - b), (x - b + w + 2 * b, y - b + h + 2 * b),\r\n (clr1, clr2, clr3), -1)\r\n contour_rect_box.append((x, y, x + w, y + h, w, h))\r\n\r\n # Check whether the bounding box is created or not\r\n # If bounding box is created, then update the image with the identified bounding box,\r\n # Else print no clusters have been identified\r\n if len(conimage) > 0:\r\n cv2.imwrite(bound_img_path, conimage)\r\n bounding_box_created = True\r\n else:\r\n print(\"No clusters identified\")\r\n return cnts, bounding_box_created","def compute_contour(ptr_array):\n hull = ConvexHull(ptr_array)\n contour_index = hull.vertices.tolist() # indices are ordered\n # contour_index = hull.simplices.flatten()\n # contour_index = list(set(contour_index))\n return contour_index","def get_neighbor_values(training_image, row, col):\n #patches.append((img[i-1:i+2,j-1:j+2],(i,j)))\n return training_image[row-1:row+2,col-1:col+2]","def get_contours(img):\n contours, hierarchy = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours, hierarchy[0]","def calcAllIntensities(self, xc, yc):\n\n tp = 0.0\n ix = 0\n iy = 0\n h = 0\n ints = np.zeros([5, 5])\n ints_inner = np.zeros([5, 5])\n # ints = [[0.0] * 5] * 5\n # ints_inner = [[0.0] * 5] * 5\n x = 0.0\n y = 0.0\n xc1 = 0.0\n yc1 = 0.0\n xc1 = xc\n yc1 = yc\n \n for h in np.arange(1,5,1):\n for k in np.arange(1,5,1):\n ints[h][k] = 0.0\n ints_inner[h][k] = 0.0\n\n for k in np.arange(0, 2, 1):\n for h in np.arange(0, 2, 1):\n for ix in np.arange(0, self.stepp + 1, 1):\n for iy in np.arange(0, self.stepp + 1, 1):\n #print(k, h, ix, iy)\n if self.qc_format == 0 :\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\n tp = math.pow(tp,2)\n #print(tp)\n elif self.qc_format == 1 :\n x = -1 + h + (ix * (1 / self.stepp))\n y = -1 + k + (iy * (1 / self.stepp))\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\n\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\n ints_inner[h + 1][k + 1] += tp\n else :\n if self.qc_format == 1 :\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\n ints[h + 1][k + 1] += tp\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\n #print(math.pow(x,2) + math.pow(y,2))\n ints[h + 1][k + 1] += tp\n # print(ints[h + 1][k + 1])\t\t\t\t\t\t\n tp = 0.0\n\n # print(ints)\n\n Aq = 0.0\n Bq = 0.0\n Cq = 0.0\n Dq = 0.0\n Ac_inner = 0.0\n Bc_inner = 0.0\n Cc_inner = 0.0\n Dc_inner = 0.0\n Ac = 0.0\n Bc = 0.0\n Cc = 0.0\n Dc = 0.0\n Ac = ints[1][2]\n Bc = ints[2][2]\n Cc = ints[2][1]\n Dc = ints[1][1]\n\n Ac_inner = ints_inner[1][2]\n Bc_inner = ints_inner[2][2]\n Cc_inner = ints_inner[2][1]\n Dc_inner = ints_inner[1][1]\n Ac *= self.QE\n Bc *= self.QE\n Cc *= self.QE\n Dc *= self.QE\n\n Ac_inner *= self.QE_inner\n Bc_inner *= self.QE_inner\n Cc_inner *= self.QE_inner\n Dc_inner *= self.QE_inner\n Ac += Ac_inner\n Bc += Bc_inner\n Cc += Cc_inner\n Dc += Dc_inner\n\n Aq = Ac\n Bq = Bc\n Cq = Cc\n Dq = Dc\n\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\n if self.smooth == 0 :\n if (Config.hplk_c0_e * self.TP) == 0 :\n cnst = 0\n else :\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\n if Config.flag_spice == 1 :\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\n #Bc *= 1 / (self.lamb * 1e6);\n #Cc *= 1 / (self.lamb * 1e6);\n #Dc *= 1 / (self.lamb * 1e6);\n \n ############################## DOUBLE CHECK ##############################\n # self.grava_arquivos = 1\n # self.flag_V_QC = 0\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n # self.flag_V_QC = 1\n # self.grava_arquivos = 0\n ############################## DOUBLE CHECK ##############################\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n else :\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n\n # 'returns' all the intensities\n self.A_intensity = Aq\n self.B_intensity = Bq\n self.C_intensity = Cq\n self.D_intensity = Dq","def generate_contours(threshold):\n \tcnts = cv2.findContours(threshold.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n \tcnts = imutils.grab_contours(cnts)\n \treturn cnts","def Predict_Image_Contours(img, mask_full, feature_dict, filename = None, path = ''):\n for ii in range(len(feature_dict)):\n Type = feature_dict[str(ii)] ## So first key is 1\n if Type=='modern_build':\n color_rgb = (255,0,0)\n elif Type=='trad_build':\n color_rgb = (0,0,255)\n mask = mask_full[:,:,ii]\n mask = 255*mask.round().astype('uint8')\n mask = np.stack((mask,mask, mask),-1)\n mask = cv2.cvtColor(mask, cv2.COLOR_RGB2GRAY);\n ret, thresh = cv2.threshold(mask, 127.5, 255, cv2.THRESH_BINARY)\n\n contours,hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n ##print('here')\n area_thresh =30 ## Depends on what the minimal building size desired is\n for cnt in contours:\n ## Contours, flag of whether curve is closed or not\n epsilon = 0.025*cv2.arcLength(cnt,True)\n ## Contours, epsilon for wiggliness, closed shape or not\n approx = cv2.approxPolyDP(cnt,epsilon,True)\n ## Extract Area Dest image, contours, contour index\n area = cv2.contourArea(approx)\n ## centroid computed from moments\n M = cv2.moments(cnt) \n if area > area_thresh:\n if Type=='modern_build':\n rect = cv2.minAreaRect(cnt)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n img = cv2.drawContours(image = img, contours = [box], \n contourIdx = 0, color = color_rgb, \n thickness = 2)\n elif Type=='trad_build':\n (x,y),radius = cv2.minEnclosingCircle(cnt)\n center = (int(x),int(y))\n radius = int(radius)\n img = cv2.circle(img,center,radius,color_rgb,2)\n elif Type=='Forest':\n img = cv2.drawContours(image = img, contours = [cnt], \n contourIdx = 0, color = color_rgb, \n thickness = 2)\n elif Type=='Bare':\n img = cv2.drawContours(image = img, contours = [cnt], \n contourIdx = 0, color = color_rgb, \n thickness = 2)\n if filename is not None:\n try: \n if path == '':\n path = 'Predictions'\n os.makedirs(path)\n except OSError as error: \n print('') \n fig, ax = plt.subplots(figsize=(18, 20))\n ax.imshow(img[:,:,0:3])\n plt.tight_layout()\n plt.savefig(path + '/' + filename, bbox_inches='tight') \n plt.close(fig)\n \n return img"],"string":"[\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def getContours(img,iteration):\\n nP, IDrange = upDate(iteration)\\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\\n kernel = np.ones((nP, nP), np.uint8)\\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\\n contours = []\\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n if iteration == 2 :\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n elif iteration == 3:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\n return contours\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def get_contour_features(mask,selectcell=\\\"centered\\\"):\\r\\n \\r\\n #binarize image (everything above 0 becomes 1)\\r\\n mask = np.clip(mask,a_min=0,a_max=1)\\r\\n\\r\\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\\r\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\r\\n contours = list(contours)\\r\\n \\r\\n #in case there is no contour found, add a dummy contour\\r\\n if len(contours)==0:\\r\\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\\r\\n\\r\\n #Sort contours, longest first\\r\\n contours.sort(key=len,reverse=True)\\r\\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\\r\\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\\r\\n\\r\\n mu_origs = [cv2.moments(contour) for contour in contours]\\r\\n mu_hulls = [cv2.moments(hull) for hull in hulls]\\r\\n\\r\\n area_origs = [mu_orig[\\\"m00\\\"] for mu_orig in mu_origs]\\r\\n area_hulls = [mu_hull[\\\"m00\\\"] for mu_hull in mu_hulls]\\r\\n\\r\\n #drop events where area is zero\\r\\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \\r\\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\\r\\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\\r\\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\\r\\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\\r\\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\\r\\n \\r\\n \\r\\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n\\r\\n \\r\\n if selectcell == \\\"smooth\\\":\\r\\n #compute the area ratio (roughness of contour)\\r\\n area_ratio = np.array(area_hulls)/np.array(area_origs)\\r\\n #get the contour with minimum roughness (smooth contour)\\r\\n sorter = np.argsort(area_ratio) #smallest first\\r\\n\\r\\n if selectcell == \\\"centered\\\":\\r\\n #select contour that is closest to the center of the image. \\r\\n #In iPAC, cells are usually in the center.\\r\\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\\r\\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\\r\\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\\r\\n sorter = np.argsort(distances) #smallest first\\r\\n \\r\\n #sort values with respect to chosen metric (area_ratio or distance)\\r\\n contours = [contours[s] for s in sorter]\\r\\n hulls = [hulls[s] for s in sorter]\\r\\n pos_x = [pos_x[s] for s in sorter]\\r\\n pos_y = [pos_y[s] for s in sorter]\\r\\n mu_origs = [mu_origs[s] for s in sorter]\\r\\n area_origs = [area_origs[s] for s in sorter]\\r\\n area_hulls = [area_hulls[s] for s in sorter]\\r\\n \\r\\n # draw mask of the chosen contour\\r\\n mask = np.zeros_like(mask)\\r\\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\\r\\n\\r\\n hull = hulls[0]#[0:n_contours]\\r\\n pos_x = pos_x[0]\\r\\n pos_y = pos_y[0] \\r\\n mu_orig = mu_origs[0]#[0:n_contours]\\r\\n area_orig = area_origs[0]#[0:n_contours]\\r\\n area_hull = area_hulls[0]#[0:n_contours]\\r\\n \\r\\n if area_orig>0:\\r\\n area_ratio = area_hull/area_orig\\r\\n else:\\r\\n area_ratio = np.nan\\r\\n\\r\\n arc = cv2.arcLength(hull, True) \\r\\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\\\"m00\\\"]) / arc\\r\\n\\r\\n\\r\\n dic = {\\\"mask\\\":mask,\\\"pos_x\\\":pos_x,\\\"pos_y\\\":pos_y,\\\"area_orig\\\":area_orig,\\\"area_hull\\\":area_hull,\\\\\\r\\n \\\"area_ratio\\\":area_ratio,\\\"circularity\\\":circularity}\\r\\n return dic\",\n \"def trackCells(self): \\n # variable initialization\\n self.t_appearance = []\\n self.id_seq = []\\n self._n_cell = 0\\n self.division = []\\n self.dict_track = {}\\n\\n t_ini = self.configs[self.TIME_INI_KEY]\\n\\n # Initialize points with first frame\\n self.dict_track[0] = {}\\n for id_num in self.pos[0][4]:\\n self._addTrack(0, id_num)\\n\\n # From frame=1 on...\\n for t, data_t in enumerate(self.pos[1:]):\\n self.dict_track[t+1] = {}\\n # check all the cells in this frame\\n for cell, id_num in enumerate(data_t[4]):\\n parent = data_t[5][cell]\\n if parent == -1:\\n # new track\\n self._addTrack(t+1, id_num)\\n elif parent in self.dict_track[t]:\\n # check if parent is in the previous list\\n index = self.dict_track[t][parent]\\n if index in self.dict_track[t+1].values():\\n # then we have cell division, and we monitor the child separarely\\n self._addDivision(t+1, id_num, index)\\n else:\\n # cell continues in the same track\\n self.id_seq[index].append(id_num)\\n self.dict_track[t+1][id_num] = index\\n else:\\n # weird things happened!\\n print(\\\"Warning! Time %s, Cell ID %s lost track\\\"%(str(t+t_ini), str(id_num)))\\n\\n\\n # all track indexes are included, no filter (yet)\\n self.index_filter = list(range(len(self.id_seq)))\\n\\n return self.id_seq, self.t_appearance\",\n \"def find_original_contours(self):\\r\\n\\r\\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\\r\\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\\r\\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\\r\\n int(self.cell_size), 5)\\r\\n self.thresh_orig = 255 - self.thresh_invert\\r\\n\\r\\n # Find the contours of the image. Each contour should correspond to a cell\\r\\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\\r\\n for block in orig_contours:\\r\\n area = cv2.contourArea(block)\\r\\n\\r\\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\\r\\n if area < self.min_cell_size:\\r\\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)\",\n \"def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\\n return [\\n [sc.cVLS() for sc in scList]\\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\\n ]\",\n \"def instance_contours(gti):\\n # TODO: move to somewhere better\\n import cv2\\n\\n rc_locs = np.where(gti > 0)\\n grouped_cc_rcs = util.group_items(\\n np.ascontiguousarray(np.vstack(rc_locs).T),\\n gti[rc_locs], axis=0\\n )\\n\\n def bounding_box(rcs):\\n rc1 = rcs.min(axis=0)\\n rc2 = rcs.max(axis=0)\\n return rc1, rc2\\n\\n # slice out a bounding region around each instance, detect the contour and\\n # then offset it back into image coordinates\\n grouped_contours = {}\\n for label, rcs in grouped_cc_rcs.items():\\n rc1, rc2 = bounding_box(rcs)\\n sl = (slice(rc1[0], rc2[0] + 2), slice(rc1[1], rc2[1] + 2))\\n submask = (gti[sl] == label).astype(np.uint8)\\n\\n xy_offset = rc1[::-1]\\n offset = xy_offset + [-2, -2]\\n\\n border = cv2.copyMakeBorder(submask, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=0 )\\n _, contors, hierarchy = cv2.findContours(border, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE,\\n offset=tuple(offset))\\n \\\"\\\"\\\"\\n offset = [0, 0]\\n BGR_GREEN = (0, 255, 0)\\n x = np.ascontiguousarray(util.ensure_alpha_channel(submask)[:, :, 0:3]).astype(np.uint8)\\n draw_img = cv2.drawContours(\\n image=x, contours=contors,\\n contourIdx=-1, color=BGR_GREEN, thickness=2)\\n \\\"\\\"\\\"\\n # note when len(contours > 1, there is a hole in the building)\\n # assert len(contors) == 1\\n grouped_contours[label] = contors\\n return grouped_contours\",\n \"def take_contours(self):\\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]\",\n \"def get_contours(self):\\n depth_image = capture_images((self.w,self.h))\\n\\n thresh = threshold_depth_image(depth_image, min_depth=config.min_depth, max_depth=config.max_depth, threshold=config.min_depth, kernel=self.kernel)\\n\\n # extract contours\\n im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\\n if hierarchy!=None:\\n hierarchy = hierarchy[0]\\n return contours, hierarchy\\n else:\\n return [], []\",\n \"def getMostContour(img,svm,knn,filterArr,digits,wThresh,hThresh):\\r\\n # append the filter to filter array, this approach is used in case of \\r\\n # multiple filter methods would be used.\\r\\n counts = []\\r\\n # iterare through every filter\\r\\n for flt in filterArr:\\r\\n # copy the image so we don't draw on same image\\r\\n flt_img = img.copy()\\r\\n last_img = img.copy()\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh) \\r\\n if not digits:\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh)\\r\\n flt_contour_map = []\\r\\n labels = []\\r\\n for crop,(x,y,w,h),contour in cropNwriteBBs(img,cntfound_fltr):\\r\\n #crop = np.array(crop,dtype='float32')\\r\\n crop = cv2.cvtColor(crop,cv2.COLOR_BGR2GRAY)\\r\\n crop = cv2.resize(crop,(25,25))\\r\\n # winSize is the size of the image cropped to an multiple of the cell size\\r\\n hog_fts = hog.compute(crop)\\\\\\r\\n .reshape(n_cells[1] - block_size[1] + 1,\\r\\n n_cells[0] - block_size[0] + 1,\\r\\n block_size[0], block_size[1], nbins) \\\\\\r\\n .transpose((1, 0, 2, 3, 4))\\r\\n hog_fts = np.resize(hog_fts.flatten(),(1,576))\\r\\n # make the resulted crop same type with the trained values\\r\\n hog_fts.dtype = 'float32'\\r\\n # get predicted labels\\r\\n label_svm=svm.predict(hog_fts)[1]\\r\\n label_knn = knn.findNearest(hog_fts,k=5)[1]\\r\\n # label 10 is considered as 'not digit' or 'thrash'\\r\\n # so if predicted label is not 10, draw the bounding box\\r\\n if digits:\\r\\n if(label_svm!=10 and label_knn != 10 and label_svm!=11 and label_knn != 11):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n else:\\r\\n if(label_svm!=2 and label_knn != 2):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n last_cnt,last_labels = secondElimination(flt_contour_map,labels)\\r\\n for cnt in last_cnt:\\r\\n x,y,w,h = cv2.boundingRect(cnt)\\r\\n cv2.rectangle(flt_img,(x,y),(x+w,y+h),[0,255,0],2)\\r\\n #showWait(flt_img,'fltres')\\r\\n _,xx,res_boxes,_,_ = mergeBoundingBoxes(flt_img,last_cnt,last_labels)\\r\\n cnt = len(res_boxes)\\r\\n counts.append([cnt,flt_img,last_cnt,last_labels])\\r\\n # append resulted image and contours to an array\\r\\n counts = np.asarray(counts)\\r\\n # get the resulted image which contain more digits (bounding boxes)\\r\\n tmp = counts[:,0]\\r\\n resulted_img = counts[np.argmax(tmp),1]\\r\\n result_labels = counts[np.argmax(tmp),3]\\r\\n resulted_contour = counts[np.argmax(tmp),2]\\r\\n return resulted_contour,result_labels,resulted_img\",\n \"def detect_contours(self):\\r\\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\r\\n return [DbugContour(cv_contour=contour) for contour in contours]\",\n \"def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\\n\\n kernel = np.ones((5, 5), np.float32)\\n\\n # Use a distance transform to find the seed points for watershed\\n tmp = class_mask\\n tmp[tmp>0] = 1 # here\\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\\n dist = (dist / np.max(dist)) * 255.\\n\\n # Since there may be multiple peaks, we use dilation to find them\\n dilate = cv2.dilate(dist, kernel, iterations=3)\\n peaks = np.float32(np.where(dilate == dist, 1, 0))\\n peaks = peaks * class_mask * 255\\n\\n sure_fg = np.where(peaks > 125, 255., 0.)\\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\\n sure_fg = np.uint8(sure_fg)\\n\\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\\n unknown = sure_bg - sure_fg\\n\\n # Add one to all labels so that known background is not 0, but 1\\n _, markers = cv2.connectedComponents(sure_fg)\\n markers = markers + 1\\n\\n markers[unknown == 255] = 0\\n\\n markers = cv2.watershed(self.image, markers)\\n\\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\\n watershed_superpixels[markers == -1] = 255\\n\\n return watershed_superpixels\",\n \"def sort_filtered_contours(self):\\r\\n\\r\\n # Get the contours again\\r\\n invert = 255 - self.thresh_invert\\r\\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\\r\\n\\r\\n # Make sure that they're within the correct range for size\\r\\n # If too small, it is probably noise; if too large, then should be things around the grid\\r\\n for i, c in enumerate(real_contours, 1):\\r\\n contour_area = cv2.contourArea(c)\\r\\n if self.min_cell_size < contour_area < self.max_cell_size:\\r\\n self.good_contours.append(c)\\r\\n\\r\\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\\r\\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\\r\\n\\r\\n # Sort the contours from top to bottom\\r\\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\\\"top-to-bottom\\\")\\r\\n\\r\\n # We then sort each row from left to right\\r\\n row = []\\r\\n for i, c in enumerate(half_sorted_contours, 1):\\r\\n row.append(c)\\r\\n if i % self.board_dimension == 0:\\r\\n (full_sorted_contours, _) = contours.sort_contours(row, method=\\\"left-to-right\\\")\\r\\n self.game_board_contours.append(full_sorted_contours)\\r\\n row = []\",\n \"def cell_detects(self, masked=False):\\r\\n grd = self.grd\\r\\n ncells = len(grd.cells['depth'])\\r\\n detects_i_tr = np.zeros(ncells, np.int32)\\r\\n if masked:\\r\\n not_flagged = np.where(self.rec_track.flagged==0)[0]\\r\\n rec_track = self.rec_track[not_flagged]\\r\\n else:\\r\\n rec_track = self.rec_track\\r\\n ndetects = len(rec_track)\\r\\n for nd in range(ndetects):\\r\\n tr = rec_track[nd]\\r\\n i = tr.i\\r\\n if i >= 0:\\r\\n detects_i_tr[i] += 1\\r\\n \\r\\n return detects_i_tr\",\n \"def get_further_neighbours(self, cell):\\n\\t\\tneighs = self.get_neighbours(cell)\\n\\t\\ti, j = cell.find_id()\\n\\t\\tneighbours = []\\n\\t\\tfor neigh in neighs:\\n\\t\\t\\tx, y = neigh.find_id()\\n\\t\\t\\tif abs(x-i)+abs(y-j) > 1 or abs(x-i)+abs(y-j) == 0: \\n\\t\\t\\t\\tneighbours.append(self.space[y,x])\\n\\t\\treturn neighbours\",\n \"def nondetects(self, masked=False):\\r\\n grd = self.grd\\r\\n xnd = []\\r\\n ynd = []\\r\\n ncells = len(grd.cells['depth'])\\r\\n non_detects_i_tr = np.zeros(ncells, np.int32)\\r\\n if masked:\\r\\n not_flagged = np.where(self.rec_track.flagged==0)[0]\\r\\n rec_track = self.rec_track[not_flagged]\\r\\n rec_seg = self.make_segments(set_depth=True, \\r\\n input_rec_track=rec_track)\\r\\n else:\\r\\n rec_seg = self.rec_seg\\r\\n for nr, rseg in enumerate(rec_seg):\\r\\n seg = rec_seg[nr]\\r\\n dt = seg.dt\\r\\n if dt > dt_signal+1:\\r\\n t1 = seg.t1\\r\\n t2 = seg.t2\\r\\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\\r\\n x1 = seg.x1\\r\\n x2 = seg.x2\\r\\n y1 = seg.y1\\r\\n y2 = seg.y2\\r\\n dx_nd = (x2 - x1)/float(nint+1)\\r\\n dy_nd = (y2 - y1)/float(nint+1)\\r\\n if nint < 120: # 10 minute cutoff for nondetect filling\\r\\n xint = [x1 + n*dx_nd for n in range(1,nint)]\\r\\n yint = [y1 + n*dy_nd for n in range(1,nint)]\\r\\n xnd = xnd + xint\\r\\n ynd = ynd + yint\\r\\n\\r\\n for nd in range(len(xnd)):\\r\\n xy = [xnd[nd], ynd[nd]]\\r\\n i = grd.select_cells_nearest(xy)\\r\\n if (i is not None) and (i >= 0):\\r\\n non_detects_i_tr[i] += 1\\r\\n\\r\\n return non_detects_i_tr\",\n \"def fun_contours(self, params):\\n shape_coeffs = params[:self.num_shape_params]\\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\\n\\n vertices3d = self.vertices3d\\n vertices3d_from_mesh = np.zeros_like(vertices3d)\\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\\n\\n inner_idx = 0\\n for idx in range(vertices3d.shape[0]):\\n lm_idx = idx % 66\\n obs_num = int(np.floor(idx/66))\\n\\n if lm_idx in self.contour_lms_list[0]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_right[obs_num])\\n elif lm_idx in self.contour_lms_list[1]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_left[obs_num])\\n else:\\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\\n inner_idx += 1\\n if inner_idx == 50:\\n inner_idx = 0\\n\\n return (vertices3d_from_mesh - vertices3d).ravel()\",\n \"def get_winning_discs(self):\\r\\n for i in range(6):\\r\\n for j in range(7):\\r\\n if self.board[i][j] == 'O':\\r\\n continue\\r\\n if self.is_horizontal_four(i, j):\\r\\n return [(i, x) for x in range(j, j + 4)]\\r\\n if self.is_vertical_four(i, j):\\r\\n return [(x, j) for x in range(i, i - 4, -1)]\\r\\n if self.is_neg_diagonal_four(i, j):\\r\\n return [(x, y) for x, y in zip(\\r\\n range(i, i + 4), range(j, j - 4, -1))]\\r\\n if self.is_pos_diagonal_four(i, j):\\r\\n return [(x, y)\\r\\n for x, y in zip(range(i, i + 4), range(j, j + 4))]\",\n \"def GetInteriorEdgesTri(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesTri()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesTri()\\n\\n sorted_all_edges = np.sort(self.all_edges,axis=1)\\n sorted_boundary_edges = np.sort(self.edges,axis=1)\\n\\n x = []\\n for i in range(self.edges.shape[0]):\\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\\n pos_interior_edges = np.where(interior_edges==0)[0]\\n if pos_interior_edges.shape[0] != 0:\\n x.append(pos_interior_edges)\\n\\n edge_aranger = np.arange(self.all_edges.shape[0])\\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\\n interior_edges = self.all_edges[edge_aranger,:]\\n\\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\\n edge_flags[edge_aranger] = 0\\n\\n self.interior_edges = interior_edges\\n return interior_edges, edge_flags\",\n \"def get_connected_components(img):\\n already_labeled = []\\n connected_components = []\\n pixel_queue = []\\n\\n def get_fg_neighbors(row,col):\\n neighbors = []\\n min_row = max(row-1,0)\\n max_row = min(row+1, len(img)-1)\\n min_col = max(col-1,0)\\n max_col = min(col+1, len(img[0])-1)\\n for r in xrange(min_row, max_row+1):\\n for c in xrange(min_col, max_col+1):\\n if img[r][c] == 1 and (r,c) not in already_labeled:\\n neighbors.append((r,c))\\n return neighbors\\n\\n for row in xrange(len(img)):\\n for col in xrange(len(img[0])):\\n if img[row][col] == 1 and (row,col) not in already_labeled:\\n already_labeled.append((row,col))\\n cc = []\\n cc.append((row,col))\\n pixel_queue.append((row,col))\\n while len(pixel_queue) > 0:\\n cur_pixel = pixel_queue[0]\\n pixel_queue = pixel_queue[1:]\\n neighbors = get_fg_neighbors(cur_pixel[0], cur_pixel[1])\\n already_labeled += neighbors\\n cc += neighbors\\n pixel_queue += neighbors\\n connected_components.append(cc)\\n return connected_components\",\n \"def findContours(img, thresh=127, val=255):\\n\\tgray = grayscale(img)\\n\\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\\n\\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\terrorCheckContour(contours)\\n\\treturn sort(contours)\",\n \"def paintings_detection(query_image, mask):\\n\\n image = cv2.imread(query_image)\\n\\n image_width = mask.shape[0]\\n image_height = mask.shape[1]\\n x_box_1, y_box_1, w_box_1, h_box_1, x_box_2, y_box_2, w_box_2, h_box_2 = 0, 0, 0, 0, 0, 0, 0, 0, \\n\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2:]\\n\\n for cnt in contours:\\n x, y, w, h = cv2.boundingRect(cnt)\\n \\n if (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 == 0):\\n x_box_1, y_box_1, w_box_1, h_box_1 = x, y, w, h\\n elif (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 != 0):\\n x_box_2, y_box_2, w_box_2, h_box_2 = x, y, w, h\\n\\n if x_box_2 == 0:\\n x_value_to_split = 0\\n else:\\n x_value_to_split = (x_box_1 + w_box_1/2 + x_box_2 + w_box_2/2) / 2\\n\\n\\n return(x_value_to_split)\",\n \"def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\\n\\n device += 1\\n\\n if len(np.shape(img)) == 3:\\n iy, ix, iz = np.shape(img)\\n else:\\n iy, ix, = np.shape(img)\\n\\n # get the break groups\\n\\n if nrow == 1:\\n rbreaks = [0, iy]\\n else:\\n rstep = np.rint(iy / nrow)\\n rstep1 = np.int(rstep)\\n rbreaks = range(0, iy, rstep1)\\n if ncol == 1:\\n cbreaks = [0, ix]\\n else:\\n cstep = np.rint(ix / ncol)\\n cstep1 = np.int(cstep)\\n cbreaks = range(0, ix, cstep1)\\n\\n # categorize what bin the center of mass of each contour\\n\\n def digitize(a, step):\\n if isinstance(step, int) == True:\\n i = step\\n else:\\n i = len(step)\\n for x in range(0, i):\\n if x == 0:\\n if a >= 0 and a < step[x + 1]:\\n return x + 1\\n elif a >= step[x - 1] and a < step[x]:\\n return x\\n elif a > step[x - 1] and a > np.max(step):\\n return i\\n\\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\\n coord = []\\n for i in range(0, len(roi_objects)):\\n m = cv2.moments(roi_objects[i])\\n if m['m00'] == 0:\\n pass\\n else:\\n cx = int(m['m10'] / m['m00'])\\n cy = int(m['m01'] / m['m00'])\\n # colbin = np.digitize(cx, cbreaks)\\n # rowbin = np.digitize(cy, rbreaks)\\n colbin = digitize(cx, cbreaks)\\n rowbin = digitize(cy, rbreaks)\\n a = (cx, cy, colbin, rowbin, i)\\n coord.append(a)\\n coord1 = np.array(coord, dtype=dtype)\\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\\n\\n # get the list of unique coordinates and group the contours with the same bin coordinates\\n\\n groups = []\\n for i, y in enumerate(coord2):\\n col = y[3]\\n row = y[2]\\n location = str(row) + ',' + str(col)\\n groups.append(location)\\n\\n unigroup = np.unique(groups)\\n coordgroups = []\\n\\n for i, y in enumerate(unigroup):\\n col = int(y[0])\\n row = int(y[2])\\n for a, b in enumerate(coord2):\\n if b[2] == col and b[3] == row:\\n grp = i\\n contour = b[4]\\n coordgroups.append((grp, contour))\\n else:\\n pass\\n\\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\\n\\n contours = roi_objects\\n grouped_contour_indexes = coordlist\\n\\n # Debug image is rainbow printed contours\\n\\n if debug == 'print':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n print_image(img_copy, (str(device) + '_clusters.png'))\\n\\n elif debug == 'plot':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n plot_image(img_copy)\\n\\n return device, grouped_contour_indexes, contours\",\n \"def get_nb_vals(i, pnts, dem, top_left_cor, cellsize, rows, cols):\\n nb_x = np.zeros((5,5)) # this 5 by 5 max would contain the x coordinate of 16 neighbor pixels of a sample point\\n nb_y = np.zeros((5,5)) # this 5 by 5 matrix would contain the y coordinate of 16 neighbor pixels of a sample point\\n nb_z = np.zeros((5,5))\\n # get index and value of cell in DEM containing current point\\n (cell_X, cell_Y, cell_Z) = misc.getCellValue(pnts[i], \\n dem, \\n top_left_cor, \\n cellsize)\\n #Deal with sample points near boundary of the DEM\\n point_within_dem = (cell_X-2) >=0 and (cell_Y-2>=0) and (cell_X+3)<=cols and (cell_Y+3)<=rows\\n if point_within_dem:\\n nb_z[0:5,0:5] = misc.RasterSubset(dem,(cell_Y-2),(cell_Y+3),(cell_X-2),(cell_X+3))\\n else:\\n #Get the part of moving window within the DEM domain\\n in_data= misc.RasterSubset(dem,max((cell_Y-2),0),min((cell_Y+3),rows),max((cell_X-2),0),min((cell_X+3),cols))\\n #in_data=dem[\\\"array\\\"][max((cell_Y-2),0):min((cell_Y+3),rows),max((cell_X-2),0):min((cell_X+3),cols)]\\n nb_z[max((2-cell_Y),0):min((5-(cell_Y+3-rows)),5),max((2-cell_X),0):min((5-(cell_X+3-cols)),5)]=in_data[0:in_data.shape[0],0:in_data.shape[1]]\\n in_data_avg=np.mean(in_data[in_data>-3.4e+10])\\n nb_z[nb_z==0]=in_data_avg\\n nb_z[nb_z<-3.4e+10]=in_data_avg\\n\\n\\n \\n # If there is missing data in the neighborhood of the sample point \\n # use neighborhood average to replace the missing value \\n has_missing_data = (nb_z>8848).sum()>0 or (nb_z<-413).sum()>0\\n if has_missing_data:\\n avgValue=np.mean(nb_z[np.where(np.logical_and(nb_z<8848, nb_z>-413))])\\n nb_z[nb_z>8848]=avgValue\\n nb_z[nb_z<-413]=avgValue\\n \\n # Obtain the coordinate of cell centroid of a 5*5 neighborhood around the sample point\\n for ii in [0,1,2,3,4]:\\n cor_y=ii-2\\n dy = (cell_Y+cor_y+0.5) * cellsize[1]\\n nb_y[ii,:] = top_left_cor[1] + dy\\n for jj in [0,1,2,3,4]:\\n cor_x=jj-2\\n dx = (cell_X+cor_x+0.5) * cellsize[0]\\n nb_x [:,jj] = top_left_cor[0] + dx\\n return nb_x, nb_y, nb_z\",\n \"def get_neighbours(self):\\n shape=self.cubeshape[1:]\\n neighboursx=np.arange(self.xpos-(self.blocksize-1)/2,(self.xpos+(self.blocksize-1)/2)+1,dtype='int' )\\n neighboursx=[x if (x>=0) & (x<=shape[1]-1) else np.nan for x in neighboursx ]\\n neighboursy=np.arange(self.ypos-(self.blocksize-1)/2,(self.ypos+(self.blocksize-1)/2)+1,dtype='int' )\\n neighboursy=[y if (y>=0) & (y<=shape[0]-1) else np.nan for y in neighboursy ]\\n keys=[np.ravel_multi_index([y,x], shape) if np.all(np.isfinite(np.asarray([y,x]))) else np.nan for y in neighboursy for x in neighboursx]\\n\\n return keys\",\n \"def GetInteriorEdgesPent(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesPent()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesPent()\\n\\n sorted_all_edges = np.sort(self.all_edges,axis=1)\\n sorted_boundary_edges = np.sort(self.edges,axis=1)\\n\\n x = []\\n for i in range(self.edges.shape[0]):\\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\\n pos_interior_edges = np.where(interior_edges==0)[0]\\n if pos_interior_edges.shape[0] != 0:\\n x.append(pos_interior_edges)\\n\\n edge_aranger = np.arange(self.all_edges.shape[0])\\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\\n interior_edges = self.all_edges[edge_aranger,:]\\n\\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\\n edge_flags[edge_aranger] = 0\\n\\n self.interior_edges = interior_edges\\n return interior_edges, edge_flags\",\n \"def footprint_corner_indices():\",\n \"def draw_contours(self, image, maskImg):\\r\\n # Required variables..\\r\\n x, y, width, height = 0, 0, 0, 0\\r\\n # Find contours..\\r\\n contours, hierarchy = cv2.findContours(image=maskImg, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) # Playable Parameters..\\r\\n # Draw the contours..\\r\\n for contour in contours:\\r\\n # Calculate the area of the contour, so can remove unnecessary contours..\\r\\n area = cv2.contourArea(contour=contour)\\r\\n if area > 3000: # Playable adjustment..!! Found Good as 3000 for current light condition.. change this if light condition changes..\\r\\n # Draw the contours to the image -- actual frame..\\r\\n if self.debug_mode:\\r\\n cv2.drawContours(image=image, contours=contour, contourIdx=-1, color=(255, 255, 0), thickness=4)\\r\\n # Find the perimeter of the markers detected...\\r\\n perimeter = cv2.arcLength(curve=contour, closed=True)\\r\\n # Approximating/Finding the corners of the image from the obtained corners..\\r\\n approx_corners = cv2.approxPolyDP(curve=contour, epsilon=0.02 * perimeter, closed=True)\\r\\n # Find the bounding box rectangle for the approximated corners..\\r\\n x, y, width, height = cv2.boundingRect(approx_corners)\\r\\n # Return the values with which a rectangle can be drawn..\\r\\n return x, y, width, height\",\n \"def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\\n\\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\\n\\n # Since the watershed draws contours, we need to invert the predictions to\\n # get the 'inside' blob portion. We also slightly compress the blob portion\\n # so we can get a more defining border.\\n inverted_contours = 255 - class_contours\\n\\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\\n # remove areas that are not part of the class mask\\n inverted_contours[class_mask==0]= 0 # here ?\\n\\n return inverted_contours\",\n \"def preprocessing(self, img):\\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def watershed(img):\\n\\ttmp = img.copy()\\n\\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\\n\\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\\n\\tkernel = np.ones((3,3), np.uint8)\\n\\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\\n\\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\\n\\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\\n\\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\\n\\tsure_fg = np.uint8(sure_fg)\\n\\tunknown = cv2.subtract(sure_bg, sure_fg)\\n\\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\\n\\tmarkers = markers+1\\n\\tmarkers[unknown==255] = 0\\n\\tmarkers = cv2.watershed(tmp, markers)\\n\\ttmp[markers == -1] = [255,0,0]\\n\\treturn tmp\",\n \"def find_components(edges, max_components=16):\\n # Perform increasingly aggressive dilation until there are just a few\\n # connected components.\\n\\n count = 21\\n dilation = 5\\n n = 1\\n while count > 16:\\n n += 1\\n dilated_image = dilate(edges, N=3, iterations=n)\\n dilated_image = np.uint8(dilated_image)\\n contours, hierarchy = cv2.findContours(dilated_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n count = len(contours)\\n # print dilation\\n # Image.fromarray(edges).show()\\n # Image.fromarray(255 * dilated_image).show()\\n return contours\",\n \"def getContours(img):\\n # mode: gets only exrteme outer contours\\n # method: stores all contour points\\n contours, hierarchy = cv2.findContours(img, mode=cv2.RETR_EXTERNAL,\\n method=cv2.CHAIN_APPROX_NONE)\\n \\n x, y, w, h = 0, 0, 0, 0\\n\\n # improving accuracy of contours\\n for cnt in contours:\\n area = cv2.contourArea(cnt)\\n if area > 500:\\n # assumes cnt with area > 500 is closed contour \\n perimeter = cv2.arcLength(cnt, True)\\n\\n # approximate polygonal curve of cnt\\n # set max difference between original and approxCurve as \\n # 0.02 * perimeter\\n approxCurve = cv2.approxPolyDP(cnt, 0.02 * perimeter, closed=True)\\n \\n x, y, w, h = cv2.boundingRect(approxCurve)\\n # wand point is is center-left tip\\n return x + (w // 2), y\",\n \"def identify_dbs(image):\\n locations = {\\\"red\\\": Point(), \\\"green\\\": Point(), \\\"blue\\\": Point()}\\n masks = {\\\"red\\\": [], \\\"green\\\": [], \\\"blue\\\": []}\\n\\n bridge = cv_bridge.CvBridge()\\n image = bridge.imgmsg_to_cv2(image, \\\"bgr8\\\")\\n hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n\\n # upper and lower bounds for red\\n # using python 3 bgr [0,0,188] = hsv [0, 255, 188]\\n lower_red = numpy.array([0, 100, 100]) \\n upper_red = numpy.array([10, 255, 255])\\n masks[\\\"red\\\"] = cv2.inRange(hsv, lower_red, upper_red)\\n\\n # upper and lower bounds for green\\n # using python 3 bgr [0,175,0] = hsv [60, 255, 175]\\n lower_green = numpy.array([50, 100, 100]) \\n upper_green = numpy.array([70, 255, 255])\\n masks[\\\"green\\\"] = cv2.inRange(hsv, lower_green, upper_green)\\n\\n # upper and lower bounds for blue\\n # using python 3 bgr [176, 0, 17] = hsv [123, 255, 176]\\n lower_blue = numpy.array([113, 100, 100])\\n upper_blue = numpy.array([133, 255, 255])\\n masks[\\\"blue\\\"] = cv2.inRange(hsv, lower_blue, upper_blue)\\n\\n x, y, w, h = 0, 0, image.shape[1]//3, image.shape[0]\\n\\n for color, mask in masks.items():\\n pixels = {\\\"left\\\": 0, \\\"middle\\\": 0, \\\"right\\\": 0}\\n \\n # define section of image to use for left, middle and right\\n left = mask[y:y+h, x:x+w]\\n middle = mask[y:y+h, x+w:x+w+w]\\n right = mask[y:y+h, x+w+w:x+3*w]\\n\\n # count the number of pixels in each section\\n pixels[\\\"left\\\"] = cv2.countNonZero(left)\\n pixels[\\\"middle\\\"] = cv2.countNonZero(middle)\\n pixels[\\\"right\\\"] = cv2.countNonZero(right)\\n location = max(pixels, key=pixels.get)\\n\\n # map the relative position of the db (left, middle, right) to the correct Point()\\n locations[color] = db_locations[location]\\n \\n return locations\",\n \"def get_pair_rects(contours):\\n\\n rect_pairs = []\\n for index, cnt in enumerate(contours):\\n # Rotated rect - ( center (x,y), (width, height), angle of rotation )\\n rect = cv2.minAreaRect(cnt)\\n center_x, center_y = rect[0]\\n rect_angle = -round(rect[2], 2)\\n\\n if rect_angle > 45.0:\\n # Iterate through all of the potential matches\\n min_x_dist = min_rect = min_index = None\\n for pot_index, pot_match in enumerate(contours):\\n if np.array_equal(pot_match, cnt):\\n continue\\n\\n match_rect = cv2.minAreaRect(pot_match)\\n\\n # Check if match is to the right of the contour\\n if match_rect[0][0] > rect[0][0] and abs(\\n match_rect[2] - rect_angle) > ANGLE_TOLERANCE_DEG:\\n x_distance = match_rect[0][0] - rect[0][0]\\n\\n if min_x_dist is None or x_distance < min_x_dist:\\n min_x_dist = x_distance\\n min_rect = match_rect\\n min_index = pot_index\\n\\n if min_rect is not None:\\n rect_pairs.append((rect, min_rect))\\n np.delete(contours, index)\\n np.delete(contours, min_index)\\n\\n return rect_pairs\",\n \"def drawcntMap(orgimg,filteredimg,wThresh,hThresh):\\r\\n _, contour, _ = cv2.findContours(filteredimg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\r\\n\\r\\n cnt = cv2.drawContours(orgimg.copy(), contour, -1, (0, 0, 255), 2) # To draw filtered contours on original image\\r\\n\\r\\n digitCnts = [] # contours to be surrounded by bounding boxes\\r\\n\\r\\n for c in contour:\\r\\n (x, y, w, h) = cv2.boundingRect(c)\\r\\n if w >= wThresh and h >= hThresh and w*h <20000: # Length filters to reduce noise\\r\\n cv2.rectangle(cnt,(x,y),(x+w,y+h),[0,255,0],2)\\r\\n digitCnts.append(c)\\r\\n\\r\\n return cnt, digitCnts\",\n \"def cell_based_hist_segmentation(img, cells=[32, 32]):\\n descriptor = []\\n w,h = img.shape[:2]\\n w_ranges = [(i*w)//cells[0] for i in range(cells[0])]+[-1]\\n h_ranges = [(i*h)//cells[1] for i in range(cells[1])]+[-1]\\n\\n celled_hist = obtain_celled_histograms(img, cells, w_ranges, h_ranges)\\n\\n rectangular_segm = obtain_rectangular_segmentation(celled_hist, cells)\\n mask = create_mask(rectangular_segm, img, cells)\\n return mask\",\n \"def find_shapes(im_bw, kernel, th):\\n im_convolved = scipy.ndimage.filters.convolve(im_bw, kernel[::-1, ::-1])\\n im_hotspots = im_convolved >= th\\n bin_dy, bin_dx = kernel.shape\\n radius_x = bin_dx // 2\\n radius_y = bin_dy // 2\\n positions = []\\n open_for_interpretation = np.ones_like(im_convolved, dtype=bool)\\n xmax = im_hotspots.shape[1] - 1\\n ymax = im_hotspots.shape[0] - 1\\n for x in range(xmax + 1):\\n for y in range(ymax + 1):\\n if open_for_interpretation[y, x] and im_hotspots[y, x]:\\n x0 = max(0, x - radius_x)\\n x1 = min(xmax, x + radius_x)\\n y0 = max(0, y - radius_y)\\n y1 = min(ymax, y + radius_y)\\n window = im_hotspots[y0:y1, x0:x1]\\n cx, cy = center_of_mass(window, x_offset=x - radius_x, y_offset=y - radius_y)\\n positions.append([cx, cy])\\n open_for_interpretation[y0:y1, x0:x1] = False\\n return positions\",\n \"def read_board_values(self):\\r\\n\\r\\n # Iterate through each contour/cell\\r\\n for row in self.game_board_contours:\\r\\n board_row = []\\r\\n\\r\\n # For each cell, we get its location and crop the original thresholded image to that location\\r\\n for c in row:\\r\\n x, y, w, h = cv2.boundingRect(c)\\r\\n x_margin = int(w * 0.05)\\r\\n y_margin = int(h * 0.05)\\r\\n cropped_image = self.thresh_orig[y + y_margin:y + h - 2 * y_margin, x + x_margin:x + w - 2 * x_margin]\\r\\n\\r\\n # If it's mostly white, we don't need to waste time with OCR and we know it is blank\\r\\n if np.average(cropped_image) > 253:\\r\\n board_row.append(0)\\r\\n\\r\\n # Otherwise we pass it to the OCR to see which character is present within that cell\\r\\n else:\\r\\n character = pytesseract.image_to_string(cropped_image, config=self.pytesseract_config)\\r\\n # If the character is a commonly mis-read one, use dictionary to find the real character\\r\\n if character in self.replacements:\\r\\n character = self.replacements[character]\\r\\n board_row.append(character)\\r\\n self.game_board.append(board_row)\",\n \"def find_contours(mask):\\n _, contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_KCOS)\\n return contours\",\n \"def get_neighbours(self, cell):\\n\\t\\tx,y = cell.find_id()\\n\\t\\tlength = self.space.shape[1]\\n\\t\\twidth = self.space.shape[0]\\n\\t\\tif (length == 0 or width == 0 or x < 0 or x >= length or y < 0 or y >= width):\\n\\t\\t\\treturn []\\n\\t\\tneighs = [(i,j) for i in range(y-1,y+2) if 0<=i<width for j in range(x-1,x+2) if 0<=j<length]\\n\\t\\tneighbours = []\\n\\t\\tfor neigh in neighs:\\n\\t\\t\\tneighbours.append(self.space[neigh[0],neigh[1]])\\n\\t\\treturn neighbours\",\n \"def find_contours(mask):\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,\\n cv2.CHAIN_APPROX_SIMPLE)\\n cnts = imutils.grab_contours(cnts)\\n return cnts\",\n \"def contextualcull(cnts):\\n temp = []\\n actualout = []\\n indicesused = []\\n for cnt in cnts:\\n if cnt.area > CULL_MINIMUMS[cnt.spatialindex]:\\n temp.append(cnt)\\n if cnt.spatialindex not in indicesused:\\n indicesused.append(cnt.spatialindex)\\n if PRIORITIZE_FASTEST:\\n for sindex in indicesused: #filter down to the fastest contour.\\n _allatthisindex = [x for x in temp if x == sindex]\\n highest = _allatthisindex.sort(key=lambda y: y.spd, reverse=False)[0]\\n actualout.append(highest)\\n else:\\n actualout = temp\\n print 'Contours after cull: ', len(actualout)\\n return actualout\",\n \"def get_cntr_points_from_center(self, contour, img_size):\\n res_arr = []\\n half_img_size = int(np.round(img_size/3))\\n diag_coord = np.random.randint(half_img_size,2*half_img_size)\\n # find the center point\\n center_point = [diag_coord,diag_coord]\\n # define all borders point\\n border = ([[0,i] for i in np.arange(0,img_size)] + \\n [[img_size,i] for i in np.arange(0,img_size)] +\\n [[i,0] for i in np.arange(0,img_size)] + \\n [[i,img_size] for i in np.arange(0,img_size)])\\n for point in border:\\n tmp_res = []\\n row_diff = point[0] - center_point[0]\\n col_diff = point[1] - center_point[1]\\n # find the distance between center point and border point\\n dist = int(np.round(np.sqrt(row_diff*row_diff+col_diff*col_diff)))\\n # find steps for row and column to go from center to border\\n row_step = row_diff/dist\\n col_step = col_diff/dist\\n \\n row_diff = center_point[0]\\n col_diff = center_point[1]\\n c_point = [int(np.round(row_diff)),\\n int(np.round(col_diff))]\\n\\n # go from center to border until points inside image\\n while ((c_point[0]>= 0) \\n and (c_point[0] < img_size) \\n and (c_point[1]>= 0) \\n and (c_point[1] < img_size)):\\n if cv2.pointPolygonTest(contour,(c_point[0],c_point[1]),True)> 0:\\n tmp_res.append(c_point)\\n row_diff = row_diff + row_step\\n col_diff = col_diff + col_step\\n c_point = [int(np.round(row_diff)),\\n int(np.round(col_diff))]\\n if len(tmp_res):\\n res_arr.append(tmp_res)\\n return res_arr\",\n \"def find_contours(dframe):\\n #Blur the image.\\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\\n #if debug:\\n #plt.imshow(fixColor(blurred))\\n #plt.show()\\n #Get a threshold image, numbers where tested for the given video.\\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \\n cv2.CHAIN_APPROX_SIMPLE)\\n return cnts\",\n \"def get_contour(atom_list):\\n initial = [atom for atom in atom_list if ((0 < len(identify_bonds(atom, atom_list)) < 3) and (check_connected(atom, identify_bonds(atom, atom_list)) == False))]\\n \\n extra_1 = []\\n for atom in atom_list:\\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n for i in neighbours:\\n neighbours2 = [bond[0] for bond in identify_bonds(i, atom_list)]\\n for j in neighbours2:\\n if j in initial:\\n extra_1.append(atom)\\n\\n extra_2 = []\\n for atom in atom_list:\\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n check = 0\\n for i in neighbours:\\n if i in initial:\\n check += 1\\n if ((check == 2) and (atom not in initial)):\\n extra_2.append(atom) \\n return (initial + extra_1 + extra_2)\",\n \"def get_table_corner_points(img):\\n\\n img_height, img_width, img_channels = img.shape\\n lower_bounds,upper_bounds = get_table_color_bounds() # Get the bounds for the table felt color\\n\\n \\\"\\\"\\\"\\n Table Image Masking\\n \\\"\\\"\\\"\\n res = cv2.cvtColor(img,cv2.COLOR_BGR2HSV) # Convert image to HSV color space\\n mask = cv2.inRange(res,lower_bounds,upper_bounds) # Get image mask from bounds\\n res = cv2.bitwise_and(img,img,mask = mask) # Mask the image\\n\\n \\\"\\\"\\\"\\n Contour Detection\\n \\\"\\\"\\\"\\n imgray = cv2.cvtColor(res,cv2.COLOR_BGR2GRAY) # Get res in gray color space\\n tmp,thresh = cv2.threshold(imgray,255,255,255) # Threshold on the gray image\\n retr = cv2.RETR_EXTERNAL # Contour parameters\\n mode = cv2.CHAIN_APPROX_SIMPLE\\n tmp, contours, hierarchy = cv2.findContours(thresh,retr,mode) # Get contours\\n res = np.zeros((img_height,img_width,3),np.uint8) # Blank image for contours\\n color = (255,255,255) # Contour drawing parameters\\n thickness = 3\\n cv2.drawContours(res,contours,-1,color,thickness) # Draw contours on blank image\\n\\n \\\"\\\"\\\"\\n Canny Detection\\n \\\"\\\"\\\"\\n blur = 9 # Blur parameter \\n res = cv2.medianBlur(res,blur) # Blur\\n res = cv2.Canny(res,100,150,apertureSize = 3) # Canny edge detection\\n\\n \\\"\\\"\\\"\\n Hough Line Detection\\n \\\"\\\"\\\"\\n rho = 0.75 # Hough parameters\\n theta = np.pi/180\\n threshold = 150\\n lines = cv2.HoughLines(res,rho,theta,threshold) # Get lines\\n\\n \\\"\\\"\\\"\\n K-Mean 4 Line Clustering\\n \\\"\\\"\\\"\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,10,1.0) # K-Means parameters\\n flags = cv2.KMEANS_PP_CENTERS\\n n = 4\\n max_iterations = 10 \\n compactness,labels,centers = cv2.kmeans(np.float32(lines),n,None,criteria,max_iterations,flags) # K-Means\\n \\n \\\"\\\"\\\"\\n Get And Return Points\\n \\\"\\\"\\\"\\n growth = 100 # Offset to expand corners\\n pts = _get_table_corners_from_lines_hough_space(centers,growth,img_width,img_height) # Gets the corner points\\n ''' \\n mask = np.zeros((img_height,img_width,3),np.uint8)\\n cv2.fillPoly(mask,np.array([pts],dtype = np.int32),(255,255,255))\\n show_img(mask)\\n cv2.resize(mask,(img.shape[0],img.shape[1]),fx = 2, fy = 2, interpolation = cv2.INTER_CUBIC)\\n show_img(mask*2)\\n res = cv2.bitwise_and(img,mask)\\n '''\\n return pts\",\n \"def find_contour(hole_atoms, atom_list):\\n contour_atoms = []\\n extra_atoms = []\\n global bond_list\\n bond_list = bond_list_1\\n for atom in hole_atoms:\\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond[0] not in hole_atoms) and (bond[0] not in contour_atoms))]\\n for element in c:\\n contour_atoms.append(element)\\n for atom in atom_list:\\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n count = 0\\n for element in c:\\n if element in contour_atoms:\\n count += 1\\n if (count >= 2):\\n extra_atoms.append(atom)\\n for atom in atom_list:\\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n for element in c:\\n if ((element in contour_atoms) or (element in extra_atoms)):\\n for i in [bond[0] for bond in identify_bonds(element, atom_list)]:\\n if ((i in hole_atoms) and (atom not in hole_atoms) and (atom not in contour_atoms) and (atom not in extra_atoms)):\\n extra_atoms.append(atom) \\n \\n contour_atoms = contour_atoms + extra_atoms\\n \\n extra_atoms2 = []\\n for atom in contour_atoms:\\n for atom2 in contour_atoms:\\n if (atom != atom2):\\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond in identify_bonds(atom2, atom_list)) and (bond[0] not in (contour_atoms)))]\\n if (len(c) != 0):\\n extra_atoms2.append(c[0]) \\n for element in extra_atoms2:\\n contour_atoms.append(element)\\n return contour_atoms\",\n \"def analyzeContours(contours):\\n if len(contours[0]) != 4 and len(contours[0]) != 8:\\n return 0\\n\\n first, second, prev = [1, 1], [1, 1], 0\\n for i, val in enumerate(numpy.nditer(contours[0])):\\n if i % 2:\\n second = [prev, val]\\n else:\\n first = [prev, val]\\n\\n # compare pair to the previous pair\\n for num in first:\\n if num in second:\\n break\\n else:\\n return 0\\n\\n prev = val\\n\\n return 1\",\n \"def get_patch_centers(self):\\n rows, cols = np.where(self.inv_overlap_mask)\\n patch_centers = tuple(zip(rows, cols))\\n # diff = np.diff(patch_centers)\\n # ind_stop_cont = np.where(np.abs(np.diff(np.reshape(diff, diff.shape[0]))) > 1)[0][0]\\n self.patch_centers = patch_centers[:: self.sampling_int // 2]\\n print(\\\"# of samples: {}\\\".format(len(self.patch_centers)))\",\n \"def get_position_patterns(contours, hierarchy):\\n found = []\\n for i in range(len(contours)):\\n k = i\\n c = 0\\n while hierarchy[k][2] != -1:\\n k = hierarchy[k][2]\\n c += 1\\n if c >= 5:\\n found.append(i)\\n return found\",\n \"def obtain_rectangular_segmentation(celled_hist, cells):\\n celled_hist = np.array(celled_hist).reshape(cells[0]*cells[1], -1)\\n scores = l1_dist(celled_hist, celled_hist)\\n\\n layers = cells[0]//2\\n \\n left, right, top, bottom = compute_positions(scores, layers, cells, \\\"lr\\\"), compute_positions(scores, layers, cells, \\\"rl\\\"), \\\\\\n compute_positions(scores, layers, cells, \\\"tb\\\"), compute_positions(scores, layers, cells, \\\"bt\\\")\\n\\n return left, right, top, bottom\",\n \"def select_contours(img):\\n # Find contours at a constant value\\n contours = measure.find_contours(img, 300)\\n # print(\\\"Found \\\" + str(len(contours)) + \\\" contour(s)\\\")\\n # Select the nearest contours with respect to the center pixel of the image\\n width = img.shape[1] # number of columms\\n heigth = img.shape[0] # number of rows\\n pixel_ref = (width / 2, heigth / 2)\\n # Threshold distance is 10% of images smallest dimension\\n dist_thresh = min(width, heigth) * 0.1\\n contours_wanted = []\\n pixel_mean_array = []\\n for contour in contours:\\n contour_3d = np.zeros([contour.shape[0], 3]) # 3rd dimension added for later conversion to patient coord space\\n contour_3d[:, :2] = contour\\n pixel_mean = np.mean(contour, axis=0)\\n if distance.euclidean(pixel_ref, pixel_mean) <= dist_thresh:\\n contours_wanted.append(contour_3d)\\n pixel_mean_array.append(pixel_mean)\\n # print(\\\"Set \\\" + str(len(contours_wanted)) + \\\" contours of interest\\\")\\n return contours_wanted, pixel_mean_array\",\n \"def computesWingConnexions(self):\\n logger.warning(\\\"!!! WARINING !!!!\\\")\\n logger.warning(\\\"BE CERTAIN THAT CPACS FILE HAS THE HORIZONTAL TAIL\\\")\\n logger.warning(\\\"DEFINED BEFORE THE VERTICAL TAIL!!!!\\\")\\n if self.nWings <= 1:\\n logger.info(\\\"No wing connexions needed\\\")\\n elif self.nWings > 1 and self.nFuselage < 1:\\n logger.error(\\\"Multiple wings with no fuselage! Mesh can not be computed\\\")\\n sys.exit()\\n else:\\n ws_connextionsPoints = self.nWings + self.nFuselage - 1\\n # if self.nFuselage > 0:\\n # ws_connextionsPoints = self.nWings\\n # else:\\n # ws_connextionsPoints = self.nWings -1\\n\\n # ws: wings\\n # d: distance\\n # L: left, R: right, c: center\\n connectedNodes = np.zeros((ws_connextionsPoints,5))\\n for i in range(ws_connextionsPoints):\\n \\\"\\\"\\\"\\n for each wing there is 3 points that need to be taken into\\n account:\\n 1) Left tip position[0]\\n 2) center [np.floor(nNodes/2))]\\n WARNING: keep in mind that symmetric wings always have \\n an odd number of points!\\n 3) right tip position[-1]\\n \\\"\\\"\\\"\\n if self.nFuselage > 0:\\n wingIndex = i+1\\n else:\\n wingIndex = i\\n # logger.debug(\\\"Wing index = \\\"+str(wingIndex))\\n # N = len(self.aircraftNodesPoints[i])\\n currentWingNpoints = len(self.aircraftNodesPoints[wingIndex])\\n if currentWingNpoints > 2:\\n c = int(np.floor(len(self.aircraftNodesPoints[wingIndex])/2))\\n else:\\n c = 0\\n # logger.debug(\\\"c = \\\"+str(c))\\n ws_identifiers = np.empty((ws_connextionsPoints,5))\\n\\n for j in range(ws_connextionsPoints+1):\\n logger.debug(\\\"wingIndex,j = \\\"+str(wingIndex)+\\\" \\\"+str(j))\\n if wingIndex != j:\\n # c: stands for current\\n logger.debug(\\\"True with wingIndex,j = \\\"+str(wingIndex)+\\\" \\\"+str(j))\\n # Computes the distances between all point\\n dist_l = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][0], axis=1)\\n if currentWingNpoints > 2:\\n dist_c = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][c], axis=1)\\n else:\\n dist_c = dist_l\\n dist_r = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][-1],axis=1)\\n\\n # Gets the index of the minimal distance between all point\\n index_l = np.argmin(dist_l)\\n if currentWingNpoints > 2:\\n index_c = np.argmin(dist_c)\\n else:\\n index_c = index_l\\n index_r = np.argmin(dist_r)\\n indexes = np.array([index_l, index_c, index_r])\\n\\n # gets the minimal distance for each wing part\\n minDist_l = dist_l[index_l]\\n if currentWingNpoints > 2:\\n minDist_c = dist_c[index_c]\\n else:\\n minDist_c = minDist_l\\n minDist_r = dist_r[index_r]\\n minDist = np.array([minDist_l,minDist_c,minDist_r])\\n\\n k = np.argmin(minDist)\\n minimalDistance = minDist[k]\\n m = indexes[k]\\n r = len(self.aircraftNodesPoints[wingIndex])\\n tab = np.array([0,c,r])\\n k = tab[k]\\n\\n # minimalDistance: distance between both of these points\\n identifier = np.array([wingIndex,j,k,m,minimalDistance])\\n # logger.debug(\\\"Identifier \\\\n\\\"+str(identifier))\\n if j < wingIndex:\\n ws_identifiers[j] = identifier\\n else:\\n ws_identifiers[j-1] = identifier\\n \\n index2 = np.argmin(ws_identifiers[:,4])\\n old = np.array([ws_identifiers[index2,2],\\n ws_identifiers[index2,3],\\n ws_identifiers[index2,0],\\n ws_identifiers[index2,1],\\n ws_identifiers[index2,4]])\\n if old in connectedNodes and i > 1:\\n logger.warning(\\\"Found a matching connexion\\\")\\n logger.debug(old)\\n logger.debug(ws_identifiers)\\n ws_identifiers = np.delete(ws_identifiers,index2,0)\\n logger.debug(ws_identifiers)\\n index2 = np.argmin(ws_identifiers[:,4])\\n connectedNodes[i] = ws_identifiers[index2]\\n logger.debug(\\\"connected Nodes: \\\\n\\\"+str(connectedNodes[i]))\\n # logger.debug(connectedNodes)\\n \\n self.aircraftConnectedNodes.append(connectedNodes)\\n self.rigidNodesAdder()\\n # sys.exit()\",\n \"def cell_merge(wsh, pred):\\n wshshape=wsh.shape\\n \\n # masks for the original cells\\n objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\\t\\n \\n # masks for dilated cells\\n dil_objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\\n \\n # bounding box coordinates\\t\\n obj_coords = np.zeros((wsh.max()+1,4))\\n \\n # cleaned watershed, output of function\\t\\n wshclean = np.zeros((wshshape[0],wshshape[1]))\\n \\n # kernel to dilate objects\\n kernel = np.ones((3,3), dtype=bool)\\t\\n \\n for obj1 in range(wsh.max()):\\n # create masks and dilated masks for obj\\n objs[obj1,:,:] = wsh==(obj1+1)\\t\\n dil_objs[obj1,:,:] = dilation(objs[obj1,:,:], kernel)\\t\\n \\n # bounding box\\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\\n \\n objcounter = 0\\t# counter for new watershed objects\\n \\n for obj1 in range(wsh.max()):\\t\\n dil1 = dil_objs[obj1,:,:]\\n\\n # check if mask has been deleted\\n if np.sum(dil1) == 0:\\n continue\\n \\n objcounter = objcounter + 1\\n orig1 = objs[obj1,:,:]\\n\\n for obj2 in range(obj1+1,wsh.max()):\\n dil2 = dil_objs[obj2,:,:]\\n \\n # only check border if bounding box overlaps, and second mask \\n # is not yet deleted\\n if (do_box_overlap(obj_coords[obj1,:], obj_coords[obj2,:])\\n and np.sum(dil2) > 0):\\n \\n border = dil1 * dil2\\t\\n border_pred = pred[border]\\n \\n # Border is too small to be considered\\n if len(border_pred) < 32:\\n continue\\n \\n # Sum of top 25% of predicted border values\\n q75 = np.quantile(border_pred, .75)\\n top_border_pred = border_pred[border_pred >= q75]\\n top_border_height = top_border_pred.sum()\\n top_border_area = len(top_border_pred)\\n \\n # merge cells\\n if top_border_height / top_border_area > .99:\\n orig1 = np.logical_or(orig1, objs[obj2,:,:])\\n dil_objs[obj1,:,:] = np.logical_or(dil1, dil2)\\n dil_objs[obj2,:,:] = np.zeros((wshshape[0], wshshape[1]))\\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\\n \\n wshclean = wshclean + orig1*objcounter\\n \\n return wshclean\",\n \"def find_rects_white(image: np.ndarray) -> List[np.ndarray]:\\n\\n raise NotImplementedError()\\n\\n #gray = norm_color_test(image.copy())\\n gray = cv.cvtColor(image.copy(), cv.COLOR_RGB2GRAY)\\n gray = cv.GaussianBlur(gray, (5, 5), 0)\\n #edged = cv.Canny(gray, 70, 180) # this numbers is hand picked guess from a few photos\\n edged = auto_canny(gray) # this numbers is hand picked guess from a few photos\\n\\n # split to HSV, then pick up rouhly any white color zeroing out the rest\\n hsv = cv.cvtColor(image.copy(), cv.COLOR_RGB2HSV)\\n h,s,v = cv.split(hsv)\\n h[h<145] = 0\\n h[h>165] = 0\\n #h = cv.GaussianBlur(h, (5, 5), 0)\\n normed = cv.normalize(h, None, 0, 255, cv.NORM_MINMAX, cv.CV_8UC1)\\n kernel = cv.getStructuringElement(shape=cv.MORPH_ELLIPSE, ksize=(5,5))\\n opened = cv.morphologyEx(normed, cv.MORPH_OPEN, kernel)\\n\\n # now find white regions contours\\n whites = cv.findContours(opened, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)[0]\\n whites.sort(key=cv.contourArea, reverse=True)\\n whites = [cnt for cnt in whites if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\\n\\n whiterects = []\\n for i in whites:\\n rect = cv.minAreaRect(i)\\n w,h = rect[1]\\n if w*h > 150: # 150px area, or rougly 12x12 pixels\\n whiterects.append(rect)\\n\\n #cv.drawContours(image, whites, -1, COLORS[2 % len(COLORS)], 2)\\n #cv.imshow('test', image)\\n #cv.waitKey()\\n\\n whites = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), whiterects))\\n\\n\\n\\n #cv.imshow('test', edged)\\n #cv.waitKey()\\n\\n contours = cv.findContours(edged.copy(), cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)\\n contours = contours[0] if len(contours) == 2 else contours[1]\\n contours.sort(key=cv.contourArea, reverse=True)\\n contours = [cnt for cnt in contours if cv.contourArea(cnt) > 15] # 15px contour area, basically cnt>=4x4\\n\\n rects = list(map(cv.minAreaRect, contours))\\n boxes = list(map(lambda r: Rect.from_cvrect(*r[0], *r[1]), rects))\\n\\n # filter non overlapping contours\\n for i in reversed(range(len(boxes))):\\n overlaps = False\\n for wbox in whites:\\n if wbox.overlaps(boxes[i]):\\n overlaps = True\\n break\\n if not overlaps:\\n boxes.pop(i)\\n\\n boxes = Rect.nms_merge(boxes)\\n\\n for i in range(len(contours)):\\n #peri = cv.arcLength(contours[i], True)\\n #approx = cv.approxPolyDP(contours[i], 0.02 * peri, True)\\n rect = cv.minAreaRect(contours[i])\\n box = cv.boxPoints(rect)\\n box = np.int0(box)\\n #cv.drawContours(image, [box], -1, COLORS[i % len(COLORS)], 2)\\n #cv.putText(image, f'{i}: {cv.contourArea(contours[i])}px', (int(rect[0][0]), int(rect[0][1])), cv.FONT_HERSHEY_SIMPLEX, 0.6, COLORS[i % len(COLORS)], 1)\\n\\n #cv.drawContours(image, contours, -1, COLORS[1], 2)\\n\\n for b in boxes:\\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmax), int(b.ymin)), (0, 255, 255), 2)\\n cv.line(image, (int(b.xmin), int(b.ymax)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\\n cv.line(image, (int(b.xmin), int(b.ymin)), (int(b.xmin), int(b.ymax)), (0, 255, 255), 2)\\n cv.line(image, (int(b.xmax), int(b.ymin)), (int(b.xmax), int(b.ymax)), (0, 255, 255), 2)\\n\\n stacked = np.hstack( (cv.cvtColor(edged, cv.COLOR_GRAY2RGB), cv.cvtColor(opened, cv.COLOR_GRAY2RGB), image))\\n cv.namedWindow('test', 0)\\n cv.imshow('test', stacked)\\n cv.waitKey()\\n\\n cv.imwrite('dump.jpg', stacked)\\n\\n\\n return boxes or list()\",\n \"def find_contours(vertical, horizontal):\\n\\tmask = vertical + horizontal\\n\\n\\ttry:\\n\\t\\t__, contours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\texcept ValueError:\\n\\t\\t# for opencv backward compatibility\\n\\t\\tcontours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\t# sort in reverse based on contour area and use first 10 contours\\n\\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\\n\\n\\tcont = []\\n\\tfor c in contours:\\n\\t\\tc_poly = cv2.approxPolyDP(c, 3, True)\\n\\t\\tx, y, w, h = cv2.boundingRect(c_poly)\\n\\t\\tcont.append((x, y, w, h))\\n\\treturn cont\",\n \"def register_cells(contours: List[np.array]) -> np.array:\\n def create_cell(contour: np.array) -> np.array:\\n center, radius = cv2.minEnclosingCircle(contour)\\n v = (0, 0)\\n weight = -1\\n\\n return np.array([center[0], center[1], v[0], v[1], radius, weight])\\n\\n areas = np.array([cv2.contourArea(contour) for contour in contours]).astype(\\\"float32\\\")\\n blobs = np.array([create_cell(contour) for contour in contours]).astype(\\\"int32\\\")\\n\\n return blobs[areas >= 100].astype(\\\"float32\\\")\",\n \"def getContours( self,img ):\\n if( len(img.shape) == 3):\\n (_, contours, _) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n (contours,_) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def findings_2_idx(findings, corner_2_idx, funcx, funcy):\\n idx = []\\n for finding in findings:\\n x, y = finding\\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\\n idx.extend([corner_2_idx(c) for c in mesh])\\n\\n return np.unique(idx)\",\n \"def _get_end_points(self, segmented_instances, i, stats, idx):\\n\\n end_points=[]\\n\\n # find all points intersecting the bbox\\n #(tl_x, th_y, width, height, area)\\n label_num=i+1\\n leftmost_x = stats['bbox'][i][cv2.CC_STAT_LEFT]\\n topmost_y = stats['bbox'][i][cv2.CC_STAT_TOP]\\n width = stats['bbox'][i][cv2.CC_STAT_WIDTH]\\n height = stats['bbox'][i][cv2.CC_STAT_HEIGHT]\\n bottom_most_y = topmost_y + height-1\\n right_most_x = leftmost_x + width-1\\n\\n segmented_instances_copy=segmented_instances.copy()\\n edge_points = np.zeros(segmented_instances.shape).astype(np.uint8)\\n segs = np.zeros(segmented_instances.shape).astype(np.uint8)\\n segs[segmented_instances==label_num]=255\\n cv2.rectangle(segmented_instances_copy,(leftmost_x, topmost_y), (right_most_x, bottom_most_y), 150, 2)\\n\\n #Get all points for the current stem segment\\n label_points = np.argwhere(segmented_instances.copy()==label_num)\\n\\n # upper points from (tl_x,th_y) to (th_x, th_y) that instersect with the upper edge of the bouding box\\n upper_points = [i for i in label_points if i[0]==topmost_y and i[1]>=leftmost_x and i[1]<=right_most_x]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(upper_points, edge_points, segs, 1)\\n center_upper_pts = sorted(self._get_centeroids(x_pts))\\n\\n # left side points from (tl_x, tl_y) to (tl_x, th_y) that instersect with the left edge of the bouding box\\n left_points = [i for i in label_points if i[1]==leftmost_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(left_points, edge_points, segs, 0)\\n center_left_pts = sorted(self._get_centeroids(x_pts))\\n\\n #right side points form (th_x, tl_y) to (th_x, th_y) that instersect with the right edge of the bouding box\\n right_points = [i for i in label_points if i[1]==right_most_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(right_points, edge_points, segs, 0)\\n center_right_pts = sorted(self._get_centeroids(x_pts))\\n\\n #bottom points from (tl_x, tl_y) to (th_x,tl_y)\\n bottom_points = [i for i in label_points if i[1]>=leftmost_x and i[1]<=right_most_x and i[0]==bottom_most_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(bottom_points, edge_points, segs, 1)\\n center_bottom_pts = sorted(self._get_centeroids(x_pts))\\n\\n # If there are corner edges, get the centroid of that\\n center_x_lb, center_y_lb, center_left_pts, center_bottom_pts = self._get_corner_centers(center_left_pts, \\\\\\n center_bottom_pts, bottom_most_y, leftmost_x)\\n if (center_x_lb != None) and (center_y_lb != None):\\n end_points.append([center_x_lb, center_y_lb])\\n else:\\n if len(center_left_pts)>0:\\n for pt_idx in range(0, len(center_left_pts)):\\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\\n if len(center_bottom_pts)>0:\\n for pt_idx in range(0, len(center_bottom_pts)):\\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\\n\\n # If there are corner edges, get the centroid of that\\n center_x_ur, center_y_ur, center_right_pts, center_upper_pts = self._get_corner_centers(center_right_pts, \\\\\\n center_upper_pts, topmost_y, right_most_x)\\n if (center_x_ur != None) and (center_y_ur != None):\\n end_points.append([center_x_ur, center_y_ur])\\n else:\\n if len(center_right_pts)>0:\\n for pt_idx in range(0, len(center_right_pts)):\\n end_points.append([right_most_x, center_right_pts[pt_idx]])\\n if len(center_upper_pts)>0:\\n for pt_idx in range(0, len(center_upper_pts)):\\n end_points.append([center_upper_pts[pt_idx], topmost_y])\\n\\n # If there are corner edges, get the centroid of that\\n center_x_ul, center_y_ul, center_left_pts, center_upper_pts = self._get_corner_centers(center_left_pts, \\\\\\n center_upper_pts, topmost_y, leftmost_x)\\n if (center_x_ul != None) and (center_y_ul != None):\\n end_points.append([center_x_ul, center_y_ul])\\n else:\\n if len(center_left_pts)>0:\\n for pt_idx in range(0, len(center_left_pts)):\\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\\n if len(center_upper_pts)>0:\\n for pt_idx in range(0, len(center_upper_pts)):\\n end_points.append([center_upper_pts[pt_idx], topmost_y])\\n\\n\\n # If there are corner edges, get the centroid of that\\n center_x_br, center_y_br, center_right_pts, center_bottom_pts = self._get_corner_centers(center_right_pts, \\\\\\n center_bottom_pts, bottom_most_y, right_most_x)\\n if (center_x_br != None) and (center_y_br != None):\\n end_points.append([center_x_br, center_y_br])\\n else:\\n if len(center_right_pts)>0:\\n for pt_idx in range(0, len(center_right_pts)):\\n end_points.append([right_most_x, center_right_pts[pt_idx]])\\n if len(center_bottom_pts)>0:\\n for pt_idx in range(0, len(center_bottom_pts)):\\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\\n\\n #self.showme(segmented_instances_copy, 'bbox')\\n\\n return end_points\",\n \"def get_shapes(self):\\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\\n X = []\\n backmap = {}\\n rad = 3\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\\n colours[i][j] = m\\n X.append(m)\\n backmap[k] = (i,j)\\n print(np.shape(X))\\n Z = linkage(X, 'ward')\\n Q = fcluster(Z, self.thresh, criterion='distance')\\n\\n closenesses = []\\n for k,cls in enumerate(Q):\\n i,j = backmap[k]\\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\\n minidx = np.argmin(closenesses)\\n bgcls = Q[minidx]\\n\\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\\n img4 = self.img2.copy()\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n cls = Q[k]\\n if cls == bgcls:\\n continue\\n col = blibs[(cls-1)]\\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\\n\\n write_img(\\\"./out/test_classes.png\\\", img4)\\n self.classimg = img4\\n\\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\\n mx = np.max(Q)\\n for k,cls in enumerate(Q):\\n if cls == bgcls:\\n continue\\n\\n if cls == mx:\\n plotcls = bgcls\\n else:\\n plotcls = cls\\n i,j = backmap[k]\\n A[i][j] = plotcls\\n\\n self.res = A\",\n \"def find_neighbors(masks, i, r=1):\\n \\n mask = np.uint8(masks == i)\\n # create the border in which we'll look at other masks\\n kernel = morphology.disk(r)\\n dilated = cv.dilate(mask, kernel, iterations=1)\\n dilated = dilated.astype(np.bool)\\n # detect potential touching masks\\n neighbors = np.unique(masks[dilated])\\n # discard the initial cell id of interest\\n neighbors = neighbors[neighbors != i]\\n # discard the background value\\n return neighbors[neighbors != 0]\",\n \"def get_integral_descriptors(image,filtered_coords,wid=5):\\n desc = []\\n for coords in filtered_coords:\\n patch = image[coords[0]-wid:coords[0]+wid+1,\\n coords[1]-wid:coords[1]+wid+1]\\n desc.append(patch)\\n return desc\",\n \"def get_descriptors(image,filtered_coords,wid=5):\\n desc = []\\n for coords in filtered_coords:\\n patch = image[coords[0]-wid:coords[0]+wid+1,\\n coords[1]-wid:coords[1]+wid+1].flatten()\\n desc.append(patch)\\n return desc\",\n \"def find_contours(img_path, **kwargs):\\n threshold = kwargs['threshold']\\n image = cv2.imread(img_path)\\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\n blurred = cv2.GaussianBlur(gray, (5, 5), 0)\\n thresh = cv2.threshold(blurred, threshold, 255, cv2.THRESH_BINARY)[1]\\n contours, _ = cv2.findContours(thresh.copy(),\\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n\\n\\n contour_areas = [] # TODO: is there a faster way to keep the contors with n-largest areas?\\n for i, contour in enumerate(contours):\\n area = cv2.contourArea(contour)\\n contour_areas.append((i, area))\\n\\n rect = cv2.minAreaRect(contour)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n cv2.drawContours(image,[box],0,(0,0,255),2)\\n cv2.imwrite('rect_{}.png'.format(i), image)\\n # Contours that cover the largest areas are whole pieces\\n largest_contour_areas = nlargest(10, contour_areas, key=lambda x:x[1])\\n #print(largest_contour_areas)\\n\\n for i, area in largest_contour_areas:\\n print (i, area)\\n cv2.drawContours(image, contours, i, (100, 155, 100), 3)\\n cv2.imwrite('contor_{}.png'.format(i), image)\\n return True\",\n \"def recognize_pieces(edges, v, squares):\\n\\n pieces = []\\n\\n v = cv2.equalizeHist(v)\\n for p1, p2 in squares:\\n # count the number of slightly centered edges\\n occupancy = sum(edges[y][x]\\n for x in range(p1.x + 5, p2.x - 5)\\n for y in range(p1.y + 5, p2.y - 5))\\n\\n if occupancy > 70*255:\\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\\n v[p2.y][p1.x], v[p2.y][p2.x])\\n\\n # average v-component of the corners\\n avg = sum(map(float, corners)) / len(corners)\\n\\n # black pixels should be relatively black\\n # when compared to the corner average\\n black = sum(v[y][x] / avg < 0.2\\n for x in range(p1.x, p2.x + 1)\\n for y in range(p1.y, p2.y + 1))\\n\\n if black >= 1000 and black != 1049:\\n color = \\\"B\\\"\\n else:\\n color = \\\"W\\\"\\n\\n pieces.append(color)\\n else:\\n pieces.append(None)\\n\\n return pieces\",\n \"def findFours(self):\\n\\n for i in range(6):\\n for j in range(7):\\n if self.board[i][j] != ' ':\\n # check if a vertical four-in-a-row starts at (i, j)\\n if self.verticalCheck(i, j):\\n self.highlightFour(i, j, 'vertical')\\n \\n # check if a horizontal four-in-a-row starts at (i, j)\\n if self.horizontalCheck(i, j):\\n self.highlightFour(i, j, 'horizontal')\\n \\n # check if a diagonal (either way) four-in-a-row starts at (i, j)\\n # also, get the slope of the four if there is one\\n diag_fours, slope = self.diagonalCheck(i, j)\\n if diag_fours:\\n self.highlightFour(i, j, 'diagonal', slope)\",\n \"def get_building_contour(current_building_mask):\\n ret, threshed = cv.threshold(current_building_mask, 0, 2 ** 16, cv.THRESH_BINARY)\\n compressed = threshed.astype(np.uint8)\\n current_building_contour, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n return current_building_contour, hierarchy\",\n \"def index_by_border(tiles):\\n by_border = {\\n \\\"north\\\": defaultdict(lambda: []),\\n \\\"east\\\": defaultdict(lambda: []),\\n \\\"south\\\": defaultdict(lambda: []),\\n \\\"west\\\": defaultdict(lambda: []),\\n }\\n borders = {}\\n inners = {}\\n for tile_id, tile_rows in tiles.items():\\n north, east, south, west, inner = get_borders(tile_rows)\\n by_border[\\\"north\\\"][north].append(tile_id)\\n by_border[\\\"east\\\"][east].append(tile_id)\\n by_border[\\\"south\\\"][south].append(tile_id)\\n by_border[\\\"west\\\"][west].append(tile_id)\\n inners[tile_id] = inner\\n borders[tile_id] = (north, east, south, west)\\n return by_border, borders, inners\",\n \"def segment_cells(frame, mask=None):\\n \\n blurred = filters.gaussian(frame, 2)\\n ridges = enhance_ridges(frame)\\n \\n # threshold ridge image\\n thresh = filters.threshold_otsu(ridges)\\n thresh_factor = 0.5\\n prominent_ridges = ridges > thresh_factor*thresh\\n prominent_ridges = morphology.remove_small_objects(prominent_ridges, min_size=256)\\n prominent_ridges = morphology.binary_closing(prominent_ridges)\\n prominent_ridges = morphology.binary_dilation(prominent_ridges)\\n \\n # skeletonize\\n ridge_skeleton = morphology.medial_axis(prominent_ridges)\\n ridge_skeleton = morphology.binary_dilation(ridge_skeleton)\\n ridge_skeleton *= mask\\n ridge_skeleton = np.bitwise_xor(ridge_skeleton, mask)\\n \\n # label\\n cell_label_im = measure.label(ridge_skeleton)\\n \\n # morphological closing to fill in the cracks\\n for cell_num in range(1, cell_label_im.max()+1):\\n cell_mask = cell_label_im==cell_num\\n cell_mask = morphology.binary_closing(cell_mask, disk(3))\\n cell_label_im[cell_mask] = cell_num\\n \\n return cell_label_im\",\n \"def _check_intrusion(self, detections):\\n width, height = self.frame_size\\n\\n results = []\\n for i in range(len(detections)):\\n (bboxes, scores, classes, num_candidates) = detections[i]\\n\\n in_roi_cands = {}\\n for j in range(int(num_candidates[0])):\\n # Check if score passes the threshold.\\n if scores[0][j] < self.detect_threshold:\\n continue\\n # Check if the object in in the trigger list.\\n # XXX: Is it posssible to generate index that is not in the\\n # category_index list?\\n try:\\n label = self._category_index[int(classes[0][j])]\\n except KeyError:\\n continue\\n else:\\n if label not in self.triggers:\\n continue\\n # Check whether the object's bbox is in roi or not.\\n ymin, xmin, ymax, xmax = bboxes[0][j]\\n unnormalized_bbox = (xmin * width, ymin * height,\\n xmax * width, ymax * height)\\n if self._is_in_roi(unnormalized_bbox):\\n if not bool(in_roi_cands):\\n # This is the first detected object candidate\\n in_roi_cands = {\\\"bboxes\\\": [], \\\"scores\\\": [], \\\"labels\\\": []}\\n in_roi_cands[\\\"bboxes\\\"].append(bboxes[0][j].tolist())\\n in_roi_cands[\\\"scores\\\"].append(scores[0][j].tolist())\\n in_roi_cands[\\\"labels\\\"].append(label)\\n results.append(in_roi_cands)\\n return results\",\n \"def textDetectWatershed(thresh, original):\\n # According to: http://docs.opencv.org/trunk/d3/db4/tutorial_py_watershed.html\\n img = resize(original, 3000)\\n thresh = resize(thresh, 3000)\\n # noise removal\\n kernel = np.ones((3,3),np.uint8)\\n opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 3)\\n \\n # sure background area\\n sure_bg = cv2.dilate(opening,kernel,iterations=3)\\n\\n # Finding sure foreground area\\n dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\\n ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0)\\n\\n # Finding unknown region\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg,sure_fg)\\n \\n # Marker labelling\\n ret, markers = cv2.connectedComponents(sure_fg)\\n\\n # Add one to all labels so that sure background is not 0, but 1\\n markers += 1\\n\\n # Now, mark the region of unknown with zero\\n markers[unknown == 255] = 0\\n \\n markers = cv2.watershed(img, markers)\\n implt(markers, t='Markers')\\n image = img.copy()\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n \\n # Creating result array\\n boxes = []\\n for mark in np.unique(markers):\\n # mark == 0 --> background\\n if mark == 0:\\n continue\\n\\n # Draw it on mask and detect biggest contour\\n mask = np.zeros(gray.shape, dtype=\\\"uint8\\\")\\n mask[markers == mark] = 255\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\\n c = max(cnts, key=cv2.contourArea)\\n \\n # Draw a bounding rectangle if it contains text\\n x,y,w,h = cv2.boundingRect(c)\\n cv2.drawContours(mask, c, 0, (255, 255, 255), cv2.FILLED)\\n maskROI = mask[y:y+h, x:x+w]\\n # Ratio of white pixels to area of bounding rectangle\\n r = cv2.countNonZero(maskROI) / (w * h)\\n \\n # Limits for text\\n if r > 0.1 and 2000 > w > 15 and 1500 > h > 15:\\n boxes += [[x, y, w, h]]\\n \\n # Group intersecting rectangles\\n boxes = group_rectangles(boxes)\\n bounding_boxes = np.array([0,0,0,0])\\n for (x, y, w, h) in boxes:\\n cv2.rectangle(image, (x, y),(x+w,y+h), (0, 255, 0), 8)\\n bounding_boxes = np.vstack((bounding_boxes, np.array([x, y, x+w, y+h])))\\n \\n implt(image)\\n\\n # Recalculate coordinates to original size\\n boxes = bounding_boxes.dot(ratio(original, img.shape[0])).astype(np.int64)\\n return boxes[1:]\",\n \"def detect(image):\\n markers = []\\n # Stage 1: Detect edges in image\\n gray = cvtColor(image, COLOR_BGR2GRAY)\\n clahe = createCLAHE(clipLimit=1, tileGridSize=(6, 6))\\n cl1 = clahe.apply(gray)\\n _, thresh = threshold(cl1, 60, 255, THRESH_OTSU)\\n blurred = GaussianBlur(thresh, (5, 5), 0)\\n edges = Canny(blurred, 75, 100)\\n\\n # Stage 2: Find contours\\n contours = findContours(edges, RETR_TREE, CHAIN_APPROX_SIMPLE)\\n contours = sorted(contours, key=contourArea, reverse=True)[:]\\n\\n for contour in contours:\\n # Stage 3: Shape check\\n perimeter = arcLength(contour, True)\\n approx = approxPolyDP(contour, 0.01*perimeter, True)\\n\\n if len(approx) == QUADRILATERAL_POINTS:\\n area = contourArea(approx)\\n # (x, y, w, h) = boundingRect(approx)\\n # ar = float(h) / float(w)\\n # if area > 100 and ar >= 0.8 and ar <= 1.2:\\n if area > 700:\\n # putText(image, str(area), (10, 30), FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)\\n drawContours(image, [contour], -1, (0, 255, 0), 1)\\n\\n # Stage 4: Perspective warping\\n topdown_quad = get_topdown_quad(thresh, approx.reshape(4, 2))\\n\\n # Stage 5: Border check\\n if topdown_quad[int((topdown_quad.shape[0]/100.0)*5), int((topdown_quad.shape[1]/100.0)*5)] > BLACK_THRESHOLD:\\n continue\\n\\n # Stage 6: Get marker pattern\\n marker_pattern = None\\n\\n try:\\n marker_pattern = get_marker_pattern(topdown_quad, THRESHOLD_PERCENT)\\n except:\\n continue\\n\\n if not marker_pattern:\\n continue\\n\\n # Stage 7: Match marker pattern\\n marker_found, marker_rotation, marker_name = match_marker_pattern(marker_pattern)\\n\\n if marker_found:\\n markers.append([marker_name, marker_rotation])\\n\\n return markers, image\",\n \"def cross_junctions(I, bounds, Wpts):\\n #--- FILL ME IN ---\\n\\n Ipts = np.zeros((2, 48))\\n\\n#parameters\\n alpha = 0.15 #typically 0.04 to 0.06\\n threshold = 1500 #default 2000\\n sigma = 2\\n ws = 12 #window size for saddle point\\n\\n#building Harris Detecter\\n I = I/255.0\\n gradx, grady = np.gradient(I)\\n IxIx = gaussian_filter(gradx*gradx,sigma)\\n IxIy = gaussian_filter(gradx*grady,sigma)\\n IyIy = gaussian_filter(grady*grady,sigma)\\n print(I.shape)\\n\\n #get harris score\\n cand_score = []\\n cand_index = []\\n cand = []\\n s_cand = []\\n\\n for j in range(len(I)):\\n for i in range(len(I[0])):\\n a11 = IxIx[j][i]\\n a12 = IxIy[j][i]\\n a21 = a12\\n a22 = IyIy[j][i]\\n A = np.array([[a11, a12],[a21, a22]])\\n ev0, ev1 = np.linalg.eigvals(A)\\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\\n cand_score.append(-h_score)\\n cand_index.append([i, j])\\n\\n #get the coordinates of the top 5000 scores\\n sorted_ind = np.argsort(cand_score)\\n sorted_score = np.sort(cand_score).tolist()\\n\\n for ind in sorted_ind[:threshold]:\\n cand.append(cand_index[ind])\\n s_cand = sorted_score[:threshold]\\n\\n\\n#clustering\\n #using homography to project candidate points to a up-front view\\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\\n H = dlt_homography(bounds, new_bbox)\\n cand = np.array(cand).T\\n cand = np.vstack((cand, np.ones(cand.shape[1])))\\n Ho_cand = np.matmul(H,cand).T\\n for pt in Ho_cand:\\n pt[0] = pt[0]/pt[2]\\n pt[1] = pt[1]/pt[2]\\n Ho_cand = Ho_cand[:,:2]\\n Ho_cand = Ho_cand.tolist()\\n\\n #get rid of points that are not in the boundry\\n temp_Ho_cand = []\\n temp_s_cand = []\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\\n continue\\n else:\\n temp_Ho_cand.append(pt)\\n temp_s_cand.append(s_cand[i])\\n Ho_cand = np.array(temp_Ho_cand)\\n s_cand = temp_s_cand\\n #divide candidates into clusters\\n assignment = []\\n assignment_score = []\\n\\n #first put in the point that has the highest score\\n assignment.append([Ho_cand[0]])\\n assignment_score.append([s_cand[0]])\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n if min(dist) > 6:\\n assignment.append([pt])\\n assignment_score.append([s_cand[i]])\\n\\n assignment = np.array(assignment)\\n\\n #assign points to clusters\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\\n continue\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n index = np.argsort(dist)[-1]\\n np.append(assignment[index], pt)\\n assignment_score[index].append(s_cand[i])\\n\\n #get centroids for each cluster\\n Ho_centroids = []\\n for i in range(len(assignment)):\\n cl = assignment[i]\\n cl = np.array(cl)\\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\\n assignment_score[i] = sum(assignment_score[i])\\n\\n print(len(assignment_score))\\n\\n Ho_centroids = np.array(Ho_centroids)\\n #get rid of edge points\\n\\n xmin = np.amin(Ho_centroids.T[0])\\n xmax = np.amax(Ho_centroids.T[0]) \\n ymin = np.amin(Ho_centroids.T[1])\\n ymax = np.amax(Ho_centroids.T[1])\\n\\n final_cand = []\\n final_score = []\\n for i in range(len(Ho_centroids)):\\n pt = Ho_centroids[i]\\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\\n continue\\n else:\\n final_cand.append(pt)\\n final_score.append(assignment_score[i])\\n print(\\\"Number of corner found: \\\")\\n print(len(final_cand))\\n\\n #get rid of fake corners\\n if (len(final_cand)>48):\\n ultimate_cand =[]\\n for ind in np.argsort(final_score)[:48]:\\n ultimate_cand.append(final_cand[ind])\\n final_cand = ultimate_cand\\n print(\\\"real corners count:\\\", len(ultimate_cand))\\n\\n\\n #sort the points\\n final_cand = np.array(final_cand)\\n y_sort_ind = np.argsort(final_cand.T[1])\\n final_cand = final_cand.tolist()\\n rows = []\\n for i in range(6):\\n row = []\\n for ind in y_sort_ind[i*8:(i+1)*8]:\\n row.append(final_cand[ind])\\n rows.append(row)\\n\\n ordered = []\\n for row in rows:\\n r = []\\n x_sort_ind = np.argsort(np.array(row).T[0])\\n for ind in x_sort_ind:\\n r.append(row[ind])\\n ordered.append(r)\\n\\n final_cand = []\\n for row in ordered:\\n for pt in row:\\n final_cand.append(pt)\\n \\n\\n\\n #get coordinates of the centroids in the original frame\\n Ho_centroids = np.array(final_cand)\\n\\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\\n centroids = np.matmul(np.linalg.inv(H), centroids).T\\n for pt in centroids:\\n pt[0] = int(pt[0]/pt[2])\\n pt[1] = int(pt[1]/pt[2])\\n centroids = centroids[:,:2]\\n\\n#finding saddle points around the centroids\\n saddle_points = []\\n for pt in centroids:\\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\\n saddle = saddle_point(img)\\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\\n saddle_points.append(saddle)\\n\\n saddle_points = np.array(saddle_points)\\n #------------------\\n print(saddle_points.T)\\n return saddle_points.T\",\n \"def findCrossings(img):\\n\\tcrossings = 0\\n\\n\\t# 2d list of pixel values\\n\\toriginalImg = []\\n\\tfor x in range(img.size[0]):\\n\\t\\tcolValues = []\\n\\t\\tfor y in range(img.size[1]):\\n\\t\\t\\tcolValues.append(img.getpixel((x, y)))\\n\\t\\toriginalImg.append(colValues)\\n\\n\\t# iterate over 9 pixel sections\\n\\tfor x in range(1, img.size[0] - 1):\\n\\t\\tfor y in range(1, img.size[1] - 1):\\n\\t\\t\\tif originalImg[x][y] == (0, 0, 0, 255) and numZeroesAround(originalImg, (x,y)) >= 4:\\n\\t\\t\\t\\timg = colorCross(img, (x, y))\\n\\t\\t\\t\\tcrossings += 1\\n\\n\\tprint \\\"Crossings that occur:\\\", crossings\\n\\treturn img\",\n \"def get_cntr_points(self, contour, img_size):\\n res_arr = []\\n # for each row\\n for row in range(img_size):\\n tmp_arr = []\\n # for each column\\n for col in range(img_size):\\n # if point in contour\\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\\n # add point to current line\\n tmp_arr.append([row,col])\\n if len(tmp_arr):\\n # add current line to result array\\n res_arr.append(tmp_arr)\\n return res_arr\",\n \"def watershed(self, debug=False):\\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg, sure_fg)\\n ret, markers = cv2.connectedComponents(sure_fg)\\n markers += 1\\n markers[unknown == 255] = 0\\n markers = cv2.watershed(self.img, markers)\\n self.add_color(markers)\\n if debug:\\n cv2.imshow(\\\"fg\\\", unknown)\\n cv2.imshow(\\\"op\\\", opening)\\n cv2.imshow(\\\"o3\\\", sure_bg)\",\n \"def get_indices(waves):\\n prob_ = np.abs(waves)**2\\n # batch\\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\\n prob = np.asarray(prob)\\n prob_tot = np.sum(prob, axis=0)\\n \\n # cutoff\\n length = np.size(prob[:,0])\\n len10 = int(length/10)\\n flags = np.zeros((prob.shape[1]), dtype=int)\\n # hinges\\n # 50% within 10% of corners\\n\\n # surface\\n # 50% within 10% of surfaces\\n # not already labelled hinges\\n prob_left = np.sum(prob[0:len10,:], axis=0)\\n frac_left = prob_left/prob_tot\\n\\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\\n frac_right = np.divide(prob_right, prob_tot)\\n\\n for i in range(len(flags)):\\n if frac_left[i]>0.5 or frac_right[i]>0.5:\\n flags[i] = 1\\n \\n indices = [i for i, x in enumerate(flags) if x == 1]\\n indices0 = [i for i, x in enumerate(flags) if x == 0]\\n \\n return indices, indices0\",\n \"def generate_contours(edges, colorimg, img):\\n cv2.destroyAllWindows()\\n cv2.namedWindow(\\\"Contours\\\")\\n lengthlimit = 20\\n arealimit = 20\\n\\n # create trackbars for length and area filters\\n cv2.createTrackbar(\\\"length\\\", \\\"Contours\\\", 0, 200, nothing)\\n cv2.createTrackbar(\\\"area\\\", \\\"Contours\\\", 0, 2000, nothing)\\n\\n # find all possible contours in the image\\n ret, thresh = cv2.threshold(edges, 127, 255, 0)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\n while 1:\\n cv2.imshow(\\\"Contours\\\", colorimg)\\n\\n # filter based on area and length\\n lengthlimit = cv2.getTrackbarPos(\\\"length\\\", \\\"Contours\\\")\\n arealimit = cv2.getTrackbarPos(\\\"area\\\", \\\"Contours\\\")\\n\\n for idx, contour in enumerate(contours):\\n if len(contour) > lengthlimit:\\n area = cv2.contourArea(contour)\\n if area > arealimit:\\n isconvex = cv2.isContourConvex(contour)\\n circle = cv2.minEnclosingCircle(contour)\\n cv2.drawContours(colorimg, contours, idx, (0, 255, 0), 2)\\n else:\\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\\n else:\\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\\n\\n k = cv2.waitKey(1) & 0xFF\\n # print k\\n if k == 27:\\n exit()\\n if k == 32:\\n show_final(colorimg, contours, arealimit, lengthlimit)\",\n \"def getContours(frame):\\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def find_contour(ctx: Context):\\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\\n contours, _ = cv2.findContours(ctx.temp_image1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n\\n # take the 5 biggest areas\\n contours = sorted(contours, key=lambda c: math.fabs(cv2.contourArea(c)), reverse=True)[:5]\\n\\n # approximate contours with poly line\\n ctx.contours = [cv2.approxPolyDP(c, 2, True) for c in contours]\",\n \"def checkNeighbours(data):\\n features = 0\\n background = 0\\n neighbours = [data[0,0],data[0,1],data[0,2],data[1,2],data[2,2],data[2,1],data[2,0],data[1,0]]\\n fourConnected = False\\n lastPoint = neighbours[-1] #Needed for checking a complete transition cycle\\n for n in neighbours:\\n if not n:\\n features += 1\\n elif fourConnected:\\n background += 1\\n\\n fourConnected = not fourConnected\\n lastPoint = n\\n\\n for pos,corner in enumerate(corners):\\n if numpy.alltrue(data == corner):\\n cornerPos = pos+1\\n break\\n else:\\n cornerPos = 0\\n return (features,background,cornerPos)\",\n \"def boundary_contour(self, time):\\n ti = np.where(time == self.times)[0][0]\\n image_mask = binary_erosion(binary_fill_holes(binary_dilation(self.masks[ti])))\\n padded_mask = np.pad(image_mask, 1, 'constant', constant_values=0)\\n c_out = find_contours(padded_mask, level=0.5, fully_connected=\\\"high\\\")\\n x_cont = self.x[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\\n y_cont = self.y[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\\n ordered_coords = np.vstack([x_cont, y_cont])\\n return ordered_coords\",\n \"def opencv_watershed(masked, mask) -> JSON_TYPE:\\n # For code and detailed explanation see:\\n # http://datahacker.rs/007-opencv-projects-image-segmentation-with-watershed-algorithm/\\n threshold: int = 30\\n gray = cv2.cvtColor(masked, cv2.COLOR_RGB2GRAY)\\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\\n # Noise removal\\n kernel = np.ones((3), np.uint8)\\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\\n # Noise removal\\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\\n\\n n_increases: int = 0\\n while local_max_location.shape[0] < 30 and n_increases < 15:\\n threshold += 20\\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\\n # Noise removal\\n kernel = np.ones((3), np.uint8)\\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\\n # Noise removal\\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\\n n_increases += 1\\n # Reset threshold\\n threshold = 30\\n\\n num_clusters: int = 30\\n if n_increases >= 15:\\n num_clusters = local_max_location.shape[0]\\n kmeans = KMeans(n_clusters=num_clusters)\\n # If local_max_location size is 0, return 0 predictions\\n if not local_max_location.size:\\n return {\\n \\\"count\\\": 0\\n }\\n kmeans.fit(local_max_location)\\n local_max_location = kmeans.cluster_centers_.copy()\\n # Kmeans is returning a float data type so we need to convert it to an int. \\n local_max_location = local_max_location.astype(int)\\n dist_transform_copy = dist_transform.copy()\\n for i in range(local_max_location.shape[0]):\\n cv2.circle(dist_transform_copy, (local_max_location[i][1], local_max_location[i][0]), 5, 255)\\n # markers = np.zeros_like(dist_transform)\\n ret, sure = cv2.threshold(dist_transform, 0.01*dist_transform.max(), 255, 0)\\n sure = np.uint8(sure)\\n ret, markers = cv2.connectedComponents(sure)\\n labels = np.arange(kmeans.n_clusters)\\n markers[local_max_location[:,0], local_max_location[:,1]] = labels + 1\\n # Convert all local markers to an integer. This because cluster centers will be float numbers. \\n markers = markers.astype(int)\\n markers_copy = markers.copy()\\n index_non_zero_markers = np.argwhere(markers != 0)\\n markers_copy = markers_copy.astype(np.uint8)\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n for i in range(index_non_zero_markers.shape[0]):\\n string_text = str(markers[index_non_zero_markers[i][0], index_non_zero_markers[i][1]])\\n cv2.putText(markers_copy, string_text, (index_non_zero_markers[i][1], index_non_zero_markers[i][0]), font, 1, 255)\\n markers = markers.astype(np.int32)\\n segmented = cv2.watershed(masked, markers)\\n count_segments(markers)\\n #return {\\n # \\\"count\\\": local_max_location.shape[0]\\n #}\\n return {\\n \\\"count\\\": count_segments(markers),\\n }\",\n \"def get_neighbors(self, cell, count):\\n row, col = cell\\n # get all the neighbors\\n neighbors = set([(min(self.height - 1, max(row + i, 0)), min(self.width - 1, max(col + j, 0))) \\n for i in range(-1, 2)\\n for j in range(-1, 2)])\\n\\n for neighbor in deepcopy(neighbors):\\n if neighbor in self.safes or neighbor == cell:\\n neighbors.remove(neighbor)\\n elif neighbor in self.mines:\\n neighbors.remove(neighbor)\\n count -= 1\\n\\n return neighbors, count\",\n \"def get_nearest_neighbours(self, cell):\\n\\t\\tneighs = self.get_neighbours(cell)\\n\\t\\ti, j = cell.find_id()\\n\\t\\tneighbours = []\\n\\t\\tfor neigh in neighs:\\n\\t\\t\\tx, y = neigh.find_id()\\n\\t\\t\\tif abs(x-i)+abs(y-j) <= 1: \\n\\t\\t\\t\\tneighbours.append(self.space[y,x])\\n\\t\\treturn neighbours\",\n \"def get_background_pixels(img, rect):\\n mask = np.zeros(img.shape[:2], np.uint8)\\n bg_model = np.zeros((1,65), np.float64)\\n fg_model = np.zeros((1,65), np.float64)\\n cv2.grabCut(img, mask, rect, bg_model, fg_model, 5, cv2.GC_INIT_WITH_RECT)\\n flattened = mask.flatten()\\n background_coords = np.where((flattened == 0) | (flattened == 2))\\n return background_coords\",\n \"def cfdProcessElementTopology(self):\\r\\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \\r\\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\\r\\n\\r\\n ## (list of lists) list of face indices forming each element\\r\\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n #populates self.elementNeighbours\\r\\n for iFace in range(self.numberOfInteriorFaces):\\r\\n own=self.owners[iFace]\\r\\n nei=self.neighbours[iFace]\\r\\n \\r\\n #adds indices of neighbour cells\\r\\n self.elementNeighbours[own].append(nei)\\r\\n self.elementNeighbours[nei].append(own)\\r\\n \\r\\n #adds interior faces\\r\\n self.elementFaces[own].append(iFace)\\r\\n self.elementFaces[nei].append(iFace)\\r\\n \\r\\n #adds boundary faces ('patches')\\r\\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\\r\\n own=self.owners[iFace]\\r\\n self.elementFaces[own].append(iFace)\\r\\n \\r\\n ## List of lists containing points forming each element\\r\\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n \\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\\r\\n \\r\\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\\r\\n \\r\\n ## Upper coefficient indices (owners)\\r\\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n ## Lower coefficient indices (owners)\\r\\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n ## Element number from 1 to numberOfElements + 1\\r\\n iNb=1\\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n \\r\\n #skip if it is a boundary face\\r\\n if faceIndex > self.numberOfInteriorFaces-1:\\r\\n continue\\r\\n \\r\\n own = self.owners[faceIndex]\\r\\n nei = self.neighbours[faceIndex]\\r\\n \\r\\n if iElement == own:\\r\\n self.upperAnbCoeffIndex[faceIndex] = iNb\\r\\n elif iElement == nei:\\r\\n self.lowerAnbCoeffIndex[faceIndex] = iNb\\r\\n \\r\\n iNb = iNb +1\",\n \"def detect_lanes(binary_warped):\\n histogram = np.sum(binary_warped[(binary_warped.shape[0] // 2):, :], axis=0)\\n out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255\\n\\n midpoint = np.int(histogram.shape[0] / 2)\\n leftx_base = np.argmax(histogram[:midpoint])\\n rightx_base = np.argmax(histogram[midpoint:]) + midpoint\\n\\n nwindows = 9\\n\\n window_height = np.int(binary_warped.shape[0] / nwindows)\\n\\n nonzero = binary_warped.nonzero()\\n nonzeroy = np.array(nonzero[0])\\n nonzerox = np.array(nonzero[1])\\n\\n # Current positions to be updated for each window\\n leftx_current = leftx_base\\n rightx_current = rightx_base\\n\\n # Set the width of the windows +/- margin\\n margin = 100\\n\\n # Set minimum number of pixels found to recenter window\\n minpix = 50\\n\\n # Create empty lists to receive left and right lane pixel indices\\n left_lane_inds = []\\n right_lane_inds = []\\n\\n # Step through the windows one by one\\n for window in range(nwindows):\\n # Identify window boundaries in x and y (and right and left)\\n win_y_low = binary_warped.shape[0] - (window + 1) * window_height\\n win_y_high = binary_warped.shape[0] - window * window_height\\n win_xleft_low = leftx_current - margin\\n win_xleft_high = leftx_current + margin\\n win_xright_low = rightx_current - margin\\n win_xright_high = rightx_current + margin\\n\\n # Draw the windows on the visualization image\\n cv2.rectangle(out_img, (win_xleft_low, win_y_low), (win_xleft_high, win_y_high), (0, 255, 0), 2)\\n cv2.rectangle(out_img, (win_xright_low, win_y_low), (win_xright_high, win_y_high), (0, 255, 0), 2)\\n\\n # Identify the nonzero pixels in x and y within the window\\n good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xleft_low) &\\n (nonzerox < win_xleft_high)).nonzero()[0]\\n good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xright_low) &\\n (nonzerox < win_xright_high)).nonzero()[0]\\n\\n # Append these indices to the lists\\n left_lane_inds.append(good_left_inds)\\n right_lane_inds.append(good_right_inds)\\n\\n # If you found > minpix pixels, recenter next window on their mean position\\n if len(good_left_inds) > minpix:\\n leftx_current = np.int(np.mean(nonzerox[good_left_inds]))\\n if len(good_right_inds) > minpix:\\n rightx_current = np.int(np.mean(nonzerox[good_right_inds]))\\n\\n # Concatenate the arrays of indices\\n left_lane_inds = np.concatenate(left_lane_inds)\\n right_lane_inds = np.concatenate(right_lane_inds)\\n\\n # 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 # Visualize\\n ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.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\\n return Lane(left_fit, right_fit, left_fitx, right_fitx, leftx, rightx, lefty, righty), out_img\",\n \"def cellNeighbours((cell_x,cell_y)):\\n dict = {}\\n dict[\\\"neighbour_up\\\"] = (cell_x, cell_y - CELL_HEIGHT)\\n dict[\\\"neighbour_down\\\"] = (cell_x, cell_y + CELL_HEIGHT)\\n dict[\\\"neighbour_left\\\"] = (cell_x - CELL_WIDTH, cell_y)\\n dict[\\\"neighbour_right\\\"] = (cell_x + CELL_WIDTH, cell_y)\\n dict[\\\"neighbour_up_left\\\"] = (cell_x - CELL_WIDTH, cell_y - CELL_HEIGHT)\\n dict[\\\"neighbour_up_right\\\"] = (cell_x + CELL_WIDTH, cell_y - CELL_HEIGHT)\\n dict[\\\"neighbour_down_left\\\"] = (cell_x - CELL_WIDTH, cell_y + CELL_HEIGHT)\\n dict[\\\"neighbour_down_right\\\"] = (cell_x + CELL_WIDTH, cell_y + CELL_HEIGHT)\\n keys_to_delete = []\\n for key,value in dict.iteritems():\\n if not inWindow(value):\\n keys_to_delete.append(key)\\n for key in keys_to_delete:\\n del dict[key]\\n return dict\",\n \"def getContours(image, copyImage):\\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n for contour in contours:\\n area = cv.contourArea(contour)\\n \\n if area > 500.0:\\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\\n perimeter = cv.arcLength(contour, True)\\n \\n # Approximates to the nearest polygon\\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\\n objectCoordinates = len(approx)\\n\\n # Returns the x, y and height width of the polygon\\n x, y, w, h = cv.boundingRect(approx)\\n\\n if objectCoordinates == 3:\\n objectShape = \\\"Triangle\\\"\\n elif objectCoordinates == 4:\\n ratio = w / float(h)\\n if ratio >= 0.95 and ratio <= 1.05:\\n objectShape = \\\"Square\\\"\\n else: objectShape = \\\"Rectangle\\\"\\n else: objectShape = \\\"Circle\\\" \\n\\n \\n\\n # Draw rectangles around the images\\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))\",\n \"def findCluster(path, bound_img_path):\\r\\n image = cv2.imread(path, cv2.IMREAD_COLOR)\\r\\n img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\r\\n blur = cv2.medianBlur(img, 3)\\r\\n thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]\\r\\n\\r\\n # Creating a structuring element to perform morphological operations\\r\\n k_size = (3, 3)\\r\\n kernelMorph = cv2.getStructuringElement(cv2.MORPH_RECT, k_size)\\r\\n\\r\\n # Performing opening on the image\\r\\n morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernelMorph, iterations=1)\\r\\n\\r\\n # Performing dilation on the image\\r\\n ksizeKernelDilate = (50, 1)\\r\\n dilated = cv2.dilate(morph, ksizeKernelDilate, iterations= 5)\\r\\n\\r\\n # Identifying contours in the image\\r\\n cnts = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n cnts = cnts[0] if len(cnts) == 2 else cnts[1]\\r\\n clr1, clr2, clr3 = 225, 255, 0,\\r\\n b = 10\\r\\n\\r\\n bounding_box_created = False\\r\\n if len(cnts) != 0:\\r\\n contour_rect_box = []\\r\\n conimage = []\\r\\n for c in cnts:\\r\\n # Identifying bounding box dimensions for each contour\\r\\n x, y, w, h = cv2.boundingRect(c)\\r\\n # Enclosing the contours in a rectangle\\r\\n if (w > 10 and h > 10 and w < img.shape[0] and h < img.shape[1]):\\r\\n conimage = cv2.rectangle(image, (x - b, y - b), (x - b + w + 2 * b, y - b + h + 2 * b),\\r\\n (clr1, clr2, clr3), -1)\\r\\n contour_rect_box.append((x, y, x + w, y + h, w, h))\\r\\n\\r\\n # Check whether the bounding box is created or not\\r\\n # If bounding box is created, then update the image with the identified bounding box,\\r\\n # Else print no clusters have been identified\\r\\n if len(conimage) > 0:\\r\\n cv2.imwrite(bound_img_path, conimage)\\r\\n bounding_box_created = True\\r\\n else:\\r\\n print(\\\"No clusters identified\\\")\\r\\n return cnts, bounding_box_created\",\n \"def compute_contour(ptr_array):\\n hull = ConvexHull(ptr_array)\\n contour_index = hull.vertices.tolist() # indices are ordered\\n # contour_index = hull.simplices.flatten()\\n # contour_index = list(set(contour_index))\\n return contour_index\",\n \"def get_neighbor_values(training_image, row, col):\\n #patches.append((img[i-1:i+2,j-1:j+2],(i,j)))\\n return training_image[row-1:row+2,col-1:col+2]\",\n \"def get_contours(img):\\n contours, hierarchy = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours, hierarchy[0]\",\n \"def calcAllIntensities(self, xc, yc):\\n\\n tp = 0.0\\n ix = 0\\n iy = 0\\n h = 0\\n ints = np.zeros([5, 5])\\n ints_inner = np.zeros([5, 5])\\n # ints = [[0.0] * 5] * 5\\n # ints_inner = [[0.0] * 5] * 5\\n x = 0.0\\n y = 0.0\\n xc1 = 0.0\\n yc1 = 0.0\\n xc1 = xc\\n yc1 = yc\\n \\n for h in np.arange(1,5,1):\\n for k in np.arange(1,5,1):\\n ints[h][k] = 0.0\\n ints_inner[h][k] = 0.0\\n\\n for k in np.arange(0, 2, 1):\\n for h in np.arange(0, 2, 1):\\n for ix in np.arange(0, self.stepp + 1, 1):\\n for iy in np.arange(0, self.stepp + 1, 1):\\n #print(k, h, ix, iy)\\n if self.qc_format == 0 :\\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\\n tp = math.pow(tp,2)\\n #print(tp)\\n elif self.qc_format == 1 :\\n x = -1 + h + (ix * (1 / self.stepp))\\n y = -1 + k + (iy * (1 / self.stepp))\\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\\n\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\\n ints_inner[h + 1][k + 1] += tp\\n else :\\n if self.qc_format == 1 :\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\\n ints[h + 1][k + 1] += tp\\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\\n #print(math.pow(x,2) + math.pow(y,2))\\n ints[h + 1][k + 1] += tp\\n # print(ints[h + 1][k + 1])\\t\\t\\t\\t\\t\\t\\n tp = 0.0\\n\\n # print(ints)\\n\\n Aq = 0.0\\n Bq = 0.0\\n Cq = 0.0\\n Dq = 0.0\\n Ac_inner = 0.0\\n Bc_inner = 0.0\\n Cc_inner = 0.0\\n Dc_inner = 0.0\\n Ac = 0.0\\n Bc = 0.0\\n Cc = 0.0\\n Dc = 0.0\\n Ac = ints[1][2]\\n Bc = ints[2][2]\\n Cc = ints[2][1]\\n Dc = ints[1][1]\\n\\n Ac_inner = ints_inner[1][2]\\n Bc_inner = ints_inner[2][2]\\n Cc_inner = ints_inner[2][1]\\n Dc_inner = ints_inner[1][1]\\n Ac *= self.QE\\n Bc *= self.QE\\n Cc *= self.QE\\n Dc *= self.QE\\n\\n Ac_inner *= self.QE_inner\\n Bc_inner *= self.QE_inner\\n Cc_inner *= self.QE_inner\\n Dc_inner *= self.QE_inner\\n Ac += Ac_inner\\n Bc += Bc_inner\\n Cc += Cc_inner\\n Dc += Dc_inner\\n\\n Aq = Ac\\n Bq = Bc\\n Cq = Cc\\n Dq = Dc\\n\\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\\n if self.smooth == 0 :\\n if (Config.hplk_c0_e * self.TP) == 0 :\\n cnst = 0\\n else :\\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\\n if Config.flag_spice == 1 :\\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\\n #Bc *= 1 / (self.lamb * 1e6);\\n #Cc *= 1 / (self.lamb * 1e6);\\n #Dc *= 1 / (self.lamb * 1e6);\\n \\n ############################## DOUBLE CHECK ##############################\\n # self.grava_arquivos = 1\\n # self.flag_V_QC = 0\\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\\n # self.flag_V_QC = 1\\n # self.grava_arquivos = 0\\n ############################## DOUBLE CHECK ##############################\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n else :\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n\\n # 'returns' all the intensities\\n self.A_intensity = Aq\\n self.B_intensity = Bq\\n self.C_intensity = Cq\\n self.D_intensity = Dq\",\n \"def generate_contours(threshold):\\n \\tcnts = cv2.findContours(threshold.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n \\tcnts = imutils.grab_contours(cnts)\\n \\treturn cnts\",\n \"def Predict_Image_Contours(img, mask_full, feature_dict, filename = None, path = ''):\\n for ii in range(len(feature_dict)):\\n Type = feature_dict[str(ii)] ## So first key is 1\\n if Type=='modern_build':\\n color_rgb = (255,0,0)\\n elif Type=='trad_build':\\n color_rgb = (0,0,255)\\n mask = mask_full[:,:,ii]\\n mask = 255*mask.round().astype('uint8')\\n mask = np.stack((mask,mask, mask),-1)\\n mask = cv2.cvtColor(mask, cv2.COLOR_RGB2GRAY);\\n ret, thresh = cv2.threshold(mask, 127.5, 255, cv2.THRESH_BINARY)\\n\\n contours,hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n ##print('here')\\n area_thresh =30 ## Depends on what the minimal building size desired is\\n for cnt in contours:\\n ## Contours, flag of whether curve is closed or not\\n epsilon = 0.025*cv2.arcLength(cnt,True)\\n ## Contours, epsilon for wiggliness, closed shape or not\\n approx = cv2.approxPolyDP(cnt,epsilon,True)\\n ## Extract Area Dest image, contours, contour index\\n area = cv2.contourArea(approx)\\n ## centroid computed from moments\\n M = cv2.moments(cnt) \\n if area > area_thresh:\\n if Type=='modern_build':\\n rect = cv2.minAreaRect(cnt)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n img = cv2.drawContours(image = img, contours = [box], \\n contourIdx = 0, color = color_rgb, \\n thickness = 2)\\n elif Type=='trad_build':\\n (x,y),radius = cv2.minEnclosingCircle(cnt)\\n center = (int(x),int(y))\\n radius = int(radius)\\n img = cv2.circle(img,center,radius,color_rgb,2)\\n elif Type=='Forest':\\n img = cv2.drawContours(image = img, contours = [cnt], \\n contourIdx = 0, color = color_rgb, \\n thickness = 2)\\n elif Type=='Bare':\\n img = cv2.drawContours(image = img, contours = [cnt], \\n contourIdx = 0, color = color_rgb, \\n thickness = 2)\\n if filename is not None:\\n try: \\n if path == '':\\n path = 'Predictions'\\n os.makedirs(path)\\n except OSError as error: \\n print('') \\n fig, ax = plt.subplots(figsize=(18, 20))\\n ax.imshow(img[:,:,0:3])\\n plt.tight_layout()\\n plt.savefig(path + '/' + filename, bbox_inches='tight') \\n plt.close(fig)\\n \\n return img\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.682303","0.62864244","0.6280185","0.60297304","0.59573025","0.5944612","0.58334446","0.57923675","0.5783148","0.5739409","0.56378686","0.55968744","0.5590528","0.55639815","0.5518648","0.54740554","0.5468312","0.5427046","0.5407643","0.5381385","0.5379665","0.53704494","0.53400975","0.5336719","0.53292334","0.53093916","0.5309197","0.52757114","0.5274474","0.52711254","0.5267839","0.52655166","0.52650124","0.5260855","0.52528334","0.5248755","0.5240066","0.5229563","0.52275604","0.5227041","0.52268803","0.5226063","0.5223253","0.52232265","0.5202643","0.51847076","0.51731455","0.51669806","0.5162194","0.5155976","0.5154365","0.51499087","0.5148446","0.5144572","0.51418287","0.51398176","0.5136569","0.51332474","0.51269865","0.5120664","0.51188946","0.5116543","0.51086694","0.5096882","0.50948346","0.50926626","0.50900334","0.5087406","0.5083241","0.50785947","0.5075275","0.5074964","0.5072246","0.5071827","0.5060396","0.5049368","0.5049084","0.50444925","0.50441283","0.5034677","0.50307715","0.50288427","0.5027822","0.5025547","0.5017384","0.5006742","0.49849248","0.49828795","0.49801868","0.49791858","0.4975158","0.49590746","0.49533653","0.49495253","0.49471912","0.49435532","0.49433345","0.49413845","0.4934361","0.4931988"],"string":"[\n \"0.682303\",\n \"0.62864244\",\n \"0.6280185\",\n \"0.60297304\",\n \"0.59573025\",\n \"0.5944612\",\n \"0.58334446\",\n \"0.57923675\",\n \"0.5783148\",\n \"0.5739409\",\n \"0.56378686\",\n \"0.55968744\",\n \"0.5590528\",\n \"0.55639815\",\n \"0.5518648\",\n \"0.54740554\",\n \"0.5468312\",\n \"0.5427046\",\n \"0.5407643\",\n \"0.5381385\",\n \"0.5379665\",\n \"0.53704494\",\n \"0.53400975\",\n \"0.5336719\",\n \"0.53292334\",\n \"0.53093916\",\n \"0.5309197\",\n \"0.52757114\",\n \"0.5274474\",\n \"0.52711254\",\n \"0.5267839\",\n \"0.52655166\",\n \"0.52650124\",\n \"0.5260855\",\n \"0.52528334\",\n \"0.5248755\",\n \"0.5240066\",\n \"0.5229563\",\n \"0.52275604\",\n \"0.5227041\",\n \"0.52268803\",\n \"0.5226063\",\n \"0.5223253\",\n \"0.52232265\",\n \"0.5202643\",\n \"0.51847076\",\n \"0.51731455\",\n \"0.51669806\",\n \"0.5162194\",\n \"0.5155976\",\n \"0.5154365\",\n \"0.51499087\",\n \"0.5148446\",\n \"0.5144572\",\n \"0.51418287\",\n \"0.51398176\",\n \"0.5136569\",\n \"0.51332474\",\n \"0.51269865\",\n \"0.5120664\",\n \"0.51188946\",\n \"0.5116543\",\n \"0.51086694\",\n \"0.5096882\",\n \"0.50948346\",\n \"0.50926626\",\n \"0.50900334\",\n \"0.5087406\",\n \"0.5083241\",\n \"0.50785947\",\n \"0.5075275\",\n \"0.5074964\",\n \"0.5072246\",\n \"0.5071827\",\n \"0.5060396\",\n \"0.5049368\",\n \"0.5049084\",\n \"0.50444925\",\n \"0.50441283\",\n \"0.5034677\",\n \"0.50307715\",\n \"0.50288427\",\n \"0.5027822\",\n \"0.5025547\",\n \"0.5017384\",\n \"0.5006742\",\n \"0.49849248\",\n \"0.49828795\",\n \"0.49801868\",\n \"0.49791858\",\n \"0.4975158\",\n \"0.49590746\",\n \"0.49533653\",\n \"0.49495253\",\n \"0.49471912\",\n \"0.49435532\",\n \"0.49433345\",\n \"0.49413845\",\n \"0.4934361\",\n \"0.4931988\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6968971"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93475,"cells":{"query":{"kind":"string","value":"Identify every contour in the watershed segmentation for each frame as defined by each pair of cell IDs (vals). Also, return the order of contours that is needed to reconstruct the border surrounding each cell. DEPRECATED, use GetSubContoursAndOrderingByFrame instead!"},"document":{"kind":"string","value":"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break"},"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 GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\n orderOfSCsByValueByFrame = [\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\n ]\n return scListByFrame, orderOfSCsByValueByFrame","def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def getContours(img,iteration):\n nP, IDrange = upDate(iteration)\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\n kernel = np.ones((nP, nP), np.uint8)\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\n contours = []\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n if iteration == 2 :\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n elif iteration == 3:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n else:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n return contours","def get_contour_features(mask,selectcell=\"centered\"):\r\n \r\n #binarize image (everything above 0 becomes 1)\r\n mask = np.clip(mask,a_min=0,a_max=1)\r\n\r\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\r\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\r\n contours = list(contours)\r\n \r\n #in case there is no contour found, add a dummy contour\r\n if len(contours)==0:\r\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\r\n\r\n #Sort contours, longest first\r\n contours.sort(key=len,reverse=True)\r\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\r\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\r\n\r\n mu_origs = [cv2.moments(contour) for contour in contours]\r\n mu_hulls = [cv2.moments(hull) for hull in hulls]\r\n\r\n area_origs = [mu_orig[\"m00\"] for mu_orig in mu_origs]\r\n area_hulls = [mu_hull[\"m00\"] for mu_hull in mu_hulls]\r\n\r\n #drop events where area is zero\r\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \r\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\r\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\r\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\r\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\r\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\r\n \r\n \r\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\r\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\r\n\r\n \r\n if selectcell == \"smooth\":\r\n #compute the area ratio (roughness of contour)\r\n area_ratio = np.array(area_hulls)/np.array(area_origs)\r\n #get the contour with minimum roughness (smooth contour)\r\n sorter = np.argsort(area_ratio) #smallest first\r\n\r\n if selectcell == \"centered\":\r\n #select contour that is closest to the center of the image. \r\n #In iPAC, cells are usually in the center.\r\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\r\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\r\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\r\n sorter = np.argsort(distances) #smallest first\r\n \r\n #sort values with respect to chosen metric (area_ratio or distance)\r\n contours = [contours[s] for s in sorter]\r\n hulls = [hulls[s] for s in sorter]\r\n pos_x = [pos_x[s] for s in sorter]\r\n pos_y = [pos_y[s] for s in sorter]\r\n mu_origs = [mu_origs[s] for s in sorter]\r\n area_origs = [area_origs[s] for s in sorter]\r\n area_hulls = [area_hulls[s] for s in sorter]\r\n \r\n # draw mask of the chosen contour\r\n mask = np.zeros_like(mask)\r\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\r\n\r\n hull = hulls[0]#[0:n_contours]\r\n pos_x = pos_x[0]\r\n pos_y = pos_y[0] \r\n mu_orig = mu_origs[0]#[0:n_contours]\r\n area_orig = area_origs[0]#[0:n_contours]\r\n area_hull = area_hulls[0]#[0:n_contours]\r\n \r\n if area_orig>0:\r\n area_ratio = area_hull/area_orig\r\n else:\r\n area_ratio = np.nan\r\n\r\n arc = cv2.arcLength(hull, True) \r\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\"m00\"]) / arc\r\n\r\n\r\n dic = {\"mask\":mask,\"pos_x\":pos_x,\"pos_y\":pos_y,\"area_orig\":area_orig,\"area_hull\":area_hull,\\\r\n \"area_ratio\":area_ratio,\"circularity\":circularity}\r\n return dic","def trackCells(self): \n # variable initialization\n self.t_appearance = []\n self.id_seq = []\n self._n_cell = 0\n self.division = []\n self.dict_track = {}\n\n t_ini = self.configs[self.TIME_INI_KEY]\n\n # Initialize points with first frame\n self.dict_track[0] = {}\n for id_num in self.pos[0][4]:\n self._addTrack(0, id_num)\n\n # From frame=1 on...\n for t, data_t in enumerate(self.pos[1:]):\n self.dict_track[t+1] = {}\n # check all the cells in this frame\n for cell, id_num in enumerate(data_t[4]):\n parent = data_t[5][cell]\n if parent == -1:\n # new track\n self._addTrack(t+1, id_num)\n elif parent in self.dict_track[t]:\n # check if parent is in the previous list\n index = self.dict_track[t][parent]\n if index in self.dict_track[t+1].values():\n # then we have cell division, and we monitor the child separarely\n self._addDivision(t+1, id_num, index)\n else:\n # cell continues in the same track\n self.id_seq[index].append(id_num)\n self.dict_track[t+1][id_num] = index\n else:\n # weird things happened!\n print(\"Warning! Time %s, Cell ID %s lost track\"%(str(t+t_ini), str(id_num)))\n\n\n # all track indexes are included, no filter (yet)\n self.index_filter = list(range(len(self.id_seq)))\n\n return self.id_seq, self.t_appearance","def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\n return [\n [sc.cVLS() for sc in scList]\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\n ]","def find_original_contours(self):\r\n\r\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\r\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\r\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\r\n int(self.cell_size), 5)\r\n self.thresh_orig = 255 - self.thresh_invert\r\n\r\n # Find the contours of the image. Each contour should correspond to a cell\r\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\r\n for block in orig_contours:\r\n area = cv2.contourArea(block)\r\n\r\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\r\n if area < self.min_cell_size:\r\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)","def take_contours(self):\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]","def sort_filtered_contours(self):\r\n\r\n # Get the contours again\r\n invert = 255 - self.thresh_invert\r\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\r\n\r\n # Make sure that they're within the correct range for size\r\n # If too small, it is probably noise; if too large, then should be things around the grid\r\n for i, c in enumerate(real_contours, 1):\r\n contour_area = cv2.contourArea(c)\r\n if self.min_cell_size < contour_area < self.max_cell_size:\r\n self.good_contours.append(c)\r\n\r\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\r\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\r\n\r\n # Sort the contours from top to bottom\r\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\"top-to-bottom\")\r\n\r\n # We then sort each row from left to right\r\n row = []\r\n for i, c in enumerate(half_sorted_contours, 1):\r\n row.append(c)\r\n if i % self.board_dimension == 0:\r\n (full_sorted_contours, _) = contours.sort_contours(row, method=\"left-to-right\")\r\n self.game_board_contours.append(full_sorted_contours)\r\n row = []","def instance_contours(gti):\n # TODO: move to somewhere better\n import cv2\n\n rc_locs = np.where(gti > 0)\n grouped_cc_rcs = util.group_items(\n np.ascontiguousarray(np.vstack(rc_locs).T),\n gti[rc_locs], axis=0\n )\n\n def bounding_box(rcs):\n rc1 = rcs.min(axis=0)\n rc2 = rcs.max(axis=0)\n return rc1, rc2\n\n # slice out a bounding region around each instance, detect the contour and\n # then offset it back into image coordinates\n grouped_contours = {}\n for label, rcs in grouped_cc_rcs.items():\n rc1, rc2 = bounding_box(rcs)\n sl = (slice(rc1[0], rc2[0] + 2), slice(rc1[1], rc2[1] + 2))\n submask = (gti[sl] == label).astype(np.uint8)\n\n xy_offset = rc1[::-1]\n offset = xy_offset + [-2, -2]\n\n border = cv2.copyMakeBorder(submask, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=0 )\n _, contors, hierarchy = cv2.findContours(border, cv2.RETR_TREE,\n cv2.CHAIN_APPROX_SIMPLE,\n offset=tuple(offset))\n \"\"\"\n offset = [0, 0]\n BGR_GREEN = (0, 255, 0)\n x = np.ascontiguousarray(util.ensure_alpha_channel(submask)[:, :, 0:3]).astype(np.uint8)\n draw_img = cv2.drawContours(\n image=x, contours=contors,\n contourIdx=-1, color=BGR_GREEN, thickness=2)\n \"\"\"\n # note when len(contours > 1, there is a hole in the building)\n # assert len(contors) == 1\n grouped_contours[label] = contors\n return grouped_contours","def get_contours(self):\n depth_image = capture_images((self.w,self.h))\n\n thresh = threshold_depth_image(depth_image, min_depth=config.min_depth, max_depth=config.max_depth, threshold=config.min_depth, kernel=self.kernel)\n\n # extract contours\n im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\n if hierarchy!=None:\n hierarchy = hierarchy[0]\n return contours, hierarchy\n else:\n return [], []","def detect_contours(self):\r\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\r\n return [DbugContour(cv_contour=contour) for contour in contours]","def nondetects(self, masked=False):\r\n grd = self.grd\r\n xnd = []\r\n ynd = []\r\n ncells = len(grd.cells['depth'])\r\n non_detects_i_tr = np.zeros(ncells, np.int32)\r\n if masked:\r\n not_flagged = np.where(self.rec_track.flagged==0)[0]\r\n rec_track = self.rec_track[not_flagged]\r\n rec_seg = self.make_segments(set_depth=True, \r\n input_rec_track=rec_track)\r\n else:\r\n rec_seg = self.rec_seg\r\n for nr, rseg in enumerate(rec_seg):\r\n seg = rec_seg[nr]\r\n dt = seg.dt\r\n if dt > dt_signal+1:\r\n t1 = seg.t1\r\n t2 = seg.t2\r\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\r\n x1 = seg.x1\r\n x2 = seg.x2\r\n y1 = seg.y1\r\n y2 = seg.y2\r\n dx_nd = (x2 - x1)/float(nint+1)\r\n dy_nd = (y2 - y1)/float(nint+1)\r\n if nint < 120: # 10 minute cutoff for nondetect filling\r\n xint = [x1 + n*dx_nd for n in range(1,nint)]\r\n yint = [y1 + n*dy_nd for n in range(1,nint)]\r\n xnd = xnd + xint\r\n ynd = ynd + yint\r\n\r\n for nd in range(len(xnd)):\r\n xy = [xnd[nd], ynd[nd]]\r\n i = grd.select_cells_nearest(xy)\r\n if (i is not None) and (i >= 0):\r\n non_detects_i_tr[i] += 1\r\n\r\n return non_detects_i_tr","def getMostContour(img,svm,knn,filterArr,digits,wThresh,hThresh):\r\n # append the filter to filter array, this approach is used in case of \r\n # multiple filter methods would be used.\r\n counts = []\r\n # iterare through every filter\r\n for flt in filterArr:\r\n # copy the image so we don't draw on same image\r\n flt_img = img.copy()\r\n last_img = img.copy()\r\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh) \r\n if not digits:\r\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh)\r\n flt_contour_map = []\r\n labels = []\r\n for crop,(x,y,w,h),contour in cropNwriteBBs(img,cntfound_fltr):\r\n #crop = np.array(crop,dtype='float32')\r\n crop = cv2.cvtColor(crop,cv2.COLOR_BGR2GRAY)\r\n crop = cv2.resize(crop,(25,25))\r\n # winSize is the size of the image cropped to an multiple of the cell size\r\n hog_fts = hog.compute(crop)\\\r\n .reshape(n_cells[1] - block_size[1] + 1,\r\n n_cells[0] - block_size[0] + 1,\r\n block_size[0], block_size[1], nbins) \\\r\n .transpose((1, 0, 2, 3, 4))\r\n hog_fts = np.resize(hog_fts.flatten(),(1,576))\r\n # make the resulted crop same type with the trained values\r\n hog_fts.dtype = 'float32'\r\n # get predicted labels\r\n label_svm=svm.predict(hog_fts)[1]\r\n label_knn = knn.findNearest(hog_fts,k=5)[1]\r\n # label 10 is considered as 'not digit' or 'thrash'\r\n # so if predicted label is not 10, draw the bounding box\r\n if digits:\r\n if(label_svm!=10 and label_knn != 10 and label_svm!=11 and label_knn != 11):\r\n flt_contour_map.append(contour)\r\n labels.append(str(label_knn[0])[1])\r\n else:\r\n if(label_svm!=2 and label_knn != 2):\r\n flt_contour_map.append(contour)\r\n labels.append(str(label_knn[0])[1])\r\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\r\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\r\n last_cnt,last_labels = secondElimination(flt_contour_map,labels)\r\n for cnt in last_cnt:\r\n x,y,w,h = cv2.boundingRect(cnt)\r\n cv2.rectangle(flt_img,(x,y),(x+w,y+h),[0,255,0],2)\r\n #showWait(flt_img,'fltres')\r\n _,xx,res_boxes,_,_ = mergeBoundingBoxes(flt_img,last_cnt,last_labels)\r\n cnt = len(res_boxes)\r\n counts.append([cnt,flt_img,last_cnt,last_labels])\r\n # append resulted image and contours to an array\r\n counts = np.asarray(counts)\r\n # get the resulted image which contain more digits (bounding boxes)\r\n tmp = counts[:,0]\r\n resulted_img = counts[np.argmax(tmp),1]\r\n result_labels = counts[np.argmax(tmp),3]\r\n resulted_contour = counts[np.argmax(tmp),2]\r\n return resulted_contour,result_labels,resulted_img","def getContours(frame):\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def preprocessing(self, img):\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def get_connected_components(img):\n already_labeled = []\n connected_components = []\n pixel_queue = []\n\n def get_fg_neighbors(row,col):\n neighbors = []\n min_row = max(row-1,0)\n max_row = min(row+1, len(img)-1)\n min_col = max(col-1,0)\n max_col = min(col+1, len(img[0])-1)\n for r in xrange(min_row, max_row+1):\n for c in xrange(min_col, max_col+1):\n if img[r][c] == 1 and (r,c) not in already_labeled:\n neighbors.append((r,c))\n return neighbors\n\n for row in xrange(len(img)):\n for col in xrange(len(img[0])):\n if img[row][col] == 1 and (row,col) not in already_labeled:\n already_labeled.append((row,col))\n cc = []\n cc.append((row,col))\n pixel_queue.append((row,col))\n while len(pixel_queue) > 0:\n cur_pixel = pixel_queue[0]\n pixel_queue = pixel_queue[1:]\n neighbors = get_fg_neighbors(cur_pixel[0], cur_pixel[1])\n already_labeled += neighbors\n cc += neighbors\n pixel_queue += neighbors\n connected_components.append(cc)\n return connected_components","def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\n\n device += 1\n\n if len(np.shape(img)) == 3:\n iy, ix, iz = np.shape(img)\n else:\n iy, ix, = np.shape(img)\n\n # get the break groups\n\n if nrow == 1:\n rbreaks = [0, iy]\n else:\n rstep = np.rint(iy / nrow)\n rstep1 = np.int(rstep)\n rbreaks = range(0, iy, rstep1)\n if ncol == 1:\n cbreaks = [0, ix]\n else:\n cstep = np.rint(ix / ncol)\n cstep1 = np.int(cstep)\n cbreaks = range(0, ix, cstep1)\n\n # categorize what bin the center of mass of each contour\n\n def digitize(a, step):\n if isinstance(step, int) == True:\n i = step\n else:\n i = len(step)\n for x in range(0, i):\n if x == 0:\n if a >= 0 and a < step[x + 1]:\n return x + 1\n elif a >= step[x - 1] and a < step[x]:\n return x\n elif a > step[x - 1] and a > np.max(step):\n return i\n\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\n coord = []\n for i in range(0, len(roi_objects)):\n m = cv2.moments(roi_objects[i])\n if m['m00'] == 0:\n pass\n else:\n cx = int(m['m10'] / m['m00'])\n cy = int(m['m01'] / m['m00'])\n # colbin = np.digitize(cx, cbreaks)\n # rowbin = np.digitize(cy, rbreaks)\n colbin = digitize(cx, cbreaks)\n rowbin = digitize(cy, rbreaks)\n a = (cx, cy, colbin, rowbin, i)\n coord.append(a)\n coord1 = np.array(coord, dtype=dtype)\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\n\n # get the list of unique coordinates and group the contours with the same bin coordinates\n\n groups = []\n for i, y in enumerate(coord2):\n col = y[3]\n row = y[2]\n location = str(row) + ',' + str(col)\n groups.append(location)\n\n unigroup = np.unique(groups)\n coordgroups = []\n\n for i, y in enumerate(unigroup):\n col = int(y[0])\n row = int(y[2])\n for a, b in enumerate(coord2):\n if b[2] == col and b[3] == row:\n grp = i\n contour = b[4]\n coordgroups.append((grp, contour))\n else:\n pass\n\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\n\n contours = roi_objects\n grouped_contour_indexes = coordlist\n\n # Debug image is rainbow printed contours\n\n if debug == 'print':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n print_image(img_copy, (str(device) + '_clusters.png'))\n\n elif debug == 'plot':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n plot_image(img_copy)\n\n return device, grouped_contour_indexes, contours","def contextualcull(cnts):\n temp = []\n actualout = []\n indicesused = []\n for cnt in cnts:\n if cnt.area > CULL_MINIMUMS[cnt.spatialindex]:\n temp.append(cnt)\n if cnt.spatialindex not in indicesused:\n indicesused.append(cnt.spatialindex)\n if PRIORITIZE_FASTEST:\n for sindex in indicesused: #filter down to the fastest contour.\n _allatthisindex = [x for x in temp if x == sindex]\n highest = _allatthisindex.sort(key=lambda y: y.spd, reverse=False)[0]\n actualout.append(highest)\n else:\n actualout = temp\n print 'Contours after cull: ', len(actualout)\n return actualout","def get_winning_discs(self):\r\n for i in range(6):\r\n for j in range(7):\r\n if self.board[i][j] == 'O':\r\n continue\r\n if self.is_horizontal_four(i, j):\r\n return [(i, x) for x in range(j, j + 4)]\r\n if self.is_vertical_four(i, j):\r\n return [(x, j) for x in range(i, i - 4, -1)]\r\n if self.is_neg_diagonal_four(i, j):\r\n return [(x, y) for x, y in zip(\r\n range(i, i + 4), range(j, j - 4, -1))]\r\n if self.is_pos_diagonal_four(i, j):\r\n return [(x, y)\r\n for x, y in zip(range(i, i + 4), range(j, j + 4))]","def draw_contours(self, image, maskImg):\r\n # Required variables..\r\n x, y, width, height = 0, 0, 0, 0\r\n # Find contours..\r\n contours, hierarchy = cv2.findContours(image=maskImg, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) # Playable Parameters..\r\n # Draw the contours..\r\n for contour in contours:\r\n # Calculate the area of the contour, so can remove unnecessary contours..\r\n area = cv2.contourArea(contour=contour)\r\n if area > 3000: # Playable adjustment..!! Found Good as 3000 for current light condition.. change this if light condition changes..\r\n # Draw the contours to the image -- actual frame..\r\n if self.debug_mode:\r\n cv2.drawContours(image=image, contours=contour, contourIdx=-1, color=(255, 255, 0), thickness=4)\r\n # Find the perimeter of the markers detected...\r\n perimeter = cv2.arcLength(curve=contour, closed=True)\r\n # Approximating/Finding the corners of the image from the obtained corners..\r\n approx_corners = cv2.approxPolyDP(curve=contour, epsilon=0.02 * perimeter, closed=True)\r\n # Find the bounding box rectangle for the approximated corners..\r\n x, y, width, height = cv2.boundingRect(approx_corners)\r\n # Return the values with which a rectangle can be drawn..\r\n return x, y, width, height","def findContours(img, thresh=127, val=255):\n\tgray = grayscale(img)\n\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\n\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\terrorCheckContour(contours)\n\treturn sort(contours)","def fun_contours(self, params):\n shape_coeffs = params[:self.num_shape_params]\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\n\n vertices3d = self.vertices3d\n vertices3d_from_mesh = np.zeros_like(vertices3d)\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\n\n inner_idx = 0\n for idx in range(vertices3d.shape[0]):\n lm_idx = idx % 66\n obs_num = int(np.floor(idx/66))\n\n if lm_idx in self.contour_lms_list[0]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_right[obs_num])\n elif lm_idx in self.contour_lms_list[1]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_left[obs_num])\n else:\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\n inner_idx += 1\n if inner_idx == 50:\n inner_idx = 0\n\n return (vertices3d_from_mesh - vertices3d).ravel()","def cell_detects(self, masked=False):\r\n grd = self.grd\r\n ncells = len(grd.cells['depth'])\r\n detects_i_tr = np.zeros(ncells, np.int32)\r\n if masked:\r\n not_flagged = np.where(self.rec_track.flagged==0)[0]\r\n rec_track = self.rec_track[not_flagged]\r\n else:\r\n rec_track = self.rec_track\r\n ndetects = len(rec_track)\r\n for nd in range(ndetects):\r\n tr = rec_track[nd]\r\n i = tr.i\r\n if i >= 0:\r\n detects_i_tr[i] += 1\r\n \r\n return detects_i_tr","def select_contours(img):\n # Find contours at a constant value\n contours = measure.find_contours(img, 300)\n # print(\"Found \" + str(len(contours)) + \" contour(s)\")\n # Select the nearest contours with respect to the center pixel of the image\n width = img.shape[1] # number of columms\n heigth = img.shape[0] # number of rows\n pixel_ref = (width / 2, heigth / 2)\n # Threshold distance is 10% of images smallest dimension\n dist_thresh = min(width, heigth) * 0.1\n contours_wanted = []\n pixel_mean_array = []\n for contour in contours:\n contour_3d = np.zeros([contour.shape[0], 3]) # 3rd dimension added for later conversion to patient coord space\n contour_3d[:, :2] = contour\n pixel_mean = np.mean(contour, axis=0)\n if distance.euclidean(pixel_ref, pixel_mean) <= dist_thresh:\n contours_wanted.append(contour_3d)\n pixel_mean_array.append(pixel_mean)\n # print(\"Set \" + str(len(contours_wanted)) + \" contours of interest\")\n return contours_wanted, pixel_mean_array","def get_pair_rects(contours):\n\n rect_pairs = []\n for index, cnt in enumerate(contours):\n # Rotated rect - ( center (x,y), (width, height), angle of rotation )\n rect = cv2.minAreaRect(cnt)\n center_x, center_y = rect[0]\n rect_angle = -round(rect[2], 2)\n\n if rect_angle > 45.0:\n # Iterate through all of the potential matches\n min_x_dist = min_rect = min_index = None\n for pot_index, pot_match in enumerate(contours):\n if np.array_equal(pot_match, cnt):\n continue\n\n match_rect = cv2.minAreaRect(pot_match)\n\n # Check if match is to the right of the contour\n if match_rect[0][0] > rect[0][0] and abs(\n match_rect[2] - rect_angle) > ANGLE_TOLERANCE_DEG:\n x_distance = match_rect[0][0] - rect[0][0]\n\n if min_x_dist is None or x_distance < min_x_dist:\n min_x_dist = x_distance\n min_rect = match_rect\n min_index = pot_index\n\n if min_rect is not None:\n rect_pairs.append((rect, min_rect))\n np.delete(contours, index)\n np.delete(contours, min_index)\n\n return rect_pairs","def getContours( self,img ):\n if( len(img.shape) == 3):\n (_, contours, _) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n else:\n (contours,_) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours","def find_components(edges, max_components=16):\n # Perform increasingly aggressive dilation until there are just a few\n # connected components.\n\n count = 21\n dilation = 5\n n = 1\n while count > 16:\n n += 1\n dilated_image = dilate(edges, N=3, iterations=n)\n dilated_image = np.uint8(dilated_image)\n contours, hierarchy = cv2.findContours(dilated_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n count = len(contours)\n # print dilation\n # Image.fromarray(edges).show()\n # Image.fromarray(255 * dilated_image).show()\n return contours","def GetInteriorEdgesTri(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesTri()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesTri()\n\n sorted_all_edges = np.sort(self.all_edges,axis=1)\n sorted_boundary_edges = np.sort(self.edges,axis=1)\n\n x = []\n for i in range(self.edges.shape[0]):\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\n pos_interior_edges = np.where(interior_edges==0)[0]\n if pos_interior_edges.shape[0] != 0:\n x.append(pos_interior_edges)\n\n edge_aranger = np.arange(self.all_edges.shape[0])\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\n interior_edges = self.all_edges[edge_aranger,:]\n\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\n edge_flags[edge_aranger] = 0\n\n self.interior_edges = interior_edges\n return interior_edges, edge_flags","def get_position_patterns(contours, hierarchy):\n found = []\n for i in range(len(contours)):\n k = i\n c = 0\n while hierarchy[k][2] != -1:\n k = hierarchy[k][2]\n c += 1\n if c >= 5:\n found.append(i)\n return found","def find_contours(dframe):\n #Blur the image.\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\n #if debug:\n #plt.imshow(fixColor(blurred))\n #plt.show()\n #Get a threshold image, numbers where tested for the given video.\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \n cv2.CHAIN_APPROX_SIMPLE)\n return cnts","def read_board_values(self):\r\n\r\n # Iterate through each contour/cell\r\n for row in self.game_board_contours:\r\n board_row = []\r\n\r\n # For each cell, we get its location and crop the original thresholded image to that location\r\n for c in row:\r\n x, y, w, h = cv2.boundingRect(c)\r\n x_margin = int(w * 0.05)\r\n y_margin = int(h * 0.05)\r\n cropped_image = self.thresh_orig[y + y_margin:y + h - 2 * y_margin, x + x_margin:x + w - 2 * x_margin]\r\n\r\n # If it's mostly white, we don't need to waste time with OCR and we know it is blank\r\n if np.average(cropped_image) > 253:\r\n board_row.append(0)\r\n\r\n # Otherwise we pass it to the OCR to see which character is present within that cell\r\n else:\r\n character = pytesseract.image_to_string(cropped_image, config=self.pytesseract_config)\r\n # If the character is a commonly mis-read one, use dictionary to find the real character\r\n if character in self.replacements:\r\n character = self.replacements[character]\r\n board_row.append(character)\r\n self.game_board.append(board_row)","def _get_end_points(self, segmented_instances, i, stats, idx):\n\n end_points=[]\n\n # find all points intersecting the bbox\n #(tl_x, th_y, width, height, area)\n label_num=i+1\n leftmost_x = stats['bbox'][i][cv2.CC_STAT_LEFT]\n topmost_y = stats['bbox'][i][cv2.CC_STAT_TOP]\n width = stats['bbox'][i][cv2.CC_STAT_WIDTH]\n height = stats['bbox'][i][cv2.CC_STAT_HEIGHT]\n bottom_most_y = topmost_y + height-1\n right_most_x = leftmost_x + width-1\n\n segmented_instances_copy=segmented_instances.copy()\n edge_points = np.zeros(segmented_instances.shape).astype(np.uint8)\n segs = np.zeros(segmented_instances.shape).astype(np.uint8)\n segs[segmented_instances==label_num]=255\n cv2.rectangle(segmented_instances_copy,(leftmost_x, topmost_y), (right_most_x, bottom_most_y), 150, 2)\n\n #Get all points for the current stem segment\n label_points = np.argwhere(segmented_instances.copy()==label_num)\n\n # upper points from (tl_x,th_y) to (th_x, th_y) that instersect with the upper edge of the bouding box\n upper_points = [i for i in label_points if i[0]==topmost_y and i[1]>=leftmost_x and i[1]<=right_most_x]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(upper_points, edge_points, segs, 1)\n center_upper_pts = sorted(self._get_centeroids(x_pts))\n\n # left side points from (tl_x, tl_y) to (tl_x, th_y) that instersect with the left edge of the bouding box\n left_points = [i for i in label_points if i[1]==leftmost_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(left_points, edge_points, segs, 0)\n center_left_pts = sorted(self._get_centeroids(x_pts))\n\n #right side points form (th_x, tl_y) to (th_x, th_y) that instersect with the right edge of the bouding box\n right_points = [i for i in label_points if i[1]==right_most_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(right_points, edge_points, segs, 0)\n center_right_pts = sorted(self._get_centeroids(x_pts))\n\n #bottom points from (tl_x, tl_y) to (th_x,tl_y)\n bottom_points = [i for i in label_points if i[1]>=leftmost_x and i[1]<=right_most_x and i[0]==bottom_most_y]\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(bottom_points, edge_points, segs, 1)\n center_bottom_pts = sorted(self._get_centeroids(x_pts))\n\n # If there are corner edges, get the centroid of that\n center_x_lb, center_y_lb, center_left_pts, center_bottom_pts = self._get_corner_centers(center_left_pts, \\\n center_bottom_pts, bottom_most_y, leftmost_x)\n if (center_x_lb != None) and (center_y_lb != None):\n end_points.append([center_x_lb, center_y_lb])\n else:\n if len(center_left_pts)>0:\n for pt_idx in range(0, len(center_left_pts)):\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\n if len(center_bottom_pts)>0:\n for pt_idx in range(0, len(center_bottom_pts)):\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\n\n # If there are corner edges, get the centroid of that\n center_x_ur, center_y_ur, center_right_pts, center_upper_pts = self._get_corner_centers(center_right_pts, \\\n center_upper_pts, topmost_y, right_most_x)\n if (center_x_ur != None) and (center_y_ur != None):\n end_points.append([center_x_ur, center_y_ur])\n else:\n if len(center_right_pts)>0:\n for pt_idx in range(0, len(center_right_pts)):\n end_points.append([right_most_x, center_right_pts[pt_idx]])\n if len(center_upper_pts)>0:\n for pt_idx in range(0, len(center_upper_pts)):\n end_points.append([center_upper_pts[pt_idx], topmost_y])\n\n # If there are corner edges, get the centroid of that\n center_x_ul, center_y_ul, center_left_pts, center_upper_pts = self._get_corner_centers(center_left_pts, \\\n center_upper_pts, topmost_y, leftmost_x)\n if (center_x_ul != None) and (center_y_ul != None):\n end_points.append([center_x_ul, center_y_ul])\n else:\n if len(center_left_pts)>0:\n for pt_idx in range(0, len(center_left_pts)):\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\n if len(center_upper_pts)>0:\n for pt_idx in range(0, len(center_upper_pts)):\n end_points.append([center_upper_pts[pt_idx], topmost_y])\n\n\n # If there are corner edges, get the centroid of that\n center_x_br, center_y_br, center_right_pts, center_bottom_pts = self._get_corner_centers(center_right_pts, \\\n center_bottom_pts, bottom_most_y, right_most_x)\n if (center_x_br != None) and (center_y_br != None):\n end_points.append([center_x_br, center_y_br])\n else:\n if len(center_right_pts)>0:\n for pt_idx in range(0, len(center_right_pts)):\n end_points.append([right_most_x, center_right_pts[pt_idx]])\n if len(center_bottom_pts)>0:\n for pt_idx in range(0, len(center_bottom_pts)):\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\n\n #self.showme(segmented_instances_copy, 'bbox')\n\n return end_points","def get_further_neighbours(self, cell):\n\t\tneighs = self.get_neighbours(cell)\n\t\ti, j = cell.find_id()\n\t\tneighbours = []\n\t\tfor neigh in neighs:\n\t\t\tx, y = neigh.find_id()\n\t\t\tif abs(x-i)+abs(y-j) > 1 or abs(x-i)+abs(y-j) == 0: \n\t\t\t\tneighbours.append(self.space[y,x])\n\t\treturn neighbours","def get_neighbours(self):\n shape=self.cubeshape[1:]\n neighboursx=np.arange(self.xpos-(self.blocksize-1)/2,(self.xpos+(self.blocksize-1)/2)+1,dtype='int' )\n neighboursx=[x if (x>=0) & (x<=shape[1]-1) else np.nan for x in neighboursx ]\n neighboursy=np.arange(self.ypos-(self.blocksize-1)/2,(self.ypos+(self.blocksize-1)/2)+1,dtype='int' )\n neighboursy=[y if (y>=0) & (y<=shape[0]-1) else np.nan for y in neighboursy ]\n keys=[np.ravel_multi_index([y,x], shape) if np.all(np.isfinite(np.asarray([y,x]))) else np.nan for y in neighboursy for x in neighboursx]\n\n return keys","def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\n\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\n\n # Since the watershed draws contours, we need to invert the predictions to\n # get the 'inside' blob portion. We also slightly compress the blob portion\n # so we can get a more defining border.\n inverted_contours = 255 - class_contours\n\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\n # remove areas that are not part of the class mask\n inverted_contours[class_mask==0]= 0 # here ?\n\n return inverted_contours","def getSignificantContours(frame, epsilon=None):\n frame, contours, hierarchy = cv2.findContours(frame, cv2.RETR_TREE,\n cv2.CHAIN_APPROX_SIMPLE)\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\n significantContours = []\n perimeters = []\n\n for contour in contours:\n perimeter = cv2.arcLength(contour, closed=False)\n index = bisect.bisect(perimeters, perimeter)\n if epsilon is not None:\n approx = cv2.approxPolyDP(contour, epsilon * perimeter, False)\n significantContours.insert(index, approx)\n else:\n significantContours.insert(index, contour)\n perimeters.insert(index, perimeter)\n\n return significantContours","def analyzeContours(contours):\n if len(contours[0]) != 4 and len(contours[0]) != 8:\n return 0\n\n first, second, prev = [1, 1], [1, 1], 0\n for i, val in enumerate(numpy.nditer(contours[0])):\n if i % 2:\n second = [prev, val]\n else:\n first = [prev, val]\n\n # compare pair to the previous pair\n for num in first:\n if num in second:\n break\n else:\n return 0\n\n prev = val\n\n return 1","def find_contours(mask):\n _, contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_KCOS)\n return contours","def find_contours(vertical, horizontal):\n\tmask = vertical + horizontal\n\n\ttry:\n\t\t__, contours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\texcept ValueError:\n\t\t# for opencv backward compatibility\n\t\tcontours, __ = cv2.findContours(\n\t\t\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\n\t\t)\n\t# sort in reverse based on contour area and use first 10 contours\n\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\n\n\tcont = []\n\tfor c in contours:\n\t\tc_poly = cv2.approxPolyDP(c, 3, True)\n\t\tx, y, w, h = cv2.boundingRect(c_poly)\n\t\tcont.append((x, y, w, h))\n\treturn cont","def contours_to_arrays(gdf, col): \n\n coords_zvals = []\n\n for i in range(0, len(gdf)):\n\n val = gdf.iloc[i][col]\n\n try:\n coords = np.concatenate([np.vstack(x.coords.xy).T \n for x in gdf.iloc[i].geometry])\n except:\n coords = np.vstack(gdf.iloc[i].geometry.coords.xy).T\n\n coords_zvals.append(np.column_stack((coords, \n np.full(np.shape(coords)[0], \n fill_value=val))))\n\n return np.concatenate(coords_zvals)","def generate_contours(edges, colorimg, img):\n cv2.destroyAllWindows()\n cv2.namedWindow(\"Contours\")\n lengthlimit = 20\n arealimit = 20\n\n # create trackbars for length and area filters\n cv2.createTrackbar(\"length\", \"Contours\", 0, 200, nothing)\n cv2.createTrackbar(\"area\", \"Contours\", 0, 2000, nothing)\n\n # find all possible contours in the image\n ret, thresh = cv2.threshold(edges, 127, 255, 0)\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n while 1:\n cv2.imshow(\"Contours\", colorimg)\n\n # filter based on area and length\n lengthlimit = cv2.getTrackbarPos(\"length\", \"Contours\")\n arealimit = cv2.getTrackbarPos(\"area\", \"Contours\")\n\n for idx, contour in enumerate(contours):\n if len(contour) > lengthlimit:\n area = cv2.contourArea(contour)\n if area > arealimit:\n isconvex = cv2.isContourConvex(contour)\n circle = cv2.minEnclosingCircle(contour)\n cv2.drawContours(colorimg, contours, idx, (0, 255, 0), 2)\n else:\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\n else:\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\n\n k = cv2.waitKey(1) & 0xFF\n # print k\n if k == 27:\n exit()\n if k == 32:\n show_final(colorimg, contours, arealimit, lengthlimit)","def segment_cells(frame, mask=None):\n \n blurred = filters.gaussian(frame, 2)\n ridges = enhance_ridges(frame)\n \n # threshold ridge image\n thresh = filters.threshold_otsu(ridges)\n thresh_factor = 0.5\n prominent_ridges = ridges > thresh_factor*thresh\n prominent_ridges = morphology.remove_small_objects(prominent_ridges, min_size=256)\n prominent_ridges = morphology.binary_closing(prominent_ridges)\n prominent_ridges = morphology.binary_dilation(prominent_ridges)\n \n # skeletonize\n ridge_skeleton = morphology.medial_axis(prominent_ridges)\n ridge_skeleton = morphology.binary_dilation(ridge_skeleton)\n ridge_skeleton *= mask\n ridge_skeleton = np.bitwise_xor(ridge_skeleton, mask)\n \n # label\n cell_label_im = measure.label(ridge_skeleton)\n \n # morphological closing to fill in the cracks\n for cell_num in range(1, cell_label_im.max()+1):\n cell_mask = cell_label_im==cell_num\n cell_mask = morphology.binary_closing(cell_mask, disk(3))\n cell_label_im[cell_mask] = cell_num\n \n return cell_label_im","def find_contours(img_path, **kwargs):\n threshold = kwargs['threshold']\n image = cv2.imread(img_path)\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n blurred = cv2.GaussianBlur(gray, (5, 5), 0)\n thresh = cv2.threshold(blurred, threshold, 255, cv2.THRESH_BINARY)[1]\n contours, _ = cv2.findContours(thresh.copy(),\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n\n\n contour_areas = [] # TODO: is there a faster way to keep the contors with n-largest areas?\n for i, contour in enumerate(contours):\n area = cv2.contourArea(contour)\n contour_areas.append((i, area))\n\n rect = cv2.minAreaRect(contour)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n cv2.drawContours(image,[box],0,(0,0,255),2)\n cv2.imwrite('rect_{}.png'.format(i), image)\n # Contours that cover the largest areas are whole pieces\n largest_contour_areas = nlargest(10, contour_areas, key=lambda x:x[1])\n #print(largest_contour_areas)\n\n for i, area in largest_contour_areas:\n print (i, area)\n cv2.drawContours(image, contours, i, (100, 155, 100), 3)\n cv2.imwrite('contor_{}.png'.format(i), image)\n return True","def find_contour(hole_atoms, atom_list):\n contour_atoms = []\n extra_atoms = []\n global bond_list\n bond_list = bond_list_1\n for atom in hole_atoms:\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond[0] not in hole_atoms) and (bond[0] not in contour_atoms))]\n for element in c:\n contour_atoms.append(element)\n for atom in atom_list:\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\n count = 0\n for element in c:\n if element in contour_atoms:\n count += 1\n if (count >= 2):\n extra_atoms.append(atom)\n for atom in atom_list:\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\n for element in c:\n if ((element in contour_atoms) or (element in extra_atoms)):\n for i in [bond[0] for bond in identify_bonds(element, atom_list)]:\n if ((i in hole_atoms) and (atom not in hole_atoms) and (atom not in contour_atoms) and (atom not in extra_atoms)):\n extra_atoms.append(atom) \n \n contour_atoms = contour_atoms + extra_atoms\n \n extra_atoms2 = []\n for atom in contour_atoms:\n for atom2 in contour_atoms:\n if (atom != atom2):\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond in identify_bonds(atom2, atom_list)) and (bond[0] not in (contour_atoms)))]\n if (len(c) != 0):\n extra_atoms2.append(c[0]) \n for element in extra_atoms2:\n contour_atoms.append(element)\n return contour_atoms","def getContours(img):\n # mode: gets only exrteme outer contours\n # method: stores all contour points\n contours, hierarchy = cv2.findContours(img, mode=cv2.RETR_EXTERNAL,\n method=cv2.CHAIN_APPROX_NONE)\n \n x, y, w, h = 0, 0, 0, 0\n\n # improving accuracy of contours\n for cnt in contours:\n area = cv2.contourArea(cnt)\n if area > 500:\n # assumes cnt with area > 500 is closed contour \n perimeter = cv2.arcLength(cnt, True)\n\n # approximate polygonal curve of cnt\n # set max difference between original and approxCurve as \n # 0.02 * perimeter\n approxCurve = cv2.approxPolyDP(cnt, 0.02 * perimeter, closed=True)\n \n x, y, w, h = cv2.boundingRect(approxCurve)\n # wand point is is center-left tip\n return x + (w // 2), y","def paintings_detection(query_image, mask):\n\n image = cv2.imread(query_image)\n\n image_width = mask.shape[0]\n image_height = mask.shape[1]\n x_box_1, y_box_1, w_box_1, h_box_1, x_box_2, y_box_2, w_box_2, h_box_2 = 0, 0, 0, 0, 0, 0, 0, 0, \n\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2:]\n\n for cnt in contours:\n x, y, w, h = cv2.boundingRect(cnt)\n \n if (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 == 0):\n x_box_1, y_box_1, w_box_1, h_box_1 = x, y, w, h\n elif (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 != 0):\n x_box_2, y_box_2, w_box_2, h_box_2 = x, y, w, h\n\n if x_box_2 == 0:\n x_value_to_split = 0\n else:\n x_value_to_split = (x_box_1 + w_box_1/2 + x_box_2 + w_box_2/2) / 2\n\n\n return(x_value_to_split)","def footprint_corner_indices():","def find_contours(mask):\n\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,\n cv2.CHAIN_APPROX_SIMPLE)\n cnts = imutils.grab_contours(cnts)\n return cnts","def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\n\n kernel = np.ones((5, 5), np.float32)\n\n # Use a distance transform to find the seed points for watershed\n tmp = class_mask\n tmp[tmp>0] = 1 # here\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\n dist = (dist / np.max(dist)) * 255.\n\n # Since there may be multiple peaks, we use dilation to find them\n dilate = cv2.dilate(dist, kernel, iterations=3)\n peaks = np.float32(np.where(dilate == dist, 1, 0))\n peaks = peaks * class_mask * 255\n\n sure_fg = np.where(peaks > 125, 255., 0.)\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\n sure_fg = np.uint8(sure_fg)\n\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\n unknown = sure_bg - sure_fg\n\n # Add one to all labels so that known background is not 0, but 1\n _, markers = cv2.connectedComponents(sure_fg)\n markers = markers + 1\n\n markers[unknown == 255] = 0\n\n markers = cv2.watershed(self.image, markers)\n\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\n watershed_superpixels[markers == -1] = 255\n\n return watershed_superpixels","def mark_contours(contour_arr, img, symmetry, _plot=False):\n marg, flag = 7, 0\n # fig, ax = plt.subplots()\n # ax.imshow(img, cmap=\"gray\")\n sub_images = [] # init array for pictures\n for contour in contour_arr:\n\n lower_dim = contour[:, 0]\n x, y = lower_dim[:, 0], lower_dim[:, 1]\n min_x, min_y, max_x, max_y = min(x), min(y), max(x), max(y)\n\n # remove small noise\n if (max_x - min_x) * (max_y - min_y) < MIN_IMG_SIZE:\n continue\n # avoid index error\n if min_x - marg < 0 or min_y - marg < 0 or max_y + marg > img.shape[0] or max_x + marg > img.shape[1]:\n marg = 0\n # crop only half cause image is symmetric:\n # TODO: address different types of symmetry as input from user\n if symmetry == HORIZONTAL:\n if max_x <= img.shape[1] // 2:\n sub_images.append(img[min_y:max_y, min_x:max_x])\n flag = 1\n else: # symmetry is around the X-axis\n if max_y <= img.shape[0] // 2:\n sub_images.append(img[min_y:max_y, min_x:max_x])\n flag = 1\n if _plot and flag:\n ax.plot([min_x - marg, max_x + marg, max_x + marg, min_x - marg, min_x - marg],\n [min_y - marg, min_y - marg, max_y + marg, max_y + marg, min_y - marg], c='r', linewidth=0.4)\n flag = 0\n if _plot:\n plt.savefig(\"found_subshapes2.jpg\")\n # plt.show()\n return sub_images","def register_cells(contours: List[np.array]) -> np.array:\n def create_cell(contour: np.array) -> np.array:\n center, radius = cv2.minEnclosingCircle(contour)\n v = (0, 0)\n weight = -1\n\n return np.array([center[0], center[1], v[0], v[1], radius, weight])\n\n areas = np.array([cv2.contourArea(contour) for contour in contours]).astype(\"float32\")\n blobs = np.array([create_cell(contour) for contour in contours]).astype(\"int32\")\n\n return blobs[areas >= 100].astype(\"float32\")","def instance_submasks(gti):\n rc_locs = np.where(gti > 0)\n grouped_cc_rcs = util.group_items(\n np.ascontiguousarray(np.vstack(rc_locs).T),\n gti[rc_locs], axis=0\n )\n\n def bounding_box(rcs):\n rc1 = rcs.min(axis=0)\n rc2 = rcs.max(axis=0)\n return rc1, rc2\n\n for label, rcs in grouped_cc_rcs.items():\n rc1, rc2 = bounding_box(rcs)\n r_slice = slice(rc1[0], rc2[0] + 1)\n c_slice = slice(rc1[1], rc2[1] + 1)\n rc_sl = (r_slice, c_slice)\n subimg = gti[rc_sl]\n submask = (subimg == label).astype(np.uint8)\n\n rc_off = rc1\n yield label, submask, rc_off, rc_sl","def detectBlocksInDepthImage(self):\n self.depth_detect_frame = self.currentDepthFrame\n\n # 1 block\n self.bin_detect_frame_1 = cv2.inRange(self.depth_detect_frame,700,710)\n kernel = np.ones((6,6),np.uint8)\n self.bin_detect_frame_1 = cv2.erode(self.bin_detect_frame_1,kernel,iterations = 1)\n _, self.block_contours, _ = cv2.findContours(self.bin_detect_frame_1,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)\n \n # 2 blocks\n self.bin_detect_frame_2 = cv2.inRange(self.depth_detect_frame,680,699)\n kernel = np.ones((6,6),np.uint8)\n self.bin_detect_frame_2 = cv2.erode(self.bin_detect_frame_2,kernel,iterations = 1)\n _, self.block_contours_2, _ = cv2.findContours(self.bin_detect_frame_2,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)\n \n # 3 blocks\n self.bin_detect_frame_3 = cv2.inRange(self.depth_detect_frame,660,679)\n kernel = np.ones((6,6),np.uint8)\n self.bin_detect_frame_3 = cv2.erode(self.bin_detect_frame_3,kernel,iterations = 1)\n _, self.block_contours_3, _ = cv2.findContours(self.bin_detect_frame_3,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)\n \n pass","def recognize_pieces(edges, v, squares):\n\n pieces = []\n\n v = cv2.equalizeHist(v)\n for p1, p2 in squares:\n # count the number of slightly centered edges\n occupancy = sum(edges[y][x]\n for x in range(p1.x + 5, p2.x - 5)\n for y in range(p1.y + 5, p2.y - 5))\n\n if occupancy > 70*255:\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\n v[p2.y][p1.x], v[p2.y][p2.x])\n\n # average v-component of the corners\n avg = sum(map(float, corners)) / len(corners)\n\n # black pixels should be relatively black\n # when compared to the corner average\n black = sum(v[y][x] / avg < 0.2\n for x in range(p1.x, p2.x + 1)\n for y in range(p1.y, p2.y + 1))\n\n if black >= 1000 and black != 1049:\n color = \"B\"\n else:\n color = \"W\"\n\n pieces.append(color)\n else:\n pieces.append(None)\n\n return pieces","def draw_separate_position_patterns(img, found, contours):\n for i in found:\n qr_dc = img.copy()\n cv2.drawContours(qr_dc, contours, i, (0, 255, 0), 2)\n show(qr_dc)","def draw_contours(self):\n contours, hierarchy = cv2.findContours(self.edged, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_TC89_L1)\n\n edged = cv2.bitwise_not(self.edged)\n rgb = cv2.cvtColor(edged, cv2.COLOR_GRAY2RGB)\n\n temp_array = np.ones([rgb.shape[0], rgb.shape[1], rgb.shape[2]])\n contours_ = cv2.drawContours(temp_array, contours, -1, (0, 0, 0), thickness=1)\n\n ml_filename = 'MLOutputs/' + str(self.file_name) + 'Clusters' + str(self.clusters) + \\\n 'FilterSize' + str(self.filter_size) + 'Sigma' + str(self.sigma) + 'UniqueColours' + \\\n str(self.unique_colours) + \".png\"\n\n plt.imshow(contours_, cmap=\"gray\")\n if not os.path.isfile(ml_filename):\n imsave(ml_filename, contours_, cmap=\"gray\")","def _plot_traces_with_cell_img(self, fovlist, gs, maxshape):\n starting_row_idx = 0\n ending_row_idx = 0\n for fov in fovlist:\n time_vec = np.arange(maxshape[1]) / fov.fps\n starting_row_idx = ending_row_idx\n if fov.labeled:\n ending_row_idx += max(\n fov.unlabeled.dff.shape[0], fov.labeled.dff.shape[0]\n )\n else:\n ending_row_idx += fov.all_data.shape[0]\n midpoint = gs.get_geometry()[1] // 2\n self._show_cell_excerpts(\n fovsubset=fov.unlabeled,\n radius=fov.cell_radius,\n gs=gs,\n gs_rows=slice(starting_row_idx, ending_row_idx),\n gs_col=0,\n )\n self._show_cell_excerpts(\n fovsubset=fov.labeled,\n radius=fov.cell_radius,\n gs=gs,\n gs_rows=slice(starting_row_idx, ending_row_idx),\n gs_col=midpoint,\n )\n self._show_traces(\n fovsubset=fov.unlabeled,\n time_vec=time_vec,\n fps=fov.fps,\n gs=gs,\n gs_rows=slice(starting_row_idx, ending_row_idx),\n gs_cols=slice(1, midpoint),\n )\n self._show_traces(\n fovsubset=fov.labeled,\n time_vec=time_vec,\n fps=fov.fps,\n gs=gs,\n gs_rows=slice(starting_row_idx, ending_row_idx),\n gs_cols=slice(midpoint+1, None),\n )","def identify_dbs(image):\n locations = {\"red\": Point(), \"green\": Point(), \"blue\": Point()}\n masks = {\"red\": [], \"green\": [], \"blue\": []}\n\n bridge = cv_bridge.CvBridge()\n image = bridge.imgmsg_to_cv2(image, \"bgr8\")\n hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n\n # upper and lower bounds for red\n # using python 3 bgr [0,0,188] = hsv [0, 255, 188]\n lower_red = numpy.array([0, 100, 100]) \n upper_red = numpy.array([10, 255, 255])\n masks[\"red\"] = cv2.inRange(hsv, lower_red, upper_red)\n\n # upper and lower bounds for green\n # using python 3 bgr [0,175,0] = hsv [60, 255, 175]\n lower_green = numpy.array([50, 100, 100]) \n upper_green = numpy.array([70, 255, 255])\n masks[\"green\"] = cv2.inRange(hsv, lower_green, upper_green)\n\n # upper and lower bounds for blue\n # using python 3 bgr [176, 0, 17] = hsv [123, 255, 176]\n lower_blue = numpy.array([113, 100, 100])\n upper_blue = numpy.array([133, 255, 255])\n masks[\"blue\"] = cv2.inRange(hsv, lower_blue, upper_blue)\n\n x, y, w, h = 0, 0, image.shape[1]//3, image.shape[0]\n\n for color, mask in masks.items():\n pixels = {\"left\": 0, \"middle\": 0, \"right\": 0}\n \n # define section of image to use for left, middle and right\n left = mask[y:y+h, x:x+w]\n middle = mask[y:y+h, x+w:x+w+w]\n right = mask[y:y+h, x+w+w:x+3*w]\n\n # count the number of pixels in each section\n pixels[\"left\"] = cv2.countNonZero(left)\n pixels[\"middle\"] = cv2.countNonZero(middle)\n pixels[\"right\"] = cv2.countNonZero(right)\n location = max(pixels, key=pixels.get)\n\n # map the relative position of the db (left, middle, right) to the correct Point()\n locations[color] = db_locations[location]\n \n return locations","def find_contour(ctx: Context):\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\n contours, _ = cv2.findContours(ctx.temp_image1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n\n # take the 5 biggest areas\n contours = sorted(contours, key=lambda c: math.fabs(cv2.contourArea(c)), reverse=True)[:5]\n\n # approximate contours with poly line\n ctx.contours = [cv2.approxPolyDP(c, 2, True) for c in contours]","def get_instance_contours(img, contoured, instance):\n mask = np.zeros(img.shape, dtype=np.uint16)\n mask[img == instance] = 1\n ret, threshed = cv.threshold(mask, 0, 2 ** 16, cv.THRESH_BINARY)\n compressed = threshed.astype(np.uint8)\n contours, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n cv.drawContours(contoured, contours, -1, (randint(25, 255), randint(25, 255), randint(25, 255)), 3)\n img2 = contours = hierarchy = mask = None","def get_nb_vals(i, pnts, dem, top_left_cor, cellsize, rows, cols):\n nb_x = np.zeros((5,5)) # this 5 by 5 max would contain the x coordinate of 16 neighbor pixels of a sample point\n nb_y = np.zeros((5,5)) # this 5 by 5 matrix would contain the y coordinate of 16 neighbor pixels of a sample point\n nb_z = np.zeros((5,5))\n # get index and value of cell in DEM containing current point\n (cell_X, cell_Y, cell_Z) = misc.getCellValue(pnts[i], \n dem, \n top_left_cor, \n cellsize)\n #Deal with sample points near boundary of the DEM\n point_within_dem = (cell_X-2) >=0 and (cell_Y-2>=0) and (cell_X+3)<=cols and (cell_Y+3)<=rows\n if point_within_dem:\n nb_z[0:5,0:5] = misc.RasterSubset(dem,(cell_Y-2),(cell_Y+3),(cell_X-2),(cell_X+3))\n else:\n #Get the part of moving window within the DEM domain\n in_data= misc.RasterSubset(dem,max((cell_Y-2),0),min((cell_Y+3),rows),max((cell_X-2),0),min((cell_X+3),cols))\n #in_data=dem[\"array\"][max((cell_Y-2),0):min((cell_Y+3),rows),max((cell_X-2),0):min((cell_X+3),cols)]\n nb_z[max((2-cell_Y),0):min((5-(cell_Y+3-rows)),5),max((2-cell_X),0):min((5-(cell_X+3-cols)),5)]=in_data[0:in_data.shape[0],0:in_data.shape[1]]\n in_data_avg=np.mean(in_data[in_data>-3.4e+10])\n nb_z[nb_z==0]=in_data_avg\n nb_z[nb_z<-3.4e+10]=in_data_avg\n\n\n \n # If there is missing data in the neighborhood of the sample point \n # use neighborhood average to replace the missing value \n has_missing_data = (nb_z>8848).sum()>0 or (nb_z<-413).sum()>0\n if has_missing_data:\n avgValue=np.mean(nb_z[np.where(np.logical_and(nb_z<8848, nb_z>-413))])\n nb_z[nb_z>8848]=avgValue\n nb_z[nb_z<-413]=avgValue\n \n # Obtain the coordinate of cell centroid of a 5*5 neighborhood around the sample point\n for ii in [0,1,2,3,4]:\n cor_y=ii-2\n dy = (cell_Y+cor_y+0.5) * cellsize[1]\n nb_y[ii,:] = top_left_cor[1] + dy\n for jj in [0,1,2,3,4]:\n cor_x=jj-2\n dx = (cell_X+cor_x+0.5) * cellsize[0]\n nb_x [:,jj] = top_left_cor[0] + dx\n return nb_x, nb_y, nb_z","def process(self):\n contours, hierachy = cv.findContours(\n self.input_image,\n cv.RETR_LIST,\n cv.CHAIN_APPROX_SIMPLE,\n )\n contours = sorted(contours, key=cv.contourArea, reverse=True)\n target = None\n for c in contours:\n path = cv.arcLength(c, True)\n approx = cv.approxPolyDP(c, 0.1*path, True)\n if len(approx) == 4:\n # print(approx)\n target = approx\n break\n if target is not None:\n \"\"\"\n cv.drawContours(\n self.original_image,\n [target],\n 0,\n (255, 255, 255),\n 5\n )\n \"\"\"\n self.output_image = copy.deepcopy(self.original_image)\n for p in target:\n cv.circle(self.output_image, tuple(p[0]), 4, (255, 255, 255), 5)\n return (self.output_image, target)","def get_neighbours(self, cell):\n\t\tx,y = cell.find_id()\n\t\tlength = self.space.shape[1]\n\t\twidth = self.space.shape[0]\n\t\tif (length == 0 or width == 0 or x < 0 or x >= length or y < 0 or y >= width):\n\t\t\treturn []\n\t\tneighs = [(i,j) for i in range(y-1,y+2) if 0<=i<width for j in range(x-1,x+2) if 0<=j<length]\n\t\tneighbours = []\n\t\tfor neigh in neighs:\n\t\t\tneighbours.append(self.space[neigh[0],neigh[1]])\n\t\treturn neighbours","def get_shapes(self):\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\n X = []\n backmap = {}\n rad = 3\n for k,((i,y),(j,x)) in enumerate(self.mids):\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\n colours[i][j] = m\n X.append(m)\n backmap[k] = (i,j)\n print(np.shape(X))\n Z = linkage(X, 'ward')\n Q = fcluster(Z, self.thresh, criterion='distance')\n\n closenesses = []\n for k,cls in enumerate(Q):\n i,j = backmap[k]\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\n minidx = np.argmin(closenesses)\n bgcls = Q[minidx]\n\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\n img4 = self.img2.copy()\n for k,((i,y),(j,x)) in enumerate(self.mids):\n cls = Q[k]\n if cls == bgcls:\n continue\n col = blibs[(cls-1)]\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\n\n write_img(\"./out/test_classes.png\", img4)\n self.classimg = img4\n\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\n mx = np.max(Q)\n for k,cls in enumerate(Q):\n if cls == bgcls:\n continue\n\n if cls == mx:\n plotcls = bgcls\n else:\n plotcls = cls\n i,j = backmap[k]\n A[i][j] = plotcls\n\n self.res = A","def get_table_corner_points(img):\n\n img_height, img_width, img_channels = img.shape\n lower_bounds,upper_bounds = get_table_color_bounds() # Get the bounds for the table felt color\n\n \"\"\"\n Table Image Masking\n \"\"\"\n res = cv2.cvtColor(img,cv2.COLOR_BGR2HSV) # Convert image to HSV color space\n mask = cv2.inRange(res,lower_bounds,upper_bounds) # Get image mask from bounds\n res = cv2.bitwise_and(img,img,mask = mask) # Mask the image\n\n \"\"\"\n Contour Detection\n \"\"\"\n imgray = cv2.cvtColor(res,cv2.COLOR_BGR2GRAY) # Get res in gray color space\n tmp,thresh = cv2.threshold(imgray,255,255,255) # Threshold on the gray image\n retr = cv2.RETR_EXTERNAL # Contour parameters\n mode = cv2.CHAIN_APPROX_SIMPLE\n tmp, contours, hierarchy = cv2.findContours(thresh,retr,mode) # Get contours\n res = np.zeros((img_height,img_width,3),np.uint8) # Blank image for contours\n color = (255,255,255) # Contour drawing parameters\n thickness = 3\n cv2.drawContours(res,contours,-1,color,thickness) # Draw contours on blank image\n\n \"\"\"\n Canny Detection\n \"\"\"\n blur = 9 # Blur parameter \n res = cv2.medianBlur(res,blur) # Blur\n res = cv2.Canny(res,100,150,apertureSize = 3) # Canny edge detection\n\n \"\"\"\n Hough Line Detection\n \"\"\"\n rho = 0.75 # Hough parameters\n theta = np.pi/180\n threshold = 150\n lines = cv2.HoughLines(res,rho,theta,threshold) # Get lines\n\n \"\"\"\n K-Mean 4 Line Clustering\n \"\"\"\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,10,1.0) # K-Means parameters\n flags = cv2.KMEANS_PP_CENTERS\n n = 4\n max_iterations = 10 \n compactness,labels,centers = cv2.kmeans(np.float32(lines),n,None,criteria,max_iterations,flags) # K-Means\n \n \"\"\"\n Get And Return Points\n \"\"\"\n growth = 100 # Offset to expand corners\n pts = _get_table_corners_from_lines_hough_space(centers,growth,img_width,img_height) # Gets the corner points\n ''' \n mask = np.zeros((img_height,img_width,3),np.uint8)\n cv2.fillPoly(mask,np.array([pts],dtype = np.int32),(255,255,255))\n show_img(mask)\n cv2.resize(mask,(img.shape[0],img.shape[1]),fx = 2, fy = 2, interpolation = cv2.INTER_CUBIC)\n show_img(mask*2)\n res = cv2.bitwise_and(img,mask)\n '''\n return pts","def drawcntMap(orgimg,filteredimg,wThresh,hThresh):\r\n _, contour, _ = cv2.findContours(filteredimg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\r\n\r\n cnt = cv2.drawContours(orgimg.copy(), contour, -1, (0, 0, 255), 2) # To draw filtered contours on original image\r\n\r\n digitCnts = [] # contours to be surrounded by bounding boxes\r\n\r\n for c in contour:\r\n (x, y, w, h) = cv2.boundingRect(c)\r\n if w >= wThresh and h >= hThresh and w*h <20000: # Length filters to reduce noise\r\n cv2.rectangle(cnt,(x,y),(x+w,y+h),[0,255,0],2)\r\n digitCnts.append(c)\r\n\r\n return cnt, digitCnts","def extract(self, files):\n for i in range(len(files)):\n print(files[i])\n img = cv2.imread('{}/{}'.format('{}/{}/{}'.format(DIR_2DST_Mask, self.patient, self.plan), files[i]), 0)\n\n \"\"\"\n Find the indices of array elements that are non-zero, i.e,\n find the pixels' positions that represents the respiratory\n functions (pixels in the respiratory function are brighter).\n \"\"\"\n color_pts = np.argwhere(img > 70)\n\n \"\"\"\n Sorts the pixels according to their x coordenate.\n Obs: np.argwhere inverts x and y, it's like (y, x), because of it,\n the parameter of itemgetter is 1 (to get x coordinate)\n \"\"\"\n lcolor_pts = sorted(color_pts.tolist(), key=itemgetter(1))\n\n \"\"\"\n If there is no pixel representing the respiratory function\n (i.e., lighter pixel) it creates an empty image (without any\n respiratory function)\n \"\"\"\n if len(lcolor_pts) == 0:\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n\n # file = open(\n # '{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\n # file.write(\"{}:{}\\n\".format(files[i], []))\n # file.close()\n\n continue\n\n # Reverse the coordinates and store the result in lordered_pts list\n lordered_pts = []\n for j in range(len(lcolor_pts)):\n lordered_pts.append(lcolor_pts[j][::-1])\n\n \"\"\"\n Convert pixels coordinates into a tuples and check which column\n has pixels that corresponding to diaphragmatic level\n Obs. There are some columns that doesnt have any pixel that\n correpond to diaphragmatic level.\n \"\"\"\n # Columns that have a pixel corresponding diaphragmatic level\n lcolumn_available = []\n for j in range(len(lordered_pts)):\n lordered_pts[j] = tuple(lordered_pts[j])\n lcolumn_available.append(lordered_pts[j][0])\n lcolumn_available = list(set(lcolumn_available))\n # print(\"Ordered points: \", lordered_pts)\n # print(\"Columns available: \", lcolumn_available)\n\n \"\"\"\n If there is not enough columns to build a respiratory pattern,\n create a blank image\n \"\"\"\n if len(lcolumn_available) < 20:\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n continue\n\n \"\"\"\n If there are no pixel that corresponding diaphragmatic level in the\n first column, assign to it the value of the second y coordinate\n \"\"\"\n if lcolumn_available[0] is not 0:\n y = max(\n [x for x in lordered_pts if x[0] == lcolumn_available[0]],\n key=itemgetter(1))[1]\n lordered_pts.insert(0, (0, y))\n lcolumn_available.insert(0, 0)\n\n \"\"\"\n If there are no pixel that corresponding diaphragmatic level in the\n last column, assign to it the value of the penultimate y coordinate\n available\n \"\"\"\n if lcolumn_available[-1] is not 49:\n lordered_pts.append(\n (49, lordered_pts[len(lcolumn_available)][1]))\n lcolumn_available.append(49)\n\n \"\"\"\n Get the biggest y value in each column that represents the\n diaphragmatic level\n \"\"\"\n column = 0\n lcolumn = []\n ldiaphragm_pts = []\n for j in range(50):\n # Get the column's points\n lcolumn = [x for x in lordered_pts if x[0] == column]\n # print('{}: {}'.format(j, lcolumn))\n\n if len(lcolumn) > 0:\n ldiaphragm_pts.append(\n max(lcolumn, key=itemgetter(1))) # Get the biggest y\n else:\n # Get the y value from the previous column\n lcolumn_available.insert(column, column)\n ldiaphragm_pts.append((column, ldiaphragm_pts[-1][1]))\n column += 1\n lcolumn = []\n\n # Draw diaphragmatic level\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n j = 0\n while(j < len(lcolumn_available) - 1):\n cv2.line(\n diaphragmatic_lvl,\n ldiaphragm_pts[j], ldiaphragm_pts[j + 1],\n (0, 0, 255), 1)\n j = j + 1\n\n lcolumn_available = []\n\n print(\"Diaphragmatic's points: \", ldiaphragm_pts)\n cv2.imshow('Diaphragmatic level', diaphragmatic_lvl)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n\n # file = open('{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\n # file.write(\"{}:{}\\n\".format(files[i], ldiaphragm_pts))\n # file.close()\n\n # return ldiaphragm_pts","def cfdProcessElementTopology(self):\r\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \r\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\r\n\r\n ## (list of lists) list of face indices forming each element\r\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\r\n \r\n #populates self.elementNeighbours\r\n for iFace in range(self.numberOfInteriorFaces):\r\n own=self.owners[iFace]\r\n nei=self.neighbours[iFace]\r\n \r\n #adds indices of neighbour cells\r\n self.elementNeighbours[own].append(nei)\r\n self.elementNeighbours[nei].append(own)\r\n \r\n #adds interior faces\r\n self.elementFaces[own].append(iFace)\r\n self.elementFaces[nei].append(iFace)\r\n \r\n #adds boundary faces ('patches')\r\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\r\n own=self.owners[iFace]\r\n self.elementFaces[own].append(iFace)\r\n \r\n ## List of lists containing points forming each element\r\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n \r\n for faceIndex in self.elementFaces[iElement]:\r\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\r\n \r\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\r\n \r\n ## Upper coefficient indices (owners)\r\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n ## Lower coefficient indices (owners)\r\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n ## Element number from 1 to numberOfElements + 1\r\n iNb=1\r\n for faceIndex in self.elementFaces[iElement]:\r\n \r\n #skip if it is a boundary face\r\n if faceIndex > self.numberOfInteriorFaces-1:\r\n continue\r\n \r\n own = self.owners[faceIndex]\r\n nei = self.neighbours[faceIndex]\r\n \r\n if iElement == own:\r\n self.upperAnbCoeffIndex[faceIndex] = iNb\r\n elif iElement == nei:\r\n self.lowerAnbCoeffIndex[faceIndex] = iNb\r\n \r\n iNb = iNb +1","def GetInteriorEdgesPent(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesPent()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesPent()\n\n sorted_all_edges = np.sort(self.all_edges,axis=1)\n sorted_boundary_edges = np.sort(self.edges,axis=1)\n\n x = []\n for i in range(self.edges.shape[0]):\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\n pos_interior_edges = np.where(interior_edges==0)[0]\n if pos_interior_edges.shape[0] != 0:\n x.append(pos_interior_edges)\n\n edge_aranger = np.arange(self.all_edges.shape[0])\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\n interior_edges = self.all_edges[edge_aranger,:]\n\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\n edge_flags[edge_aranger] = 0\n\n self.interior_edges = interior_edges\n return interior_edges, edge_flags","def run_connected_components(img, viz=False):\n\n fg = img.foreground_mask(cfg.COLOR_TOL, ignore_black=True)\n if viz:\n cv2.imwrite(\"debug_imgs/mask.png\", fg.data)\n\n groups = get_cluster_info(fg)\n\n if viz:\n display_grasps(img, groups)\n\n return groups","def getContours(image, copyImage):\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n for contour in contours:\n area = cv.contourArea(contour)\n \n if area > 500.0:\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\n perimeter = cv.arcLength(contour, True)\n \n # Approximates to the nearest polygon\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\n objectCoordinates = len(approx)\n\n # Returns the x, y and height width of the polygon\n x, y, w, h = cv.boundingRect(approx)\n\n if objectCoordinates == 3:\n objectShape = \"Triangle\"\n elif objectCoordinates == 4:\n ratio = w / float(h)\n if ratio >= 0.95 and ratio <= 1.05:\n objectShape = \"Square\"\n else: objectShape = \"Rectangle\"\n else: objectShape = \"Circle\" \n\n \n\n # Draw rectangles around the images\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))","def get_contour_lims(frame: imageType) -> Tuple[int, int, int, int]:\n largest_contour = get_largest_contour(frame)\n if largest_contour is not None:\n (x, y, w, h) = cv2.boundingRect(largest_contour)\n else:\n (x, y, w, h) = (0, 0, 0, 0)\n return (x, y, w, h)","def findFours(self):\n\n for i in range(6):\n for j in range(7):\n if self.board[i][j] != ' ':\n # check if a vertical four-in-a-row starts at (i, j)\n if self.verticalCheck(i, j):\n self.highlightFour(i, j, 'vertical')\n \n # check if a horizontal four-in-a-row starts at (i, j)\n if self.horizontalCheck(i, j):\n self.highlightFour(i, j, 'horizontal')\n \n # check if a diagonal (either way) four-in-a-row starts at (i, j)\n # also, get the slope of the four if there is one\n diag_fours, slope = self.diagonalCheck(i, j)\n if diag_fours:\n self.highlightFour(i, j, 'diagonal', slope)","def vis_detections(self,im, class_name, dets, thresh=0.5):\n\t\tinds = np.where(dets[:, -1] >= thresh)[0]\n\t\tif len(inds) == 0:\n\t\t\treturn None, None\n\n\t\tcenters = []\n\t\tfor i in inds:\n\t\t\tbbox = dets[i, :4]\n\t\t\tscore = dets[i, -1]\n\t\t\tim = im.copy()\n\t\t\tcv2.rectangle(im,(bbox[0],bbox[1]),(bbox[2],bbox[3]),(0,0,255))\n\n\t\t\tcenter = np.zeros(2)\n\t\t\tcenter[0] = bbox[0] + (bbox[2] - bbox[0])/2.0\n\t\t\tcenter[1] = bbox[1] + (bbox[3] - bbox[1])/2.0\n\t\t\tprint center\n\t\t\tim[center[1]-20:center[1]+20,center[0]-20:center[0]+20,:] = [0,0,255]\n\n\t\t\tcenters.append(center)\n\t\t\t\n\t\treturn centers,im","def load_drawings(self, contours, append=False):\n\n CONTOUR_IS_INTERPOLATED = 1\n\n if not append:\n self.drawings = defaultdict(list)\n\n endorser_contour_lookup = defaultdict(set)\n for cnt_id, contour in contours.iterrows():\n for editor in set([edit['username'] for edit in contour['edits']]):\n endorser_contour_lookup[editor].add(cnt_id)\n endorser_contour_lookup[contour['creator']].add(cnt_id)\n\n grouped = contours.groupby('section')\n\n for i_or_sec, group in grouped:\n # if i_or_sec not in self.data_feeder.sections: continue ## IS TIHS NECESSARY ?\n for contour_id, contour in group.iterrows():\n vertices = contour['vertices']\n contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\n self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\n linecolor='r', section=i_or_sec, type=contour_type,\n side=contour['side'],\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else False,\n side_manually_assigned=contour['side_manually_assigned'],\n edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'],\n contour_id=contour_id)\n\n # grouped = contours.groupby('position')\n #\n # for i_or_sec, group in grouped:\n # for contour_id, contour in group.iterrows():\n # vertices = contour['vertices']\n # contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\n # self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\n # linecolor='r', index=i_or_sec, type=contour_type,\n # side=contour['side'],\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else True,\n # edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'])","def find_contours(thresh):\n thresh = thresh.astype(np.uint8)\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n\n # filter outer contours\n filtered_cont = []\n for i in range(len(contours)):\n if hierarchy[0, i, 3] == NO_PARENT:\n filtered_cont.append(contours[i])\n\n return filtered_cont","def detectBlocksInDepthImage(self):\n depth_range_dict = {'1':[173,178],'2':[169,172],'3':[165,169],'4':[159,163],'5':[156,158],'6':[147,155],'7':[139,146],'8':[132,138]}\n depth_frame = self.DepthFrameRaw\n rgb_frame = self.VideoFrame\n rgb_frame = cv2.resize(rgb_frame, (640,480))\n depth_frame = cv2.resize(depth_frame, (640, 480))\n np.clip(depth_frame,0,2**10 - 1,depth_frame)\n depth_frame >>= 2\n depth_frame = depth_frame.astype(np.uint8)\n filt_block = []\n for k,v in depth_range_dict.items():\n thresh = cv2.inRange(depth_frame,v[0],v[1])\n cv2.imwrite(\"/home/student/armlab-w20/log/img.jpeg\", thresh)\n _ , contours, _ = cv2.findContours(thresh, 1, 2)\n for cnt in contours:\n area = cv2.contourArea(cnt)\n if area > 400 and area < 700:\n block = []\n rect = cv2.minAreaRect(cnt)\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n color = self.determine_color(rgb_frame, box)\n org = (box[0][0], box[0][1])\n rgb_frame = cv2.putText(rgb_frame, color, org,cv2.FONT_HERSHEY_SIMPLEX , 0.5 ,(0,0,0),2, cv2.LINE_AA)\n rgb_frame = cv2.drawContours(rgb_frame,[box],0,(0,0,0),0)\n self.VideoFrame = rgb_frame\n block.append(box)\n block.append(int(k))\n block.append(color)\n filt_block.append(block)\n return filt_block","def watershed(self, debug=False):\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg, sure_fg)\n ret, markers = cv2.connectedComponents(sure_fg)\n markers += 1\n markers[unknown == 255] = 0\n markers = cv2.watershed(self.img, markers)\n self.add_color(markers)\n if debug:\n cv2.imshow(\"fg\", unknown)\n cv2.imshow(\"op\", opening)\n cv2.imshow(\"o3\", sure_bg)","def analyze(self, frame: np.ndarray, debug: bool) -> Tuple[float, float]:\n gate_center = self.output_class(250, 250)\n filtered_frame = self.combined_filter(frame, display_figs=False)\n filtered_frame_copies = [filtered_frame for _ in range(3)]\n stacked_filter_frames = np.concatenate(filtered_frame_copies, axis=2)\n mask = cv.inRange(\n stacked_filter_frames, np.array([100, 100, 100]), np.array([255, 255, 255])\n )\n contours = cv.findContours(mask, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)[-2]\n if len(contours) > 0:\n contours.sort(reverse=True, key=self.findStraightness)\n cnts = contours[:2]\n rects = [cv.minAreaRect(c) for c in cnts]\n centers = [np.array(r[0]) for r in rects]\n boxpts = [cv.boxPoints(r) for r in rects]\n box = [np.int0(b) for b in boxpts]\n for b in box:\n cv.drawContours(stacked_filter_frames, [b], 0, (0, 0, 255), 5)\n if len(centers) >= 2:\n gate_center = (centers[0] + centers[1]) * 0.5\n if self.__ema is None:\n self.__ema = gate_center\n else:\n self.__ema = (\n self.__alpha * gate_center + (1 - self.__alpha) * self.__ema\n )\n gate_center = (int(self.__ema[0]), int(self.__ema[1]))\n # TODO: clean this up via hyperparam or move to gate center algo\n # if len(self.__past_centers) < 15:\n # \tself.__past_centers += [gate_center]\n # else:\n # \tself.__past_centers.pop(0)\n # \tself.__past_centers += [gate_center]\n # gate_center = sum(self.__past_centers) / len(self.__past_centers)\n # gate_center = (int(gate_center[0]), int(gate_center[1]))\n cv.circle(stacked_filter_frames, gate_center, 10, (0, 255, 0), -1)\n\n if debug:\n return (gate_center[0], gate_center[1]), (frame, stacked_filter_frames)\n return (gate_center[0], gate_center[1])","def consolidate_instances_all_way(self, stats, segmented_instances):\n\n img = np.zeros(segmented_instances.shape).astype(np.uint8)\n\n #get all pixel labels in the segmented_instances mask\n segment_numbers = np.unique(segmented_instances)\n\n # remove the background label\n segment_numbers=segment_numbers[segment_numbers!=0]\n\n end_points = np.empty((len(segment_numbers),),dtype=np.object_)\n end_points.fill([])\n\n for curr_segment in segment_numbers:\n idx=[]\n i=curr_segment-1\n if curr_segment!=0:\n #Show all segments of curr_segment. Only useful to view results\n img[segmented_instances== curr_segment]= 255\n #get indeces of the segments for curr_segment\n idx = np.argwhere(segmented_instances == curr_segment)\n if len(idx>0):\n end_points[i]= self._get_end_points(segmented_instances, i, \\\n stats, idx)\n # add point markers and lines connecting each end point to centroid.\n # useful only to view results\n \"\"\"for pt_num, pt in enumerate(end_points[i]):\n cv2.circle(img, (pt[0],pt[1]), 3, 100, -1)\n cv2.line(img,(pt[0],pt[1]),\\\n (stats['centroid'][i,0], stats['centroid'][i,1]),150,2)\n cv2.circle(img, (stats['centroid'][i,0], stats['centroid'][i,1]), 3, 200, -1)\"\"\"\n #self.showme(img, 'line '+str(i))\n\n # cluster segments into stem instances\n cluster_mask, clustered_instances = self._cluster_segments_all_way(segmented_instances,\\\n segment_numbers, end_points, \\\n stats)\n\n #put all instances in one layer\n if len(cluster_mask)>0:\n single_layer_cluster_mask=np.zeros(cluster_mask[0].shape)\n for i in xrange(len(cluster_mask)):\n single_layer_cluster_mask[cluster_mask[i]>0]= i+1\n\n # self.showObjects(clustered_instances);\n return single_layer_cluster_mask, clustered_instances","def get_contour(atom_list):\n initial = [atom for atom in atom_list if ((0 < len(identify_bonds(atom, atom_list)) < 3) and (check_connected(atom, identify_bonds(atom, atom_list)) == False))]\n \n extra_1 = []\n for atom in atom_list:\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\n for i in neighbours:\n neighbours2 = [bond[0] for bond in identify_bonds(i, atom_list)]\n for j in neighbours2:\n if j in initial:\n extra_1.append(atom)\n\n extra_2 = []\n for atom in atom_list:\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\n check = 0\n for i in neighbours:\n if i in initial:\n check += 1\n if ((check == 2) and (atom not in initial)):\n extra_2.append(atom) \n return (initial + extra_1 + extra_2)","def get_patch_centers(self):\n rows, cols = np.where(self.inv_overlap_mask)\n patch_centers = tuple(zip(rows, cols))\n # diff = np.diff(patch_centers)\n # ind_stop_cont = np.where(np.abs(np.diff(np.reshape(diff, diff.shape[0]))) > 1)[0][0]\n self.patch_centers = patch_centers[:: self.sampling_int // 2]\n print(\"# of samples: {}\".format(len(self.patch_centers)))","def get_descriptors(image,filtered_coords,wid=5):\n desc = []\n for coords in filtered_coords:\n patch = image[coords[0]-wid:coords[0]+wid+1,\n coords[1]-wid:coords[1]+wid+1].flatten()\n desc.append(patch)\n return desc","def figure_detection_border(self, gray_img, binary_img, frame_position, time_stamp, contours_list_title):\n img = gray_img.copy()\n height, width = gray_img.shape\n # # edge detection\n edges = cv2.Canny(img, 31, 180, apertureSize=3)\n # contour detection\n contours = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[1]\n # default values\n table_x = -1\n table_y = -1\n # minimum values that a figure can have\n table_w = 450\n table_h = 200\n\n for contour in contours:\n # get rectangle bounding contour\n [x, y, w, h] = cv2.boundingRect(contour)\n # Don't plot small false positives that aren't text\n if w > table_w and h > table_h:\n table_x = x\n table_y = y\n table_h = h\n table_w = w\n if not table_x == -1 and not table_y == -1 and not table_h > height - 50:\n\n if self.first:\n # save cropped figure\n cv2.imwrite(\"figures/\" + str(frame_position) + \".jpg\",\n gray_img[table_y:table_y + table_h, table_x:table_x + table_w])\n\n self.first = False\n self.previous_h = table_h\n self.previous_w = table_w\n # add details to frame details dictionary\n # method call\n self.ops_obj.add_to_dict_from_figure(frame_position, time_stamp)\n # method call - to get text around the figure\n self.text_extraction_obj.extract_text_string(binary_img[0:table_y, 0:width], frame_position, time_stamp,\n contours_list_title)\n\n else:\n if self.previous_w == table_w or self.previous_h == table_h:\n # this scenario is not valid for detect relevant borders\n pass\n else:\n # save cropped figure\n cv2.imwrite(\"figures/\" + str(frame_position) + \".jpg\",\n gray_img[table_y:table_y + table_h, table_x:table_x + table_w])\n\n self.previous_h = table_h\n self.previous_w = table_w\n # add details to frame details dictionary\n # method call\n self.ops_obj.add_to_dict_from_figure(frame_position, time_stamp)\n # method call - to get text around the figure\n self.text_extraction_obj.extract_text_string(binary_img[0:table_y, 0:width], frame_position,\n time_stamp, contours_list_title)\n else:\n # method call\n self.borderless_figure_detector_obj.figure_detection_borderless(gray_img, binary_img,\n frame_position, time_stamp,\n contours_list_title)","def get_integral_descriptors(image,filtered_coords,wid=5):\n desc = []\n for coords in filtered_coords:\n patch = image[coords[0]-wid:coords[0]+wid+1,\n coords[1]-wid:coords[1]+wid+1]\n desc.append(patch)\n return desc","def get_contours(img):\n contours, hierarchy = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours, hierarchy[0]","def enumerate_detector(det, thresholds, shot_ok=None, tiles=None, nimages=np.inf, startimg=0, stopimg=np.inf, correction=False, progress=True):\n global terminated\n Ncorrect = 64\n correctionphotonthres = 3000\n if not isinstance(det, h5py.Group):\n raise TypeError('det should be a h5 group')\n if tiles is None:\n tiles = [k for k in det.keys() if 'tile' in k]\n else:\n newtiles = []\n for t in tiles:\n if t in det:\n newtiles.append(t)\n elif f'tile{t}' in det:\n newtiles.append(f'tile{t}')\n else:\n raise KeyError(f'tile {t} not found')\n tiles = newtiles\n datanames = [(f'{det.name}/{t}/data') for t in tiles]\n filename = det.file.filename\n\n nshots = det[f'{tiles[0]}/data'].shape[0]\n startimg = int(np.clip(startimg, 0, nshots))\n stopimg = int(np.clip(stopimg, startimg, nshots))\n tileshape = det[f'{tiles[0]}/data'].shape[1:]\n correctmask = [correctionmask(det[t]['absfft0/mean'], Ncorrect) for t in tiles]\n if shot_ok is None:\n shot_ok = np.ones(nshots, np.bool)\n ind_filtered = 0\n data = np.zeros((len(tiles), *tileshape))\n willread = np.copy(shot_ok)\n willread[:startimg] = False\n willread[stopimg:] = False\n with datasetreader(datanames, filename, sizecache=10, willread=willread) as reader:\n\n for ind_orig in range(startimg, stopimg):\n if not shot_ok[ind_orig]:\n continue\n if ind_filtered >= nimages or terminated != 0:\n return\n if progress and ind_filtered % 10 == 0:\n print(ind_filtered, end=' ', flush=True)\n\n for it, t in enumerate(tiles):\n cdat = np.array(reader[ind_orig, it], dtype=np.float, order='C')\n if correction:\n correct(cdat, correctionphotonthres, Ncorrect, correctmask[it])\n data[it, ...] = cdat\n ev, number, scatter = getstats(data, thresholds)\n\n yield (ind_filtered, ind_orig, data, ev, number, scatter)\n\n ind_filtered += 1","def get_cntr_points(self, contour, img_size):\n res_arr = []\n # for each row\n for row in range(img_size):\n tmp_arr = []\n # for each column\n for col in range(img_size):\n # if point in contour\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\n # add point to current line\n tmp_arr.append([row,col])\n if len(tmp_arr):\n # add current line to result array\n res_arr.append(tmp_arr)\n return res_arr","def GetMatchedSubContourLists(\n scListRef,\n scList,\n allValsByFrame,\n orderOfSCsByValue,\n splitLength=1,\n fixedNumInteriorPoints=None,\n):\n ## NOT DONE! MERGE LATER??\n return simplifiedSCListRef, simplifiedSCList","def findings_2_idx(findings, corner_2_idx, funcx, funcy):\n idx = []\n for finding in findings:\n x, y = finding\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\n idx.extend([corner_2_idx(c) for c in mesh])\n\n return np.unique(idx)","def draw_all_position_patterns(img, found, contours):\n draw_img = img.copy()\n for i in found:\n rect = cv2.minAreaRect(contours[i])\n box = np.int0(cv2.cv.BoxPoints(rect))\n cv2.drawContours(draw_img, [box], 0, (0, 0, 255), 2)\n show(draw_img)","def enumerate_detector(det, thresholds, shot_ok=None, tiles=None, nimages=np.inf, stats=True, correction=False, progress=True, photonfunction=None):\n Ncorrect = 64\n correctionphotonthres = 3000\n if not isinstance(det, h5py.Group):\n raise TypeError('det should be a h5 group')\n if tiles is None:\n tiles = [k for k in det.keys() if 'tile' in k]\n else:\n newtiles = []\n for t in tiles:\n if t in det:\n newtiles.append(t)\n elif f'tile{t}' in det:\n newtiles.append(f'tile{t}')\n else:\n raise KeyError(f'tile {t} not found')\n tiles = newtiles\n multitiles = not (len(tiles) == 1 and 'data' in det[tiles[0]])\n mincorners = []\n maxcorners = []\n rots = []\n datanames = []\n filename = det.file.filename\n nshots = det[f'{tiles[0]}/data'].shape[0]\n correctmask = []\n for t in tiles:\n d = det[t]\n offset = np.rint(d.attrs['detector_tile_position_in_pixels'])\n rot = int(d.attrs['detector_rotation_steps'][0])\n rots.append(rot)\n n, a, b = d['data'].shape\n if n != nshots:\n raise ValueError('tiles should have same number of shots')\n shape = ((a, b), (-b, a), (-a, -b), (b, -a))[rot % 4]\n corners = (offset, (shape + offset))\n mincorners.append(np.min(corners, axis=0))\n maxcorners.append(np.max(corners, axis=0))\n datanames.append(f'{d.name}/data')\n if correction:\n correctmask.append(correctionmask(det[t]['absfft0/mean'], Ncorrect))\n\n globaloffset = np.floor(np.min(mincorners, axis=0)).astype(int)\n extent = [fastlen(x) for x in (np.ceil(np.max(maxcorners, axis=0)) - globaloffset)]\n startx, starty = [list(s) for s in (np.floor(mincorners - globaloffset).astype(int)).T]\n\n if shot_ok is None:\n shot_ok = np.ones(nshots, np.bool)\n assembled = np.zeros(extent, np.float64)\n global terminated\n ind_filtered = 0\n with datasetreader(datanames, filename, willread=shot_ok) if multitiles else arrayreader(det[tiles[0]]['data']) as reader:\n for ind_orig in range(nshots):\n if not shot_ok[ind_orig]:\n continue\n if ind_filtered >= nimages or terminated != 0:\n return\n if progress and ind_filtered % 100 == 0:\n print(ind_filtered, end=' ', flush=True)\n\n for t in range(len(tiles)):\n if multitiles:\n tile = np.asarray(reader[ind_orig, t], order='C', dtype=np.float64)\n if correction:\n correct(tile, correctionphotonthres, Ncorrect, correctmask[t], rots[t], assembled, startx[t], starty[t])\n else:\n place(tile, rots[t], assembled, startx[t], starty[t])\n else:\n if correction:\n tile = np.asarray(reader[ind_orig], order='C', dtype=np.float64)\n correct(tile, correctionphotonthres, Ncorrect, correctmask[t], rots[t], assembled, startx[t], starty[t])\n else:\n assembled = np.asarray(np.rot90(reader[ind_orig], rots[t]), order='C', dtype=np.float64)\n \n\n \n numberfromfunc = photonfunction(assembled) if photonfunction is not None else None\n if thresholds is not None:\n if stats:\n ev, number, scatter = getstats(assembled, thresholds)\n yield (ind_filtered, ind_orig, np.copy(assembled), ev, number, scatter, numberfromfunc)\n else:\n number = getphotons(assembled, thresholds)\n yield (ind_filtered, ind_orig, np.copy(assembled), None, number, None, numberfromfunc)\n else: \n yield (ind_filtered, ind_orig, np.copy(assembled), None, None, None, numberfromfunc)\n\n \n ind_filtered += 1","def boundary_contour(self, time):\n ti = np.where(time == self.times)[0][0]\n image_mask = binary_erosion(binary_fill_holes(binary_dilation(self.masks[ti])))\n padded_mask = np.pad(image_mask, 1, 'constant', constant_values=0)\n c_out = find_contours(padded_mask, level=0.5, fully_connected=\"high\")\n x_cont = self.x[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\n y_cont = self.y[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\n ordered_coords = np.vstack([x_cont, y_cont])\n return ordered_coords","def find_targets(contours, frame):\n # If there aren't any contours present, return frame without drawing\n if len(contours) == 0:\n return frame\n # Copy frame, TODO why do we need to do this?\n image = frame.copy()\n screen_height, screen_width, _ = image.shape;\n # TODO: Why subtract?\n center_x = screen_width / 2 - .5\n center_y = screen_height / 2 - .5\n # List for storing found targets\n targets = []\n\n if len(contours) >= 2:\n # Sort contours in descending order by size\n contours.sort(key=lambda contour: cv2.contourArea(contour), reverse=True)\n\n valid_contours = []\n for contour in contours:\n # Calculate areas of contour\n contour_area = cv2.contourArea(contour)\n if contour_area >= MIN_CONTOUR_SIZE:\n # Get moments of contour for centroid calculations\n moments = cv2.moments(contour)\n # Find centroid of contour\n if moments[\"m00\"] != 0:\n cx = int(moments[\"m10\"] / moments[\"m00\"])\n cy = int(moments[\"m01\"] / moments[\"m00\"])\n else:\n cx, cy = 0, 0\n\n ### CALCULATE CONTOUR ROTATION BY FITTING ELLIPSE ###\n rotation = get_ellipse_rotation(image, contour)\n\n ### DRAW CONTOUR ###\n # Draw white circle at center of contour\n cv2.circle(image, (cx, cy), 6, (255, 255, 255))\n\n # Draw contour in green\n cv2.drawContours(image, [contour], 0, (0, 200, 0), 1)\n\n # Append important info to array\n valid_contours.append({\"cx\": cx, \"cy\": cy, \"rotation\": rotation})\n\n # Sort array based on coordinates (left to right) to make sure contours are adjacent\n valid_contours.sort(key=lambda contour: contour[\"cx\"])\n\n # Find targets from contours\n for i in range(len(valid_contours) - 1):\n # Check rotation of adjacent contours\n tilt_left = valid_contours[i][\"rotation\"]\n tilt_right = valid_contours[i + 1][\"rotation\"]\n\n # Contour coordinates\n cx_left = valid_contours[i][\"cx\"]\n cx_right = valid_contours[i + 1][\"cx\"]\n cy_left = valid_contours[i][\"cy\"]\n cy_right = valid_contours[i + 1][\"cy\"]\n\n # If contour angles are opposite\n # Negative tilt -> Rotated to the right\n # NOTE: if using rotated rect (min area rectangle), negative tilt means rotated to left\n # If left contour rotation is tilted to the left then skip iteration\n # If right contour rotation is tilted to the right then skip iteration\n if (len(valid_contours) == 2) or (np.sign(tilt_left) != np.sign(tilt_right) and\n not (tilt_left > 0 and cx_left < cx_right or tilt_right > 0 and cx_right < cx_left)):\n\n target_cx = (cx_left + cx_right) / 2\n target_cy = (cy_left + cy_right) / 2\n\n target_yaw = calculate_yaw(target_cx, center_x)\n target_pitch = calculate_pitch(target_cy, center_y)\n\n targets.append({\"cx\": target_cx,\n \"cy\": target_cy,\n \"yaw\": target_yaw,\n \"pitch\": target_pitch})\n\n # Check if there are targets seen\n if len(targets) > 0:\n # Get target with smallest yaw\n nearest_target = min(targets, key=lambda target: math.fabs(target[\"yaw\"]))\n # Write yaw of target in corner of image\n cv2.putText(image, \"Yaw: %.3f\" % nearest_target[\"yaw\"], (1, 12), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255))\n # Draw line at center of target\n cv2.line(image, (int(nearest_target[\"cx\"]), screen_height), (int(nearest_target[\"cx\"]), 0), (255, 0, 0), 1)\n # Draw line at center of screen\n cv2.line(image, (round(center_x), screen_height), (round(center_x), 0), (255, 255, 255), 1)\n\n # Send our final data to NetworkTables\n table.putBoolean(\"target_present\", True)\n table.putNumber(\"targets_seen\", len(targets))\n table.putNumber(\"target_yaw\", nearest_target[\"yaw\"])\n table.putNumber(\"target_pitch\", nearest_target[\"pitch\"])\n else:\n table.putBoolean(\"target_present\", False)\n table.putNumber(\"targets_seen\", 0)\n table.putNumber(\"target_yaw\", 0)\n table.putNumber(\"target_pitch\", 0)\n table.putNumber(\"target_distance\", 0)\n\n return image","def _check_intrusion(self, detections):\n width, height = self.frame_size\n\n results = []\n for i in range(len(detections)):\n (bboxes, scores, classes, num_candidates) = detections[i]\n\n in_roi_cands = {}\n for j in range(int(num_candidates[0])):\n # Check if score passes the threshold.\n if scores[0][j] < self.detect_threshold:\n continue\n # Check if the object in in the trigger list.\n # XXX: Is it posssible to generate index that is not in the\n # category_index list?\n try:\n label = self._category_index[int(classes[0][j])]\n except KeyError:\n continue\n else:\n if label not in self.triggers:\n continue\n # Check whether the object's bbox is in roi or not.\n ymin, xmin, ymax, xmax = bboxes[0][j]\n unnormalized_bbox = (xmin * width, ymin * height,\n xmax * width, ymax * height)\n if self._is_in_roi(unnormalized_bbox):\n if not bool(in_roi_cands):\n # This is the first detected object candidate\n in_roi_cands = {\"bboxes\": [], \"scores\": [], \"labels\": []}\n in_roi_cands[\"bboxes\"].append(bboxes[0][j].tolist())\n in_roi_cands[\"scores\"].append(scores[0][j].tolist())\n in_roi_cands[\"labels\"].append(label)\n results.append(in_roi_cands)\n return results","def getValidNeighborsInformation(self, index, distances = False,coordinates=False,figuresOfMerit=False ):\n try:\n p = self.get_crds(index)\n new_pnts = na.reshape(\\\n na.inner(self.d124,\\\n na.array([p[0],p[1],p[2],1])),\\\n (124,3))\n cx = new_pnts[:,0]\n cy = new_pnts[:,1]\n cz = new_pnts[:,2]\n ind = na.nonzero((cx >=0 )*( cx < self.dim[0])*\\\n (cy >=0 )*( cy < self.dim[1])*\\\n (cz >=0 )*( cz < self.dim[2]))[0]\n cx = na.take(cx,ind)\n cy = na.take(cy,ind)\n cz = na.take(cz,ind)\n dst = na.take(self.ds124,ind)\n \n tind = self.get_ind(cx,cy,cz)\n \n # only keep points in current label value of mask\n ind = self.getValidIndicies(tind)\n \n # now accumulate optional results\n inds = na.take(tind,ind)\n\n indc = [self.maskMap[i] for i in inds]\n return indc\n except Exception as error:\n print(\"failed in getValidNeighborsInformation() \", error)","def locate_tracker(self, debug):\n\n # tmp_image =\n # tmp_image = cv2.GaussianBlur(self.frame, (11, 11), 0) # Experiment with this\n\n hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) # Convert to HSV Color Space. This is temporary for testing using colored objects)\n\n mask = cv2.inRange(hsv, self.hueLower, self.hueUpper)\n\n try:\n mask = cv2.inRange(hsv, self.hueLower2, self.hueUpper2) + mask\n except AttributeError:\n pass\n\n mask = cv2.erode(mask, None, iterations=2)\n mask = cv2.dilate(mask, None, iterations=2)\n\n if debug:\n tmpMask = imutils.resize(mask, width=1000, height=1000)\n cv2.imshow(\"mask\", tmpMask)\n\n\n # find contours in the mask and initialize the current (x, y) center of the object\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\n center = None\n\n # only proceed if at least one contour was found\n if len(cnts) > 0:\n # find the largest contour in the mask, then use\n # it to compute the minimum enclosing circle and\n # centroid\n c = max(cnts, key=cv2.contourArea)\n\n ((x, y), radius) = cv2.minEnclosingCircle(c)\n M = cv2.moments(c)\n center = (int(M[\"m10\"] / M[\"m00\"]), int(M[\"m01\"] / M[\"m00\"]))\n\n # only proceed if the radius meets a minimum size\n # if radius > 10:\n # # draw the circle and centroid on the frame,\n # # then update the list of tracked points\n # cv2.circle(frame, (int(x), int(y)), int(radius),\n # (0, 255, 255), 2)\n # cv2.circle(frame, center, 5, (0, 0, 255), -1)\n if debug:\n cv2.drawContours(self.frame, c, -1, (0, 255, 0), 20)\n return center, radius\n # update the points queue\n cv2.imshow(\"mask\", imutils.resize(mask, width=1000, height=1000))\n cv2.imshow(\"frame\", imutils.resize(self.frame, width=1000, height=1000))\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n raise OpenCVError(\"Could not find tracker!\")\n\n # return (1, 1), 1","def fillHoles(img):\n out,contour,hierarchy = cv2.findContours(img,cv2.RETR_CCOMP,cv2.CHAIN_APPROX_NONE)\n i=0\n for cnt in contour:\n cv2.drawContours(img,contour,i,255,-1)\n i+=1\n return img","def compute_contour(ptr_array):\n hull = ConvexHull(ptr_array)\n contour_index = hull.vertices.tolist() # indices are ordered\n # contour_index = hull.simplices.flatten()\n # contour_index = list(set(contour_index))\n return contour_index"],"string":"[\n \"def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\\n orderOfSCsByValueByFrame = [\\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\\n ]\\n return scListByFrame, orderOfSCsByValueByFrame\",\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def getContours(img,iteration):\\n nP, IDrange = upDate(iteration)\\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\\n kernel = np.ones((nP, nP), np.uint8)\\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\\n contours = []\\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n if iteration == 2 :\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n elif iteration == 3:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\n return contours\",\n \"def get_contour_features(mask,selectcell=\\\"centered\\\"):\\r\\n \\r\\n #binarize image (everything above 0 becomes 1)\\r\\n mask = np.clip(mask,a_min=0,a_max=1)\\r\\n\\r\\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\\r\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\r\\n contours = list(contours)\\r\\n \\r\\n #in case there is no contour found, add a dummy contour\\r\\n if len(contours)==0:\\r\\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\\r\\n\\r\\n #Sort contours, longest first\\r\\n contours.sort(key=len,reverse=True)\\r\\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\\r\\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\\r\\n\\r\\n mu_origs = [cv2.moments(contour) for contour in contours]\\r\\n mu_hulls = [cv2.moments(hull) for hull in hulls]\\r\\n\\r\\n area_origs = [mu_orig[\\\"m00\\\"] for mu_orig in mu_origs]\\r\\n area_hulls = [mu_hull[\\\"m00\\\"] for mu_hull in mu_hulls]\\r\\n\\r\\n #drop events where area is zero\\r\\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \\r\\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\\r\\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\\r\\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\\r\\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\\r\\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\\r\\n \\r\\n \\r\\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n\\r\\n \\r\\n if selectcell == \\\"smooth\\\":\\r\\n #compute the area ratio (roughness of contour)\\r\\n area_ratio = np.array(area_hulls)/np.array(area_origs)\\r\\n #get the contour with minimum roughness (smooth contour)\\r\\n sorter = np.argsort(area_ratio) #smallest first\\r\\n\\r\\n if selectcell == \\\"centered\\\":\\r\\n #select contour that is closest to the center of the image. \\r\\n #In iPAC, cells are usually in the center.\\r\\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\\r\\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\\r\\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\\r\\n sorter = np.argsort(distances) #smallest first\\r\\n \\r\\n #sort values with respect to chosen metric (area_ratio or distance)\\r\\n contours = [contours[s] for s in sorter]\\r\\n hulls = [hulls[s] for s in sorter]\\r\\n pos_x = [pos_x[s] for s in sorter]\\r\\n pos_y = [pos_y[s] for s in sorter]\\r\\n mu_origs = [mu_origs[s] for s in sorter]\\r\\n area_origs = [area_origs[s] for s in sorter]\\r\\n area_hulls = [area_hulls[s] for s in sorter]\\r\\n \\r\\n # draw mask of the chosen contour\\r\\n mask = np.zeros_like(mask)\\r\\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\\r\\n\\r\\n hull = hulls[0]#[0:n_contours]\\r\\n pos_x = pos_x[0]\\r\\n pos_y = pos_y[0] \\r\\n mu_orig = mu_origs[0]#[0:n_contours]\\r\\n area_orig = area_origs[0]#[0:n_contours]\\r\\n area_hull = area_hulls[0]#[0:n_contours]\\r\\n \\r\\n if area_orig>0:\\r\\n area_ratio = area_hull/area_orig\\r\\n else:\\r\\n area_ratio = np.nan\\r\\n\\r\\n arc = cv2.arcLength(hull, True) \\r\\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\\\"m00\\\"]) / arc\\r\\n\\r\\n\\r\\n dic = {\\\"mask\\\":mask,\\\"pos_x\\\":pos_x,\\\"pos_y\\\":pos_y,\\\"area_orig\\\":area_orig,\\\"area_hull\\\":area_hull,\\\\\\r\\n \\\"area_ratio\\\":area_ratio,\\\"circularity\\\":circularity}\\r\\n return dic\",\n \"def trackCells(self): \\n # variable initialization\\n self.t_appearance = []\\n self.id_seq = []\\n self._n_cell = 0\\n self.division = []\\n self.dict_track = {}\\n\\n t_ini = self.configs[self.TIME_INI_KEY]\\n\\n # Initialize points with first frame\\n self.dict_track[0] = {}\\n for id_num in self.pos[0][4]:\\n self._addTrack(0, id_num)\\n\\n # From frame=1 on...\\n for t, data_t in enumerate(self.pos[1:]):\\n self.dict_track[t+1] = {}\\n # check all the cells in this frame\\n for cell, id_num in enumerate(data_t[4]):\\n parent = data_t[5][cell]\\n if parent == -1:\\n # new track\\n self._addTrack(t+1, id_num)\\n elif parent in self.dict_track[t]:\\n # check if parent is in the previous list\\n index = self.dict_track[t][parent]\\n if index in self.dict_track[t+1].values():\\n # then we have cell division, and we monitor the child separarely\\n self._addDivision(t+1, id_num, index)\\n else:\\n # cell continues in the same track\\n self.id_seq[index].append(id_num)\\n self.dict_track[t+1][id_num] = index\\n else:\\n # weird things happened!\\n print(\\\"Warning! Time %s, Cell ID %s lost track\\\"%(str(t+t_ini), str(id_num)))\\n\\n\\n # all track indexes are included, no filter (yet)\\n self.index_filter = list(range(len(self.id_seq)))\\n\\n return self.id_seq, self.t_appearance\",\n \"def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\\n return [\\n [sc.cVLS() for sc in scList]\\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\\n ]\",\n \"def find_original_contours(self):\\r\\n\\r\\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\\r\\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\\r\\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\\r\\n int(self.cell_size), 5)\\r\\n self.thresh_orig = 255 - self.thresh_invert\\r\\n\\r\\n # Find the contours of the image. Each contour should correspond to a cell\\r\\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\\r\\n for block in orig_contours:\\r\\n area = cv2.contourArea(block)\\r\\n\\r\\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\\r\\n if area < self.min_cell_size:\\r\\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)\",\n \"def take_contours(self):\\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]\",\n \"def sort_filtered_contours(self):\\r\\n\\r\\n # Get the contours again\\r\\n invert = 255 - self.thresh_invert\\r\\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\\r\\n\\r\\n # Make sure that they're within the correct range for size\\r\\n # If too small, it is probably noise; if too large, then should be things around the grid\\r\\n for i, c in enumerate(real_contours, 1):\\r\\n contour_area = cv2.contourArea(c)\\r\\n if self.min_cell_size < contour_area < self.max_cell_size:\\r\\n self.good_contours.append(c)\\r\\n\\r\\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\\r\\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\\r\\n\\r\\n # Sort the contours from top to bottom\\r\\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\\\"top-to-bottom\\\")\\r\\n\\r\\n # We then sort each row from left to right\\r\\n row = []\\r\\n for i, c in enumerate(half_sorted_contours, 1):\\r\\n row.append(c)\\r\\n if i % self.board_dimension == 0:\\r\\n (full_sorted_contours, _) = contours.sort_contours(row, method=\\\"left-to-right\\\")\\r\\n self.game_board_contours.append(full_sorted_contours)\\r\\n row = []\",\n \"def instance_contours(gti):\\n # TODO: move to somewhere better\\n import cv2\\n\\n rc_locs = np.where(gti > 0)\\n grouped_cc_rcs = util.group_items(\\n np.ascontiguousarray(np.vstack(rc_locs).T),\\n gti[rc_locs], axis=0\\n )\\n\\n def bounding_box(rcs):\\n rc1 = rcs.min(axis=0)\\n rc2 = rcs.max(axis=0)\\n return rc1, rc2\\n\\n # slice out a bounding region around each instance, detect the contour and\\n # then offset it back into image coordinates\\n grouped_contours = {}\\n for label, rcs in grouped_cc_rcs.items():\\n rc1, rc2 = bounding_box(rcs)\\n sl = (slice(rc1[0], rc2[0] + 2), slice(rc1[1], rc2[1] + 2))\\n submask = (gti[sl] == label).astype(np.uint8)\\n\\n xy_offset = rc1[::-1]\\n offset = xy_offset + [-2, -2]\\n\\n border = cv2.copyMakeBorder(submask, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=0 )\\n _, contors, hierarchy = cv2.findContours(border, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE,\\n offset=tuple(offset))\\n \\\"\\\"\\\"\\n offset = [0, 0]\\n BGR_GREEN = (0, 255, 0)\\n x = np.ascontiguousarray(util.ensure_alpha_channel(submask)[:, :, 0:3]).astype(np.uint8)\\n draw_img = cv2.drawContours(\\n image=x, contours=contors,\\n contourIdx=-1, color=BGR_GREEN, thickness=2)\\n \\\"\\\"\\\"\\n # note when len(contours > 1, there is a hole in the building)\\n # assert len(contors) == 1\\n grouped_contours[label] = contors\\n return grouped_contours\",\n \"def get_contours(self):\\n depth_image = capture_images((self.w,self.h))\\n\\n thresh = threshold_depth_image(depth_image, min_depth=config.min_depth, max_depth=config.max_depth, threshold=config.min_depth, kernel=self.kernel)\\n\\n # extract contours\\n im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\\n if hierarchy!=None:\\n hierarchy = hierarchy[0]\\n return contours, hierarchy\\n else:\\n return [], []\",\n \"def detect_contours(self):\\r\\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\r\\n return [DbugContour(cv_contour=contour) for contour in contours]\",\n \"def nondetects(self, masked=False):\\r\\n grd = self.grd\\r\\n xnd = []\\r\\n ynd = []\\r\\n ncells = len(grd.cells['depth'])\\r\\n non_detects_i_tr = np.zeros(ncells, np.int32)\\r\\n if masked:\\r\\n not_flagged = np.where(self.rec_track.flagged==0)[0]\\r\\n rec_track = self.rec_track[not_flagged]\\r\\n rec_seg = self.make_segments(set_depth=True, \\r\\n input_rec_track=rec_track)\\r\\n else:\\r\\n rec_seg = self.rec_seg\\r\\n for nr, rseg in enumerate(rec_seg):\\r\\n seg = rec_seg[nr]\\r\\n dt = seg.dt\\r\\n if dt > dt_signal+1:\\r\\n t1 = seg.t1\\r\\n t2 = seg.t2\\r\\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\\r\\n x1 = seg.x1\\r\\n x2 = seg.x2\\r\\n y1 = seg.y1\\r\\n y2 = seg.y2\\r\\n dx_nd = (x2 - x1)/float(nint+1)\\r\\n dy_nd = (y2 - y1)/float(nint+1)\\r\\n if nint < 120: # 10 minute cutoff for nondetect filling\\r\\n xint = [x1 + n*dx_nd for n in range(1,nint)]\\r\\n yint = [y1 + n*dy_nd for n in range(1,nint)]\\r\\n xnd = xnd + xint\\r\\n ynd = ynd + yint\\r\\n\\r\\n for nd in range(len(xnd)):\\r\\n xy = [xnd[nd], ynd[nd]]\\r\\n i = grd.select_cells_nearest(xy)\\r\\n if (i is not None) and (i >= 0):\\r\\n non_detects_i_tr[i] += 1\\r\\n\\r\\n return non_detects_i_tr\",\n \"def getMostContour(img,svm,knn,filterArr,digits,wThresh,hThresh):\\r\\n # append the filter to filter array, this approach is used in case of \\r\\n # multiple filter methods would be used.\\r\\n counts = []\\r\\n # iterare through every filter\\r\\n for flt in filterArr:\\r\\n # copy the image so we don't draw on same image\\r\\n flt_img = img.copy()\\r\\n last_img = img.copy()\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh) \\r\\n if not digits:\\r\\n flt_contour,cntfound_fltr = drawcntMap(img.copy(),flt,wThresh,hThresh)\\r\\n flt_contour_map = []\\r\\n labels = []\\r\\n for crop,(x,y,w,h),contour in cropNwriteBBs(img,cntfound_fltr):\\r\\n #crop = np.array(crop,dtype='float32')\\r\\n crop = cv2.cvtColor(crop,cv2.COLOR_BGR2GRAY)\\r\\n crop = cv2.resize(crop,(25,25))\\r\\n # winSize is the size of the image cropped to an multiple of the cell size\\r\\n hog_fts = hog.compute(crop)\\\\\\r\\n .reshape(n_cells[1] - block_size[1] + 1,\\r\\n n_cells[0] - block_size[0] + 1,\\r\\n block_size[0], block_size[1], nbins) \\\\\\r\\n .transpose((1, 0, 2, 3, 4))\\r\\n hog_fts = np.resize(hog_fts.flatten(),(1,576))\\r\\n # make the resulted crop same type with the trained values\\r\\n hog_fts.dtype = 'float32'\\r\\n # get predicted labels\\r\\n label_svm=svm.predict(hog_fts)[1]\\r\\n label_knn = knn.findNearest(hog_fts,k=5)[1]\\r\\n # label 10 is considered as 'not digit' or 'thrash'\\r\\n # so if predicted label is not 10, draw the bounding box\\r\\n if digits:\\r\\n if(label_svm!=10 and label_knn != 10 and label_svm!=11 and label_knn != 11):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n else:\\r\\n if(label_svm!=2 and label_knn != 2):\\r\\n flt_contour_map.append(contour)\\r\\n labels.append(str(label_knn[0])[1])\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n #cv2.putText(flt_img,str(label_knn[0])[1],(x,y),fontFace=cv2.FONT_HERSHEY_COMPLEX,fontScale=0.8,color=(0,0,255))\\r\\n last_cnt,last_labels = secondElimination(flt_contour_map,labels)\\r\\n for cnt in last_cnt:\\r\\n x,y,w,h = cv2.boundingRect(cnt)\\r\\n cv2.rectangle(flt_img,(x,y),(x+w,y+h),[0,255,0],2)\\r\\n #showWait(flt_img,'fltres')\\r\\n _,xx,res_boxes,_,_ = mergeBoundingBoxes(flt_img,last_cnt,last_labels)\\r\\n cnt = len(res_boxes)\\r\\n counts.append([cnt,flt_img,last_cnt,last_labels])\\r\\n # append resulted image and contours to an array\\r\\n counts = np.asarray(counts)\\r\\n # get the resulted image which contain more digits (bounding boxes)\\r\\n tmp = counts[:,0]\\r\\n resulted_img = counts[np.argmax(tmp),1]\\r\\n result_labels = counts[np.argmax(tmp),3]\\r\\n resulted_contour = counts[np.argmax(tmp),2]\\r\\n return resulted_contour,result_labels,resulted_img\",\n \"def getContours(frame):\\n contours, _ = cv2.findContours(frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def preprocessing(self, img):\\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def get_connected_components(img):\\n already_labeled = []\\n connected_components = []\\n pixel_queue = []\\n\\n def get_fg_neighbors(row,col):\\n neighbors = []\\n min_row = max(row-1,0)\\n max_row = min(row+1, len(img)-1)\\n min_col = max(col-1,0)\\n max_col = min(col+1, len(img[0])-1)\\n for r in xrange(min_row, max_row+1):\\n for c in xrange(min_col, max_col+1):\\n if img[r][c] == 1 and (r,c) not in already_labeled:\\n neighbors.append((r,c))\\n return neighbors\\n\\n for row in xrange(len(img)):\\n for col in xrange(len(img[0])):\\n if img[row][col] == 1 and (row,col) not in already_labeled:\\n already_labeled.append((row,col))\\n cc = []\\n cc.append((row,col))\\n pixel_queue.append((row,col))\\n while len(pixel_queue) > 0:\\n cur_pixel = pixel_queue[0]\\n pixel_queue = pixel_queue[1:]\\n neighbors = get_fg_neighbors(cur_pixel[0], cur_pixel[1])\\n already_labeled += neighbors\\n cc += neighbors\\n pixel_queue += neighbors\\n connected_components.append(cc)\\n return connected_components\",\n \"def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\\n\\n device += 1\\n\\n if len(np.shape(img)) == 3:\\n iy, ix, iz = np.shape(img)\\n else:\\n iy, ix, = np.shape(img)\\n\\n # get the break groups\\n\\n if nrow == 1:\\n rbreaks = [0, iy]\\n else:\\n rstep = np.rint(iy / nrow)\\n rstep1 = np.int(rstep)\\n rbreaks = range(0, iy, rstep1)\\n if ncol == 1:\\n cbreaks = [0, ix]\\n else:\\n cstep = np.rint(ix / ncol)\\n cstep1 = np.int(cstep)\\n cbreaks = range(0, ix, cstep1)\\n\\n # categorize what bin the center of mass of each contour\\n\\n def digitize(a, step):\\n if isinstance(step, int) == True:\\n i = step\\n else:\\n i = len(step)\\n for x in range(0, i):\\n if x == 0:\\n if a >= 0 and a < step[x + 1]:\\n return x + 1\\n elif a >= step[x - 1] and a < step[x]:\\n return x\\n elif a > step[x - 1] and a > np.max(step):\\n return i\\n\\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\\n coord = []\\n for i in range(0, len(roi_objects)):\\n m = cv2.moments(roi_objects[i])\\n if m['m00'] == 0:\\n pass\\n else:\\n cx = int(m['m10'] / m['m00'])\\n cy = int(m['m01'] / m['m00'])\\n # colbin = np.digitize(cx, cbreaks)\\n # rowbin = np.digitize(cy, rbreaks)\\n colbin = digitize(cx, cbreaks)\\n rowbin = digitize(cy, rbreaks)\\n a = (cx, cy, colbin, rowbin, i)\\n coord.append(a)\\n coord1 = np.array(coord, dtype=dtype)\\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\\n\\n # get the list of unique coordinates and group the contours with the same bin coordinates\\n\\n groups = []\\n for i, y in enumerate(coord2):\\n col = y[3]\\n row = y[2]\\n location = str(row) + ',' + str(col)\\n groups.append(location)\\n\\n unigroup = np.unique(groups)\\n coordgroups = []\\n\\n for i, y in enumerate(unigroup):\\n col = int(y[0])\\n row = int(y[2])\\n for a, b in enumerate(coord2):\\n if b[2] == col and b[3] == row:\\n grp = i\\n contour = b[4]\\n coordgroups.append((grp, contour))\\n else:\\n pass\\n\\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\\n\\n contours = roi_objects\\n grouped_contour_indexes = coordlist\\n\\n # Debug image is rainbow printed contours\\n\\n if debug == 'print':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n print_image(img_copy, (str(device) + '_clusters.png'))\\n\\n elif debug == 'plot':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n plot_image(img_copy)\\n\\n return device, grouped_contour_indexes, contours\",\n \"def contextualcull(cnts):\\n temp = []\\n actualout = []\\n indicesused = []\\n for cnt in cnts:\\n if cnt.area > CULL_MINIMUMS[cnt.spatialindex]:\\n temp.append(cnt)\\n if cnt.spatialindex not in indicesused:\\n indicesused.append(cnt.spatialindex)\\n if PRIORITIZE_FASTEST:\\n for sindex in indicesused: #filter down to the fastest contour.\\n _allatthisindex = [x for x in temp if x == sindex]\\n highest = _allatthisindex.sort(key=lambda y: y.spd, reverse=False)[0]\\n actualout.append(highest)\\n else:\\n actualout = temp\\n print 'Contours after cull: ', len(actualout)\\n return actualout\",\n \"def get_winning_discs(self):\\r\\n for i in range(6):\\r\\n for j in range(7):\\r\\n if self.board[i][j] == 'O':\\r\\n continue\\r\\n if self.is_horizontal_four(i, j):\\r\\n return [(i, x) for x in range(j, j + 4)]\\r\\n if self.is_vertical_four(i, j):\\r\\n return [(x, j) for x in range(i, i - 4, -1)]\\r\\n if self.is_neg_diagonal_four(i, j):\\r\\n return [(x, y) for x, y in zip(\\r\\n range(i, i + 4), range(j, j - 4, -1))]\\r\\n if self.is_pos_diagonal_four(i, j):\\r\\n return [(x, y)\\r\\n for x, y in zip(range(i, i + 4), range(j, j + 4))]\",\n \"def draw_contours(self, image, maskImg):\\r\\n # Required variables..\\r\\n x, y, width, height = 0, 0, 0, 0\\r\\n # Find contours..\\r\\n contours, hierarchy = cv2.findContours(image=maskImg, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) # Playable Parameters..\\r\\n # Draw the contours..\\r\\n for contour in contours:\\r\\n # Calculate the area of the contour, so can remove unnecessary contours..\\r\\n area = cv2.contourArea(contour=contour)\\r\\n if area > 3000: # Playable adjustment..!! Found Good as 3000 for current light condition.. change this if light condition changes..\\r\\n # Draw the contours to the image -- actual frame..\\r\\n if self.debug_mode:\\r\\n cv2.drawContours(image=image, contours=contour, contourIdx=-1, color=(255, 255, 0), thickness=4)\\r\\n # Find the perimeter of the markers detected...\\r\\n perimeter = cv2.arcLength(curve=contour, closed=True)\\r\\n # Approximating/Finding the corners of the image from the obtained corners..\\r\\n approx_corners = cv2.approxPolyDP(curve=contour, epsilon=0.02 * perimeter, closed=True)\\r\\n # Find the bounding box rectangle for the approximated corners..\\r\\n x, y, width, height = cv2.boundingRect(approx_corners)\\r\\n # Return the values with which a rectangle can be drawn..\\r\\n return x, y, width, height\",\n \"def findContours(img, thresh=127, val=255):\\n\\tgray = grayscale(img)\\n\\tret, binary = cv2.threshold(gray, thresh, val, cv2.THRESH_BINARY_INV)\\n\\tbina, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\terrorCheckContour(contours)\\n\\treturn sort(contours)\",\n \"def fun_contours(self, params):\\n shape_coeffs = params[:self.num_shape_params]\\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\\n\\n vertices3d = self.vertices3d\\n vertices3d_from_mesh = np.zeros_like(vertices3d)\\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\\n\\n inner_idx = 0\\n for idx in range(vertices3d.shape[0]):\\n lm_idx = idx % 66\\n obs_num = int(np.floor(idx/66))\\n\\n if lm_idx in self.contour_lms_list[0]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_right[obs_num])\\n elif lm_idx in self.contour_lms_list[1]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_left[obs_num])\\n else:\\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\\n inner_idx += 1\\n if inner_idx == 50:\\n inner_idx = 0\\n\\n return (vertices3d_from_mesh - vertices3d).ravel()\",\n \"def cell_detects(self, masked=False):\\r\\n grd = self.grd\\r\\n ncells = len(grd.cells['depth'])\\r\\n detects_i_tr = np.zeros(ncells, np.int32)\\r\\n if masked:\\r\\n not_flagged = np.where(self.rec_track.flagged==0)[0]\\r\\n rec_track = self.rec_track[not_flagged]\\r\\n else:\\r\\n rec_track = self.rec_track\\r\\n ndetects = len(rec_track)\\r\\n for nd in range(ndetects):\\r\\n tr = rec_track[nd]\\r\\n i = tr.i\\r\\n if i >= 0:\\r\\n detects_i_tr[i] += 1\\r\\n \\r\\n return detects_i_tr\",\n \"def select_contours(img):\\n # Find contours at a constant value\\n contours = measure.find_contours(img, 300)\\n # print(\\\"Found \\\" + str(len(contours)) + \\\" contour(s)\\\")\\n # Select the nearest contours with respect to the center pixel of the image\\n width = img.shape[1] # number of columms\\n heigth = img.shape[0] # number of rows\\n pixel_ref = (width / 2, heigth / 2)\\n # Threshold distance is 10% of images smallest dimension\\n dist_thresh = min(width, heigth) * 0.1\\n contours_wanted = []\\n pixel_mean_array = []\\n for contour in contours:\\n contour_3d = np.zeros([contour.shape[0], 3]) # 3rd dimension added for later conversion to patient coord space\\n contour_3d[:, :2] = contour\\n pixel_mean = np.mean(contour, axis=0)\\n if distance.euclidean(pixel_ref, pixel_mean) <= dist_thresh:\\n contours_wanted.append(contour_3d)\\n pixel_mean_array.append(pixel_mean)\\n # print(\\\"Set \\\" + str(len(contours_wanted)) + \\\" contours of interest\\\")\\n return contours_wanted, pixel_mean_array\",\n \"def get_pair_rects(contours):\\n\\n rect_pairs = []\\n for index, cnt in enumerate(contours):\\n # Rotated rect - ( center (x,y), (width, height), angle of rotation )\\n rect = cv2.minAreaRect(cnt)\\n center_x, center_y = rect[0]\\n rect_angle = -round(rect[2], 2)\\n\\n if rect_angle > 45.0:\\n # Iterate through all of the potential matches\\n min_x_dist = min_rect = min_index = None\\n for pot_index, pot_match in enumerate(contours):\\n if np.array_equal(pot_match, cnt):\\n continue\\n\\n match_rect = cv2.minAreaRect(pot_match)\\n\\n # Check if match is to the right of the contour\\n if match_rect[0][0] > rect[0][0] and abs(\\n match_rect[2] - rect_angle) > ANGLE_TOLERANCE_DEG:\\n x_distance = match_rect[0][0] - rect[0][0]\\n\\n if min_x_dist is None or x_distance < min_x_dist:\\n min_x_dist = x_distance\\n min_rect = match_rect\\n min_index = pot_index\\n\\n if min_rect is not None:\\n rect_pairs.append((rect, min_rect))\\n np.delete(contours, index)\\n np.delete(contours, min_index)\\n\\n return rect_pairs\",\n \"def getContours( self,img ):\\n if( len(img.shape) == 3):\\n (_, contours, _) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n (contours,_) = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours\",\n \"def find_components(edges, max_components=16):\\n # Perform increasingly aggressive dilation until there are just a few\\n # connected components.\\n\\n count = 21\\n dilation = 5\\n n = 1\\n while count > 16:\\n n += 1\\n dilated_image = dilate(edges, N=3, iterations=n)\\n dilated_image = np.uint8(dilated_image)\\n contours, hierarchy = cv2.findContours(dilated_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n count = len(contours)\\n # print dilation\\n # Image.fromarray(edges).show()\\n # Image.fromarray(255 * dilated_image).show()\\n return contours\",\n \"def GetInteriorEdgesTri(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesTri()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesTri()\\n\\n sorted_all_edges = np.sort(self.all_edges,axis=1)\\n sorted_boundary_edges = np.sort(self.edges,axis=1)\\n\\n x = []\\n for i in range(self.edges.shape[0]):\\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\\n pos_interior_edges = np.where(interior_edges==0)[0]\\n if pos_interior_edges.shape[0] != 0:\\n x.append(pos_interior_edges)\\n\\n edge_aranger = np.arange(self.all_edges.shape[0])\\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\\n interior_edges = self.all_edges[edge_aranger,:]\\n\\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\\n edge_flags[edge_aranger] = 0\\n\\n self.interior_edges = interior_edges\\n return interior_edges, edge_flags\",\n \"def get_position_patterns(contours, hierarchy):\\n found = []\\n for i in range(len(contours)):\\n k = i\\n c = 0\\n while hierarchy[k][2] != -1:\\n k = hierarchy[k][2]\\n c += 1\\n if c >= 5:\\n found.append(i)\\n return found\",\n \"def find_contours(dframe):\\n #Blur the image.\\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\\n #if debug:\\n #plt.imshow(fixColor(blurred))\\n #plt.show()\\n #Get a threshold image, numbers where tested for the given video.\\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \\n cv2.CHAIN_APPROX_SIMPLE)\\n return cnts\",\n \"def read_board_values(self):\\r\\n\\r\\n # Iterate through each contour/cell\\r\\n for row in self.game_board_contours:\\r\\n board_row = []\\r\\n\\r\\n # For each cell, we get its location and crop the original thresholded image to that location\\r\\n for c in row:\\r\\n x, y, w, h = cv2.boundingRect(c)\\r\\n x_margin = int(w * 0.05)\\r\\n y_margin = int(h * 0.05)\\r\\n cropped_image = self.thresh_orig[y + y_margin:y + h - 2 * y_margin, x + x_margin:x + w - 2 * x_margin]\\r\\n\\r\\n # If it's mostly white, we don't need to waste time with OCR and we know it is blank\\r\\n if np.average(cropped_image) > 253:\\r\\n board_row.append(0)\\r\\n\\r\\n # Otherwise we pass it to the OCR to see which character is present within that cell\\r\\n else:\\r\\n character = pytesseract.image_to_string(cropped_image, config=self.pytesseract_config)\\r\\n # If the character is a commonly mis-read one, use dictionary to find the real character\\r\\n if character in self.replacements:\\r\\n character = self.replacements[character]\\r\\n board_row.append(character)\\r\\n self.game_board.append(board_row)\",\n \"def _get_end_points(self, segmented_instances, i, stats, idx):\\n\\n end_points=[]\\n\\n # find all points intersecting the bbox\\n #(tl_x, th_y, width, height, area)\\n label_num=i+1\\n leftmost_x = stats['bbox'][i][cv2.CC_STAT_LEFT]\\n topmost_y = stats['bbox'][i][cv2.CC_STAT_TOP]\\n width = stats['bbox'][i][cv2.CC_STAT_WIDTH]\\n height = stats['bbox'][i][cv2.CC_STAT_HEIGHT]\\n bottom_most_y = topmost_y + height-1\\n right_most_x = leftmost_x + width-1\\n\\n segmented_instances_copy=segmented_instances.copy()\\n edge_points = np.zeros(segmented_instances.shape).astype(np.uint8)\\n segs = np.zeros(segmented_instances.shape).astype(np.uint8)\\n segs[segmented_instances==label_num]=255\\n cv2.rectangle(segmented_instances_copy,(leftmost_x, topmost_y), (right_most_x, bottom_most_y), 150, 2)\\n\\n #Get all points for the current stem segment\\n label_points = np.argwhere(segmented_instances.copy()==label_num)\\n\\n # upper points from (tl_x,th_y) to (th_x, th_y) that instersect with the upper edge of the bouding box\\n upper_points = [i for i in label_points if i[0]==topmost_y and i[1]>=leftmost_x and i[1]<=right_most_x]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(upper_points, edge_points, segs, 1)\\n center_upper_pts = sorted(self._get_centeroids(x_pts))\\n\\n # left side points from (tl_x, tl_y) to (tl_x, th_y) that instersect with the left edge of the bouding box\\n left_points = [i for i in label_points if i[1]==leftmost_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(left_points, edge_points, segs, 0)\\n center_left_pts = sorted(self._get_centeroids(x_pts))\\n\\n #right side points form (th_x, tl_y) to (th_x, th_y) that instersect with the right edge of the bouding box\\n right_points = [i for i in label_points if i[1]==right_most_x and i[0]<=bottom_most_y and i[0]>=topmost_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(right_points, edge_points, segs, 0)\\n center_right_pts = sorted(self._get_centeroids(x_pts))\\n\\n #bottom points from (tl_x, tl_y) to (th_x,tl_y)\\n bottom_points = [i for i in label_points if i[1]>=leftmost_x and i[1]<=right_most_x and i[0]==bottom_most_y]\\n x_pts, segs, edge_points = self._update_imgs_and_pt_list(bottom_points, edge_points, segs, 1)\\n center_bottom_pts = sorted(self._get_centeroids(x_pts))\\n\\n # If there are corner edges, get the centroid of that\\n center_x_lb, center_y_lb, center_left_pts, center_bottom_pts = self._get_corner_centers(center_left_pts, \\\\\\n center_bottom_pts, bottom_most_y, leftmost_x)\\n if (center_x_lb != None) and (center_y_lb != None):\\n end_points.append([center_x_lb, center_y_lb])\\n else:\\n if len(center_left_pts)>0:\\n for pt_idx in range(0, len(center_left_pts)):\\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\\n if len(center_bottom_pts)>0:\\n for pt_idx in range(0, len(center_bottom_pts)):\\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\\n\\n # If there are corner edges, get the centroid of that\\n center_x_ur, center_y_ur, center_right_pts, center_upper_pts = self._get_corner_centers(center_right_pts, \\\\\\n center_upper_pts, topmost_y, right_most_x)\\n if (center_x_ur != None) and (center_y_ur != None):\\n end_points.append([center_x_ur, center_y_ur])\\n else:\\n if len(center_right_pts)>0:\\n for pt_idx in range(0, len(center_right_pts)):\\n end_points.append([right_most_x, center_right_pts[pt_idx]])\\n if len(center_upper_pts)>0:\\n for pt_idx in range(0, len(center_upper_pts)):\\n end_points.append([center_upper_pts[pt_idx], topmost_y])\\n\\n # If there are corner edges, get the centroid of that\\n center_x_ul, center_y_ul, center_left_pts, center_upper_pts = self._get_corner_centers(center_left_pts, \\\\\\n center_upper_pts, topmost_y, leftmost_x)\\n if (center_x_ul != None) and (center_y_ul != None):\\n end_points.append([center_x_ul, center_y_ul])\\n else:\\n if len(center_left_pts)>0:\\n for pt_idx in range(0, len(center_left_pts)):\\n end_points.append([leftmost_x, center_left_pts[pt_idx]])\\n if len(center_upper_pts)>0:\\n for pt_idx in range(0, len(center_upper_pts)):\\n end_points.append([center_upper_pts[pt_idx], topmost_y])\\n\\n\\n # If there are corner edges, get the centroid of that\\n center_x_br, center_y_br, center_right_pts, center_bottom_pts = self._get_corner_centers(center_right_pts, \\\\\\n center_bottom_pts, bottom_most_y, right_most_x)\\n if (center_x_br != None) and (center_y_br != None):\\n end_points.append([center_x_br, center_y_br])\\n else:\\n if len(center_right_pts)>0:\\n for pt_idx in range(0, len(center_right_pts)):\\n end_points.append([right_most_x, center_right_pts[pt_idx]])\\n if len(center_bottom_pts)>0:\\n for pt_idx in range(0, len(center_bottom_pts)):\\n end_points.append([center_bottom_pts[pt_idx], bottom_most_y])\\n\\n #self.showme(segmented_instances_copy, 'bbox')\\n\\n return end_points\",\n \"def get_further_neighbours(self, cell):\\n\\t\\tneighs = self.get_neighbours(cell)\\n\\t\\ti, j = cell.find_id()\\n\\t\\tneighbours = []\\n\\t\\tfor neigh in neighs:\\n\\t\\t\\tx, y = neigh.find_id()\\n\\t\\t\\tif abs(x-i)+abs(y-j) > 1 or abs(x-i)+abs(y-j) == 0: \\n\\t\\t\\t\\tneighbours.append(self.space[y,x])\\n\\t\\treturn neighbours\",\n \"def get_neighbours(self):\\n shape=self.cubeshape[1:]\\n neighboursx=np.arange(self.xpos-(self.blocksize-1)/2,(self.xpos+(self.blocksize-1)/2)+1,dtype='int' )\\n neighboursx=[x if (x>=0) & (x<=shape[1]-1) else np.nan for x in neighboursx ]\\n neighboursy=np.arange(self.ypos-(self.blocksize-1)/2,(self.ypos+(self.blocksize-1)/2)+1,dtype='int' )\\n neighboursy=[y if (y>=0) & (y<=shape[0]-1) else np.nan for y in neighboursy ]\\n keys=[np.ravel_multi_index([y,x], shape) if np.all(np.isfinite(np.asarray([y,x]))) else np.nan for y in neighboursy for x in neighboursx]\\n\\n return keys\",\n \"def _get_watershed_areas(self, class_contours, class_mask, kernel_size=3, area_thresh=500):\\n\\n kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)\\n\\n # Since the watershed draws contours, we need to invert the predictions to\\n # get the 'inside' blob portion. We also slightly compress the blob portion\\n # so we can get a more defining border.\\n inverted_contours = 255 - class_contours\\n\\n inverted_contours = cv2.erode(inverted_contours, kernel, iterations=1)\\n # remove areas that are not part of the class mask\\n inverted_contours[class_mask==0]= 0 # here ?\\n\\n return inverted_contours\",\n \"def getSignificantContours(frame, epsilon=None):\\n frame, contours, hierarchy = cv2.findContours(frame, cv2.RETR_TREE,\\n cv2.CHAIN_APPROX_SIMPLE)\\n contours = sorted(contours, key=cv2.contourArea, reverse=True)\\n significantContours = []\\n perimeters = []\\n\\n for contour in contours:\\n perimeter = cv2.arcLength(contour, closed=False)\\n index = bisect.bisect(perimeters, perimeter)\\n if epsilon is not None:\\n approx = cv2.approxPolyDP(contour, epsilon * perimeter, False)\\n significantContours.insert(index, approx)\\n else:\\n significantContours.insert(index, contour)\\n perimeters.insert(index, perimeter)\\n\\n return significantContours\",\n \"def analyzeContours(contours):\\n if len(contours[0]) != 4 and len(contours[0]) != 8:\\n return 0\\n\\n first, second, prev = [1, 1], [1, 1], 0\\n for i, val in enumerate(numpy.nditer(contours[0])):\\n if i % 2:\\n second = [prev, val]\\n else:\\n first = [prev, val]\\n\\n # compare pair to the previous pair\\n for num in first:\\n if num in second:\\n break\\n else:\\n return 0\\n\\n prev = val\\n\\n return 1\",\n \"def find_contours(mask):\\n _, contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_KCOS)\\n return contours\",\n \"def find_contours(vertical, horizontal):\\n\\tmask = vertical + horizontal\\n\\n\\ttry:\\n\\t\\t__, contours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\texcept ValueError:\\n\\t\\t# for opencv backward compatibility\\n\\t\\tcontours, __ = cv2.findContours(\\n\\t\\t\\tmask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE\\n\\t\\t)\\n\\t# sort in reverse based on contour area and use first 10 contours\\n\\tcontours = sorted(contours, key=cv2.contourArea, reverse=True)[:10]\\n\\n\\tcont = []\\n\\tfor c in contours:\\n\\t\\tc_poly = cv2.approxPolyDP(c, 3, True)\\n\\t\\tx, y, w, h = cv2.boundingRect(c_poly)\\n\\t\\tcont.append((x, y, w, h))\\n\\treturn cont\",\n \"def contours_to_arrays(gdf, col): \\n\\n coords_zvals = []\\n\\n for i in range(0, len(gdf)):\\n\\n val = gdf.iloc[i][col]\\n\\n try:\\n coords = np.concatenate([np.vstack(x.coords.xy).T \\n for x in gdf.iloc[i].geometry])\\n except:\\n coords = np.vstack(gdf.iloc[i].geometry.coords.xy).T\\n\\n coords_zvals.append(np.column_stack((coords, \\n np.full(np.shape(coords)[0], \\n fill_value=val))))\\n\\n return np.concatenate(coords_zvals)\",\n \"def generate_contours(edges, colorimg, img):\\n cv2.destroyAllWindows()\\n cv2.namedWindow(\\\"Contours\\\")\\n lengthlimit = 20\\n arealimit = 20\\n\\n # create trackbars for length and area filters\\n cv2.createTrackbar(\\\"length\\\", \\\"Contours\\\", 0, 200, nothing)\\n cv2.createTrackbar(\\\"area\\\", \\\"Contours\\\", 0, 2000, nothing)\\n\\n # find all possible contours in the image\\n ret, thresh = cv2.threshold(edges, 127, 255, 0)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\n while 1:\\n cv2.imshow(\\\"Contours\\\", colorimg)\\n\\n # filter based on area and length\\n lengthlimit = cv2.getTrackbarPos(\\\"length\\\", \\\"Contours\\\")\\n arealimit = cv2.getTrackbarPos(\\\"area\\\", \\\"Contours\\\")\\n\\n for idx, contour in enumerate(contours):\\n if len(contour) > lengthlimit:\\n area = cv2.contourArea(contour)\\n if area > arealimit:\\n isconvex = cv2.isContourConvex(contour)\\n circle = cv2.minEnclosingCircle(contour)\\n cv2.drawContours(colorimg, contours, idx, (0, 255, 0), 2)\\n else:\\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\\n else:\\n cv2.drawContours(colorimg, contours, idx, (0, 0, 255), 2)\\n\\n k = cv2.waitKey(1) & 0xFF\\n # print k\\n if k == 27:\\n exit()\\n if k == 32:\\n show_final(colorimg, contours, arealimit, lengthlimit)\",\n \"def segment_cells(frame, mask=None):\\n \\n blurred = filters.gaussian(frame, 2)\\n ridges = enhance_ridges(frame)\\n \\n # threshold ridge image\\n thresh = filters.threshold_otsu(ridges)\\n thresh_factor = 0.5\\n prominent_ridges = ridges > thresh_factor*thresh\\n prominent_ridges = morphology.remove_small_objects(prominent_ridges, min_size=256)\\n prominent_ridges = morphology.binary_closing(prominent_ridges)\\n prominent_ridges = morphology.binary_dilation(prominent_ridges)\\n \\n # skeletonize\\n ridge_skeleton = morphology.medial_axis(prominent_ridges)\\n ridge_skeleton = morphology.binary_dilation(ridge_skeleton)\\n ridge_skeleton *= mask\\n ridge_skeleton = np.bitwise_xor(ridge_skeleton, mask)\\n \\n # label\\n cell_label_im = measure.label(ridge_skeleton)\\n \\n # morphological closing to fill in the cracks\\n for cell_num in range(1, cell_label_im.max()+1):\\n cell_mask = cell_label_im==cell_num\\n cell_mask = morphology.binary_closing(cell_mask, disk(3))\\n cell_label_im[cell_mask] = cell_num\\n \\n return cell_label_im\",\n \"def find_contours(img_path, **kwargs):\\n threshold = kwargs['threshold']\\n image = cv2.imread(img_path)\\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\n blurred = cv2.GaussianBlur(gray, (5, 5), 0)\\n thresh = cv2.threshold(blurred, threshold, 255, cv2.THRESH_BINARY)[1]\\n contours, _ = cv2.findContours(thresh.copy(),\\n cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\\n\\n\\n contour_areas = [] # TODO: is there a faster way to keep the contors with n-largest areas?\\n for i, contour in enumerate(contours):\\n area = cv2.contourArea(contour)\\n contour_areas.append((i, area))\\n\\n rect = cv2.minAreaRect(contour)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n cv2.drawContours(image,[box],0,(0,0,255),2)\\n cv2.imwrite('rect_{}.png'.format(i), image)\\n # Contours that cover the largest areas are whole pieces\\n largest_contour_areas = nlargest(10, contour_areas, key=lambda x:x[1])\\n #print(largest_contour_areas)\\n\\n for i, area in largest_contour_areas:\\n print (i, area)\\n cv2.drawContours(image, contours, i, (100, 155, 100), 3)\\n cv2.imwrite('contor_{}.png'.format(i), image)\\n return True\",\n \"def find_contour(hole_atoms, atom_list):\\n contour_atoms = []\\n extra_atoms = []\\n global bond_list\\n bond_list = bond_list_1\\n for atom in hole_atoms:\\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond[0] not in hole_atoms) and (bond[0] not in contour_atoms))]\\n for element in c:\\n contour_atoms.append(element)\\n for atom in atom_list:\\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n count = 0\\n for element in c:\\n if element in contour_atoms:\\n count += 1\\n if (count >= 2):\\n extra_atoms.append(atom)\\n for atom in atom_list:\\n c = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n for element in c:\\n if ((element in contour_atoms) or (element in extra_atoms)):\\n for i in [bond[0] for bond in identify_bonds(element, atom_list)]:\\n if ((i in hole_atoms) and (atom not in hole_atoms) and (atom not in contour_atoms) and (atom not in extra_atoms)):\\n extra_atoms.append(atom) \\n \\n contour_atoms = contour_atoms + extra_atoms\\n \\n extra_atoms2 = []\\n for atom in contour_atoms:\\n for atom2 in contour_atoms:\\n if (atom != atom2):\\n c = [bond[0] for bond in identify_bonds(atom, atom_list) if ((bond in identify_bonds(atom2, atom_list)) and (bond[0] not in (contour_atoms)))]\\n if (len(c) != 0):\\n extra_atoms2.append(c[0]) \\n for element in extra_atoms2:\\n contour_atoms.append(element)\\n return contour_atoms\",\n \"def getContours(img):\\n # mode: gets only exrteme outer contours\\n # method: stores all contour points\\n contours, hierarchy = cv2.findContours(img, mode=cv2.RETR_EXTERNAL,\\n method=cv2.CHAIN_APPROX_NONE)\\n \\n x, y, w, h = 0, 0, 0, 0\\n\\n # improving accuracy of contours\\n for cnt in contours:\\n area = cv2.contourArea(cnt)\\n if area > 500:\\n # assumes cnt with area > 500 is closed contour \\n perimeter = cv2.arcLength(cnt, True)\\n\\n # approximate polygonal curve of cnt\\n # set max difference between original and approxCurve as \\n # 0.02 * perimeter\\n approxCurve = cv2.approxPolyDP(cnt, 0.02 * perimeter, closed=True)\\n \\n x, y, w, h = cv2.boundingRect(approxCurve)\\n # wand point is is center-left tip\\n return x + (w // 2), y\",\n \"def paintings_detection(query_image, mask):\\n\\n image = cv2.imread(query_image)\\n\\n image_width = mask.shape[0]\\n image_height = mask.shape[1]\\n x_box_1, y_box_1, w_box_1, h_box_1, x_box_2, y_box_2, w_box_2, h_box_2 = 0, 0, 0, 0, 0, 0, 0, 0, \\n\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2:]\\n\\n for cnt in contours:\\n x, y, w, h = cv2.boundingRect(cnt)\\n \\n if (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 == 0):\\n x_box_1, y_box_1, w_box_1, h_box_1 = x, y, w, h\\n elif (w > 0.15 * image_width) & (h > 0.15 * image_height) & (w < 0.98 * image_width) & (x_box_1 != 0):\\n x_box_2, y_box_2, w_box_2, h_box_2 = x, y, w, h\\n\\n if x_box_2 == 0:\\n x_value_to_split = 0\\n else:\\n x_value_to_split = (x_box_1 + w_box_1/2 + x_box_2 + w_box_2/2) / 2\\n\\n\\n return(x_value_to_split)\",\n \"def footprint_corner_indices():\",\n \"def find_contours(mask):\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,\\n cv2.CHAIN_APPROX_SIMPLE)\\n cnts = imutils.grab_contours(cnts)\\n return cnts\",\n \"def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\\n\\n kernel = np.ones((5, 5), np.float32)\\n\\n # Use a distance transform to find the seed points for watershed\\n tmp = class_mask\\n tmp[tmp>0] = 1 # here\\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\\n dist = (dist / np.max(dist)) * 255.\\n\\n # Since there may be multiple peaks, we use dilation to find them\\n dilate = cv2.dilate(dist, kernel, iterations=3)\\n peaks = np.float32(np.where(dilate == dist, 1, 0))\\n peaks = peaks * class_mask * 255\\n\\n sure_fg = np.where(peaks > 125, 255., 0.)\\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\\n sure_fg = np.uint8(sure_fg)\\n\\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\\n unknown = sure_bg - sure_fg\\n\\n # Add one to all labels so that known background is not 0, but 1\\n _, markers = cv2.connectedComponents(sure_fg)\\n markers = markers + 1\\n\\n markers[unknown == 255] = 0\\n\\n markers = cv2.watershed(self.image, markers)\\n\\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\\n watershed_superpixels[markers == -1] = 255\\n\\n return watershed_superpixels\",\n \"def mark_contours(contour_arr, img, symmetry, _plot=False):\\n marg, flag = 7, 0\\n # fig, ax = plt.subplots()\\n # ax.imshow(img, cmap=\\\"gray\\\")\\n sub_images = [] # init array for pictures\\n for contour in contour_arr:\\n\\n lower_dim = contour[:, 0]\\n x, y = lower_dim[:, 0], lower_dim[:, 1]\\n min_x, min_y, max_x, max_y = min(x), min(y), max(x), max(y)\\n\\n # remove small noise\\n if (max_x - min_x) * (max_y - min_y) < MIN_IMG_SIZE:\\n continue\\n # avoid index error\\n if min_x - marg < 0 or min_y - marg < 0 or max_y + marg > img.shape[0] or max_x + marg > img.shape[1]:\\n marg = 0\\n # crop only half cause image is symmetric:\\n # TODO: address different types of symmetry as input from user\\n if symmetry == HORIZONTAL:\\n if max_x <= img.shape[1] // 2:\\n sub_images.append(img[min_y:max_y, min_x:max_x])\\n flag = 1\\n else: # symmetry is around the X-axis\\n if max_y <= img.shape[0] // 2:\\n sub_images.append(img[min_y:max_y, min_x:max_x])\\n flag = 1\\n if _plot and flag:\\n ax.plot([min_x - marg, max_x + marg, max_x + marg, min_x - marg, min_x - marg],\\n [min_y - marg, min_y - marg, max_y + marg, max_y + marg, min_y - marg], c='r', linewidth=0.4)\\n flag = 0\\n if _plot:\\n plt.savefig(\\\"found_subshapes2.jpg\\\")\\n # plt.show()\\n return sub_images\",\n \"def register_cells(contours: List[np.array]) -> np.array:\\n def create_cell(contour: np.array) -> np.array:\\n center, radius = cv2.minEnclosingCircle(contour)\\n v = (0, 0)\\n weight = -1\\n\\n return np.array([center[0], center[1], v[0], v[1], radius, weight])\\n\\n areas = np.array([cv2.contourArea(contour) for contour in contours]).astype(\\\"float32\\\")\\n blobs = np.array([create_cell(contour) for contour in contours]).astype(\\\"int32\\\")\\n\\n return blobs[areas >= 100].astype(\\\"float32\\\")\",\n \"def instance_submasks(gti):\\n rc_locs = np.where(gti > 0)\\n grouped_cc_rcs = util.group_items(\\n np.ascontiguousarray(np.vstack(rc_locs).T),\\n gti[rc_locs], axis=0\\n )\\n\\n def bounding_box(rcs):\\n rc1 = rcs.min(axis=0)\\n rc2 = rcs.max(axis=0)\\n return rc1, rc2\\n\\n for label, rcs in grouped_cc_rcs.items():\\n rc1, rc2 = bounding_box(rcs)\\n r_slice = slice(rc1[0], rc2[0] + 1)\\n c_slice = slice(rc1[1], rc2[1] + 1)\\n rc_sl = (r_slice, c_slice)\\n subimg = gti[rc_sl]\\n submask = (subimg == label).astype(np.uint8)\\n\\n rc_off = rc1\\n yield label, submask, rc_off, rc_sl\",\n \"def detectBlocksInDepthImage(self):\\n self.depth_detect_frame = self.currentDepthFrame\\n\\n # 1 block\\n self.bin_detect_frame_1 = cv2.inRange(self.depth_detect_frame,700,710)\\n kernel = np.ones((6,6),np.uint8)\\n self.bin_detect_frame_1 = cv2.erode(self.bin_detect_frame_1,kernel,iterations = 1)\\n _, self.block_contours, _ = cv2.findContours(self.bin_detect_frame_1,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)\\n \\n # 2 blocks\\n self.bin_detect_frame_2 = cv2.inRange(self.depth_detect_frame,680,699)\\n kernel = np.ones((6,6),np.uint8)\\n self.bin_detect_frame_2 = cv2.erode(self.bin_detect_frame_2,kernel,iterations = 1)\\n _, self.block_contours_2, _ = cv2.findContours(self.bin_detect_frame_2,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)\\n \\n # 3 blocks\\n self.bin_detect_frame_3 = cv2.inRange(self.depth_detect_frame,660,679)\\n kernel = np.ones((6,6),np.uint8)\\n self.bin_detect_frame_3 = cv2.erode(self.bin_detect_frame_3,kernel,iterations = 1)\\n _, self.block_contours_3, _ = cv2.findContours(self.bin_detect_frame_3,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)\\n \\n pass\",\n \"def recognize_pieces(edges, v, squares):\\n\\n pieces = []\\n\\n v = cv2.equalizeHist(v)\\n for p1, p2 in squares:\\n # count the number of slightly centered edges\\n occupancy = sum(edges[y][x]\\n for x in range(p1.x + 5, p2.x - 5)\\n for y in range(p1.y + 5, p2.y - 5))\\n\\n if occupancy > 70*255:\\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\\n v[p2.y][p1.x], v[p2.y][p2.x])\\n\\n # average v-component of the corners\\n avg = sum(map(float, corners)) / len(corners)\\n\\n # black pixels should be relatively black\\n # when compared to the corner average\\n black = sum(v[y][x] / avg < 0.2\\n for x in range(p1.x, p2.x + 1)\\n for y in range(p1.y, p2.y + 1))\\n\\n if black >= 1000 and black != 1049:\\n color = \\\"B\\\"\\n else:\\n color = \\\"W\\\"\\n\\n pieces.append(color)\\n else:\\n pieces.append(None)\\n\\n return pieces\",\n \"def draw_separate_position_patterns(img, found, contours):\\n for i in found:\\n qr_dc = img.copy()\\n cv2.drawContours(qr_dc, contours, i, (0, 255, 0), 2)\\n show(qr_dc)\",\n \"def draw_contours(self):\\n contours, hierarchy = cv2.findContours(self.edged, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_TC89_L1)\\n\\n edged = cv2.bitwise_not(self.edged)\\n rgb = cv2.cvtColor(edged, cv2.COLOR_GRAY2RGB)\\n\\n temp_array = np.ones([rgb.shape[0], rgb.shape[1], rgb.shape[2]])\\n contours_ = cv2.drawContours(temp_array, contours, -1, (0, 0, 0), thickness=1)\\n\\n ml_filename = 'MLOutputs/' + str(self.file_name) + 'Clusters' + str(self.clusters) + \\\\\\n 'FilterSize' + str(self.filter_size) + 'Sigma' + str(self.sigma) + 'UniqueColours' + \\\\\\n str(self.unique_colours) + \\\".png\\\"\\n\\n plt.imshow(contours_, cmap=\\\"gray\\\")\\n if not os.path.isfile(ml_filename):\\n imsave(ml_filename, contours_, cmap=\\\"gray\\\")\",\n \"def _plot_traces_with_cell_img(self, fovlist, gs, maxshape):\\n starting_row_idx = 0\\n ending_row_idx = 0\\n for fov in fovlist:\\n time_vec = np.arange(maxshape[1]) / fov.fps\\n starting_row_idx = ending_row_idx\\n if fov.labeled:\\n ending_row_idx += max(\\n fov.unlabeled.dff.shape[0], fov.labeled.dff.shape[0]\\n )\\n else:\\n ending_row_idx += fov.all_data.shape[0]\\n midpoint = gs.get_geometry()[1] // 2\\n self._show_cell_excerpts(\\n fovsubset=fov.unlabeled,\\n radius=fov.cell_radius,\\n gs=gs,\\n gs_rows=slice(starting_row_idx, ending_row_idx),\\n gs_col=0,\\n )\\n self._show_cell_excerpts(\\n fovsubset=fov.labeled,\\n radius=fov.cell_radius,\\n gs=gs,\\n gs_rows=slice(starting_row_idx, ending_row_idx),\\n gs_col=midpoint,\\n )\\n self._show_traces(\\n fovsubset=fov.unlabeled,\\n time_vec=time_vec,\\n fps=fov.fps,\\n gs=gs,\\n gs_rows=slice(starting_row_idx, ending_row_idx),\\n gs_cols=slice(1, midpoint),\\n )\\n self._show_traces(\\n fovsubset=fov.labeled,\\n time_vec=time_vec,\\n fps=fov.fps,\\n gs=gs,\\n gs_rows=slice(starting_row_idx, ending_row_idx),\\n gs_cols=slice(midpoint+1, None),\\n )\",\n \"def identify_dbs(image):\\n locations = {\\\"red\\\": Point(), \\\"green\\\": Point(), \\\"blue\\\": Point()}\\n masks = {\\\"red\\\": [], \\\"green\\\": [], \\\"blue\\\": []}\\n\\n bridge = cv_bridge.CvBridge()\\n image = bridge.imgmsg_to_cv2(image, \\\"bgr8\\\")\\n hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n\\n # upper and lower bounds for red\\n # using python 3 bgr [0,0,188] = hsv [0, 255, 188]\\n lower_red = numpy.array([0, 100, 100]) \\n upper_red = numpy.array([10, 255, 255])\\n masks[\\\"red\\\"] = cv2.inRange(hsv, lower_red, upper_red)\\n\\n # upper and lower bounds for green\\n # using python 3 bgr [0,175,0] = hsv [60, 255, 175]\\n lower_green = numpy.array([50, 100, 100]) \\n upper_green = numpy.array([70, 255, 255])\\n masks[\\\"green\\\"] = cv2.inRange(hsv, lower_green, upper_green)\\n\\n # upper and lower bounds for blue\\n # using python 3 bgr [176, 0, 17] = hsv [123, 255, 176]\\n lower_blue = numpy.array([113, 100, 100])\\n upper_blue = numpy.array([133, 255, 255])\\n masks[\\\"blue\\\"] = cv2.inRange(hsv, lower_blue, upper_blue)\\n\\n x, y, w, h = 0, 0, image.shape[1]//3, image.shape[0]\\n\\n for color, mask in masks.items():\\n pixels = {\\\"left\\\": 0, \\\"middle\\\": 0, \\\"right\\\": 0}\\n \\n # define section of image to use for left, middle and right\\n left = mask[y:y+h, x:x+w]\\n middle = mask[y:y+h, x+w:x+w+w]\\n right = mask[y:y+h, x+w+w:x+3*w]\\n\\n # count the number of pixels in each section\\n pixels[\\\"left\\\"] = cv2.countNonZero(left)\\n pixels[\\\"middle\\\"] = cv2.countNonZero(middle)\\n pixels[\\\"right\\\"] = cv2.countNonZero(right)\\n location = max(pixels, key=pixels.get)\\n\\n # map the relative position of the db (left, middle, right) to the correct Point()\\n locations[color] = db_locations[location]\\n \\n return locations\",\n \"def find_contour(ctx: Context):\\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\\n contours, _ = cv2.findContours(ctx.temp_image1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n\\n # take the 5 biggest areas\\n contours = sorted(contours, key=lambda c: math.fabs(cv2.contourArea(c)), reverse=True)[:5]\\n\\n # approximate contours with poly line\\n ctx.contours = [cv2.approxPolyDP(c, 2, True) for c in contours]\",\n \"def get_instance_contours(img, contoured, instance):\\n mask = np.zeros(img.shape, dtype=np.uint16)\\n mask[img == instance] = 1\\n ret, threshed = cv.threshold(mask, 0, 2 ** 16, cv.THRESH_BINARY)\\n compressed = threshed.astype(np.uint8)\\n contours, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n cv.drawContours(contoured, contours, -1, (randint(25, 255), randint(25, 255), randint(25, 255)), 3)\\n img2 = contours = hierarchy = mask = None\",\n \"def get_nb_vals(i, pnts, dem, top_left_cor, cellsize, rows, cols):\\n nb_x = np.zeros((5,5)) # this 5 by 5 max would contain the x coordinate of 16 neighbor pixels of a sample point\\n nb_y = np.zeros((5,5)) # this 5 by 5 matrix would contain the y coordinate of 16 neighbor pixels of a sample point\\n nb_z = np.zeros((5,5))\\n # get index and value of cell in DEM containing current point\\n (cell_X, cell_Y, cell_Z) = misc.getCellValue(pnts[i], \\n dem, \\n top_left_cor, \\n cellsize)\\n #Deal with sample points near boundary of the DEM\\n point_within_dem = (cell_X-2) >=0 and (cell_Y-2>=0) and (cell_X+3)<=cols and (cell_Y+3)<=rows\\n if point_within_dem:\\n nb_z[0:5,0:5] = misc.RasterSubset(dem,(cell_Y-2),(cell_Y+3),(cell_X-2),(cell_X+3))\\n else:\\n #Get the part of moving window within the DEM domain\\n in_data= misc.RasterSubset(dem,max((cell_Y-2),0),min((cell_Y+3),rows),max((cell_X-2),0),min((cell_X+3),cols))\\n #in_data=dem[\\\"array\\\"][max((cell_Y-2),0):min((cell_Y+3),rows),max((cell_X-2),0):min((cell_X+3),cols)]\\n nb_z[max((2-cell_Y),0):min((5-(cell_Y+3-rows)),5),max((2-cell_X),0):min((5-(cell_X+3-cols)),5)]=in_data[0:in_data.shape[0],0:in_data.shape[1]]\\n in_data_avg=np.mean(in_data[in_data>-3.4e+10])\\n nb_z[nb_z==0]=in_data_avg\\n nb_z[nb_z<-3.4e+10]=in_data_avg\\n\\n\\n \\n # If there is missing data in the neighborhood of the sample point \\n # use neighborhood average to replace the missing value \\n has_missing_data = (nb_z>8848).sum()>0 or (nb_z<-413).sum()>0\\n if has_missing_data:\\n avgValue=np.mean(nb_z[np.where(np.logical_and(nb_z<8848, nb_z>-413))])\\n nb_z[nb_z>8848]=avgValue\\n nb_z[nb_z<-413]=avgValue\\n \\n # Obtain the coordinate of cell centroid of a 5*5 neighborhood around the sample point\\n for ii in [0,1,2,3,4]:\\n cor_y=ii-2\\n dy = (cell_Y+cor_y+0.5) * cellsize[1]\\n nb_y[ii,:] = top_left_cor[1] + dy\\n for jj in [0,1,2,3,4]:\\n cor_x=jj-2\\n dx = (cell_X+cor_x+0.5) * cellsize[0]\\n nb_x [:,jj] = top_left_cor[0] + dx\\n return nb_x, nb_y, nb_z\",\n \"def process(self):\\n contours, hierachy = cv.findContours(\\n self.input_image,\\n cv.RETR_LIST,\\n cv.CHAIN_APPROX_SIMPLE,\\n )\\n contours = sorted(contours, key=cv.contourArea, reverse=True)\\n target = None\\n for c in contours:\\n path = cv.arcLength(c, True)\\n approx = cv.approxPolyDP(c, 0.1*path, True)\\n if len(approx) == 4:\\n # print(approx)\\n target = approx\\n break\\n if target is not None:\\n \\\"\\\"\\\"\\n cv.drawContours(\\n self.original_image,\\n [target],\\n 0,\\n (255, 255, 255),\\n 5\\n )\\n \\\"\\\"\\\"\\n self.output_image = copy.deepcopy(self.original_image)\\n for p in target:\\n cv.circle(self.output_image, tuple(p[0]), 4, (255, 255, 255), 5)\\n return (self.output_image, target)\",\n \"def get_neighbours(self, cell):\\n\\t\\tx,y = cell.find_id()\\n\\t\\tlength = self.space.shape[1]\\n\\t\\twidth = self.space.shape[0]\\n\\t\\tif (length == 0 or width == 0 or x < 0 or x >= length or y < 0 or y >= width):\\n\\t\\t\\treturn []\\n\\t\\tneighs = [(i,j) for i in range(y-1,y+2) if 0<=i<width for j in range(x-1,x+2) if 0<=j<length]\\n\\t\\tneighbours = []\\n\\t\\tfor neigh in neighs:\\n\\t\\t\\tneighbours.append(self.space[neigh[0],neigh[1]])\\n\\t\\treturn neighbours\",\n \"def get_shapes(self):\\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\\n X = []\\n backmap = {}\\n rad = 3\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\\n colours[i][j] = m\\n X.append(m)\\n backmap[k] = (i,j)\\n print(np.shape(X))\\n Z = linkage(X, 'ward')\\n Q = fcluster(Z, self.thresh, criterion='distance')\\n\\n closenesses = []\\n for k,cls in enumerate(Q):\\n i,j = backmap[k]\\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\\n minidx = np.argmin(closenesses)\\n bgcls = Q[minidx]\\n\\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\\n img4 = self.img2.copy()\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n cls = Q[k]\\n if cls == bgcls:\\n continue\\n col = blibs[(cls-1)]\\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\\n\\n write_img(\\\"./out/test_classes.png\\\", img4)\\n self.classimg = img4\\n\\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\\n mx = np.max(Q)\\n for k,cls in enumerate(Q):\\n if cls == bgcls:\\n continue\\n\\n if cls == mx:\\n plotcls = bgcls\\n else:\\n plotcls = cls\\n i,j = backmap[k]\\n A[i][j] = plotcls\\n\\n self.res = A\",\n \"def get_table_corner_points(img):\\n\\n img_height, img_width, img_channels = img.shape\\n lower_bounds,upper_bounds = get_table_color_bounds() # Get the bounds for the table felt color\\n\\n \\\"\\\"\\\"\\n Table Image Masking\\n \\\"\\\"\\\"\\n res = cv2.cvtColor(img,cv2.COLOR_BGR2HSV) # Convert image to HSV color space\\n mask = cv2.inRange(res,lower_bounds,upper_bounds) # Get image mask from bounds\\n res = cv2.bitwise_and(img,img,mask = mask) # Mask the image\\n\\n \\\"\\\"\\\"\\n Contour Detection\\n \\\"\\\"\\\"\\n imgray = cv2.cvtColor(res,cv2.COLOR_BGR2GRAY) # Get res in gray color space\\n tmp,thresh = cv2.threshold(imgray,255,255,255) # Threshold on the gray image\\n retr = cv2.RETR_EXTERNAL # Contour parameters\\n mode = cv2.CHAIN_APPROX_SIMPLE\\n tmp, contours, hierarchy = cv2.findContours(thresh,retr,mode) # Get contours\\n res = np.zeros((img_height,img_width,3),np.uint8) # Blank image for contours\\n color = (255,255,255) # Contour drawing parameters\\n thickness = 3\\n cv2.drawContours(res,contours,-1,color,thickness) # Draw contours on blank image\\n\\n \\\"\\\"\\\"\\n Canny Detection\\n \\\"\\\"\\\"\\n blur = 9 # Blur parameter \\n res = cv2.medianBlur(res,blur) # Blur\\n res = cv2.Canny(res,100,150,apertureSize = 3) # Canny edge detection\\n\\n \\\"\\\"\\\"\\n Hough Line Detection\\n \\\"\\\"\\\"\\n rho = 0.75 # Hough parameters\\n theta = np.pi/180\\n threshold = 150\\n lines = cv2.HoughLines(res,rho,theta,threshold) # Get lines\\n\\n \\\"\\\"\\\"\\n K-Mean 4 Line Clustering\\n \\\"\\\"\\\"\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,10,1.0) # K-Means parameters\\n flags = cv2.KMEANS_PP_CENTERS\\n n = 4\\n max_iterations = 10 \\n compactness,labels,centers = cv2.kmeans(np.float32(lines),n,None,criteria,max_iterations,flags) # K-Means\\n \\n \\\"\\\"\\\"\\n Get And Return Points\\n \\\"\\\"\\\"\\n growth = 100 # Offset to expand corners\\n pts = _get_table_corners_from_lines_hough_space(centers,growth,img_width,img_height) # Gets the corner points\\n ''' \\n mask = np.zeros((img_height,img_width,3),np.uint8)\\n cv2.fillPoly(mask,np.array([pts],dtype = np.int32),(255,255,255))\\n show_img(mask)\\n cv2.resize(mask,(img.shape[0],img.shape[1]),fx = 2, fy = 2, interpolation = cv2.INTER_CUBIC)\\n show_img(mask*2)\\n res = cv2.bitwise_and(img,mask)\\n '''\\n return pts\",\n \"def drawcntMap(orgimg,filteredimg,wThresh,hThresh):\\r\\n _, contour, _ = cv2.findContours(filteredimg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\r\\n\\r\\n cnt = cv2.drawContours(orgimg.copy(), contour, -1, (0, 0, 255), 2) # To draw filtered contours on original image\\r\\n\\r\\n digitCnts = [] # contours to be surrounded by bounding boxes\\r\\n\\r\\n for c in contour:\\r\\n (x, y, w, h) = cv2.boundingRect(c)\\r\\n if w >= wThresh and h >= hThresh and w*h <20000: # Length filters to reduce noise\\r\\n cv2.rectangle(cnt,(x,y),(x+w,y+h),[0,255,0],2)\\r\\n digitCnts.append(c)\\r\\n\\r\\n return cnt, digitCnts\",\n \"def extract(self, files):\\n for i in range(len(files)):\\n print(files[i])\\n img = cv2.imread('{}/{}'.format('{}/{}/{}'.format(DIR_2DST_Mask, self.patient, self.plan), files[i]), 0)\\n\\n \\\"\\\"\\\"\\n Find the indices of array elements that are non-zero, i.e,\\n find the pixels' positions that represents the respiratory\\n functions (pixels in the respiratory function are brighter).\\n \\\"\\\"\\\"\\n color_pts = np.argwhere(img > 70)\\n\\n \\\"\\\"\\\"\\n Sorts the pixels according to their x coordenate.\\n Obs: np.argwhere inverts x and y, it's like (y, x), because of it,\\n the parameter of itemgetter is 1 (to get x coordinate)\\n \\\"\\\"\\\"\\n lcolor_pts = sorted(color_pts.tolist(), key=itemgetter(1))\\n\\n \\\"\\\"\\\"\\n If there is no pixel representing the respiratory function\\n (i.e., lighter pixel) it creates an empty image (without any\\n respiratory function)\\n \\\"\\\"\\\"\\n if len(lcolor_pts) == 0:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open(\\n # '{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], []))\\n # file.close()\\n\\n continue\\n\\n # Reverse the coordinates and store the result in lordered_pts list\\n lordered_pts = []\\n for j in range(len(lcolor_pts)):\\n lordered_pts.append(lcolor_pts[j][::-1])\\n\\n \\\"\\\"\\\"\\n Convert pixels coordinates into a tuples and check which column\\n has pixels that corresponding to diaphragmatic level\\n Obs. There are some columns that doesnt have any pixel that\\n correpond to diaphragmatic level.\\n \\\"\\\"\\\"\\n # Columns that have a pixel corresponding diaphragmatic level\\n lcolumn_available = []\\n for j in range(len(lordered_pts)):\\n lordered_pts[j] = tuple(lordered_pts[j])\\n lcolumn_available.append(lordered_pts[j][0])\\n lcolumn_available = list(set(lcolumn_available))\\n # print(\\\"Ordered points: \\\", lordered_pts)\\n # print(\\\"Columns available: \\\", lcolumn_available)\\n\\n \\\"\\\"\\\"\\n If there is not enough columns to build a respiratory pattern,\\n create a blank image\\n \\\"\\\"\\\"\\n if len(lcolumn_available) < 20:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n continue\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n first column, assign to it the value of the second y coordinate\\n \\\"\\\"\\\"\\n if lcolumn_available[0] is not 0:\\n y = max(\\n [x for x in lordered_pts if x[0] == lcolumn_available[0]],\\n key=itemgetter(1))[1]\\n lordered_pts.insert(0, (0, y))\\n lcolumn_available.insert(0, 0)\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n last column, assign to it the value of the penultimate y coordinate\\n available\\n \\\"\\\"\\\"\\n if lcolumn_available[-1] is not 49:\\n lordered_pts.append(\\n (49, lordered_pts[len(lcolumn_available)][1]))\\n lcolumn_available.append(49)\\n\\n \\\"\\\"\\\"\\n Get the biggest y value in each column that represents the\\n diaphragmatic level\\n \\\"\\\"\\\"\\n column = 0\\n lcolumn = []\\n ldiaphragm_pts = []\\n for j in range(50):\\n # Get the column's points\\n lcolumn = [x for x in lordered_pts if x[0] == column]\\n # print('{}: {}'.format(j, lcolumn))\\n\\n if len(lcolumn) > 0:\\n ldiaphragm_pts.append(\\n max(lcolumn, key=itemgetter(1))) # Get the biggest y\\n else:\\n # Get the y value from the previous column\\n lcolumn_available.insert(column, column)\\n ldiaphragm_pts.append((column, ldiaphragm_pts[-1][1]))\\n column += 1\\n lcolumn = []\\n\\n # Draw diaphragmatic level\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n j = 0\\n while(j < len(lcolumn_available) - 1):\\n cv2.line(\\n diaphragmatic_lvl,\\n ldiaphragm_pts[j], ldiaphragm_pts[j + 1],\\n (0, 0, 255), 1)\\n j = j + 1\\n\\n lcolumn_available = []\\n\\n print(\\\"Diaphragmatic's points: \\\", ldiaphragm_pts)\\n cv2.imshow('Diaphragmatic level', diaphragmatic_lvl)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open('{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], ldiaphragm_pts))\\n # file.close()\\n\\n # return ldiaphragm_pts\",\n \"def cfdProcessElementTopology(self):\\r\\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \\r\\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\\r\\n\\r\\n ## (list of lists) list of face indices forming each element\\r\\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n #populates self.elementNeighbours\\r\\n for iFace in range(self.numberOfInteriorFaces):\\r\\n own=self.owners[iFace]\\r\\n nei=self.neighbours[iFace]\\r\\n \\r\\n #adds indices of neighbour cells\\r\\n self.elementNeighbours[own].append(nei)\\r\\n self.elementNeighbours[nei].append(own)\\r\\n \\r\\n #adds interior faces\\r\\n self.elementFaces[own].append(iFace)\\r\\n self.elementFaces[nei].append(iFace)\\r\\n \\r\\n #adds boundary faces ('patches')\\r\\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\\r\\n own=self.owners[iFace]\\r\\n self.elementFaces[own].append(iFace)\\r\\n \\r\\n ## List of lists containing points forming each element\\r\\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n \\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\\r\\n \\r\\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\\r\\n \\r\\n ## Upper coefficient indices (owners)\\r\\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n ## Lower coefficient indices (owners)\\r\\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n ## Element number from 1 to numberOfElements + 1\\r\\n iNb=1\\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n \\r\\n #skip if it is a boundary face\\r\\n if faceIndex > self.numberOfInteriorFaces-1:\\r\\n continue\\r\\n \\r\\n own = self.owners[faceIndex]\\r\\n nei = self.neighbours[faceIndex]\\r\\n \\r\\n if iElement == own:\\r\\n self.upperAnbCoeffIndex[faceIndex] = iNb\\r\\n elif iElement == nei:\\r\\n self.lowerAnbCoeffIndex[faceIndex] = iNb\\r\\n \\r\\n iNb = iNb +1\",\n \"def GetInteriorEdgesPent(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesPent()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesPent()\\n\\n sorted_all_edges = np.sort(self.all_edges,axis=1)\\n sorted_boundary_edges = np.sort(self.edges,axis=1)\\n\\n x = []\\n for i in range(self.edges.shape[0]):\\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\\n pos_interior_edges = np.where(interior_edges==0)[0]\\n if pos_interior_edges.shape[0] != 0:\\n x.append(pos_interior_edges)\\n\\n edge_aranger = np.arange(self.all_edges.shape[0])\\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\\n interior_edges = self.all_edges[edge_aranger,:]\\n\\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\\n edge_flags[edge_aranger] = 0\\n\\n self.interior_edges = interior_edges\\n return interior_edges, edge_flags\",\n \"def run_connected_components(img, viz=False):\\n\\n fg = img.foreground_mask(cfg.COLOR_TOL, ignore_black=True)\\n if viz:\\n cv2.imwrite(\\\"debug_imgs/mask.png\\\", fg.data)\\n\\n groups = get_cluster_info(fg)\\n\\n if viz:\\n display_grasps(img, groups)\\n\\n return groups\",\n \"def getContours(image, copyImage):\\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n for contour in contours:\\n area = cv.contourArea(contour)\\n \\n if area > 500.0:\\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\\n perimeter = cv.arcLength(contour, True)\\n \\n # Approximates to the nearest polygon\\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\\n objectCoordinates = len(approx)\\n\\n # Returns the x, y and height width of the polygon\\n x, y, w, h = cv.boundingRect(approx)\\n\\n if objectCoordinates == 3:\\n objectShape = \\\"Triangle\\\"\\n elif objectCoordinates == 4:\\n ratio = w / float(h)\\n if ratio >= 0.95 and ratio <= 1.05:\\n objectShape = \\\"Square\\\"\\n else: objectShape = \\\"Rectangle\\\"\\n else: objectShape = \\\"Circle\\\" \\n\\n \\n\\n # Draw rectangles around the images\\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))\",\n \"def get_contour_lims(frame: imageType) -> Tuple[int, int, int, int]:\\n largest_contour = get_largest_contour(frame)\\n if largest_contour is not None:\\n (x, y, w, h) = cv2.boundingRect(largest_contour)\\n else:\\n (x, y, w, h) = (0, 0, 0, 0)\\n return (x, y, w, h)\",\n \"def findFours(self):\\n\\n for i in range(6):\\n for j in range(7):\\n if self.board[i][j] != ' ':\\n # check if a vertical four-in-a-row starts at (i, j)\\n if self.verticalCheck(i, j):\\n self.highlightFour(i, j, 'vertical')\\n \\n # check if a horizontal four-in-a-row starts at (i, j)\\n if self.horizontalCheck(i, j):\\n self.highlightFour(i, j, 'horizontal')\\n \\n # check if a diagonal (either way) four-in-a-row starts at (i, j)\\n # also, get the slope of the four if there is one\\n diag_fours, slope = self.diagonalCheck(i, j)\\n if diag_fours:\\n self.highlightFour(i, j, 'diagonal', slope)\",\n \"def vis_detections(self,im, class_name, dets, thresh=0.5):\\n\\t\\tinds = np.where(dets[:, -1] >= thresh)[0]\\n\\t\\tif len(inds) == 0:\\n\\t\\t\\treturn None, None\\n\\n\\t\\tcenters = []\\n\\t\\tfor i in inds:\\n\\t\\t\\tbbox = dets[i, :4]\\n\\t\\t\\tscore = dets[i, -1]\\n\\t\\t\\tim = im.copy()\\n\\t\\t\\tcv2.rectangle(im,(bbox[0],bbox[1]),(bbox[2],bbox[3]),(0,0,255))\\n\\n\\t\\t\\tcenter = np.zeros(2)\\n\\t\\t\\tcenter[0] = bbox[0] + (bbox[2] - bbox[0])/2.0\\n\\t\\t\\tcenter[1] = bbox[1] + (bbox[3] - bbox[1])/2.0\\n\\t\\t\\tprint center\\n\\t\\t\\tim[center[1]-20:center[1]+20,center[0]-20:center[0]+20,:] = [0,0,255]\\n\\n\\t\\t\\tcenters.append(center)\\n\\t\\t\\t\\n\\t\\treturn centers,im\",\n \"def load_drawings(self, contours, append=False):\\n\\n CONTOUR_IS_INTERPOLATED = 1\\n\\n if not append:\\n self.drawings = defaultdict(list)\\n\\n endorser_contour_lookup = defaultdict(set)\\n for cnt_id, contour in contours.iterrows():\\n for editor in set([edit['username'] for edit in contour['edits']]):\\n endorser_contour_lookup[editor].add(cnt_id)\\n endorser_contour_lookup[contour['creator']].add(cnt_id)\\n\\n grouped = contours.groupby('section')\\n\\n for i_or_sec, group in grouped:\\n # if i_or_sec not in self.data_feeder.sections: continue ## IS TIHS NECESSARY ?\\n for contour_id, contour in group.iterrows():\\n vertices = contour['vertices']\\n contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\\n self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\\n linecolor='r', section=i_or_sec, type=contour_type,\\n side=contour['side'],\\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else False,\\n side_manually_assigned=contour['side_manually_assigned'],\\n edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'],\\n contour_id=contour_id)\\n\\n # grouped = contours.groupby('position')\\n #\\n # for i_or_sec, group in grouped:\\n # for contour_id, contour in group.iterrows():\\n # vertices = contour['vertices']\\n # contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\\n # self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\\n # linecolor='r', index=i_or_sec, type=contour_type,\\n # side=contour['side'],\\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else True,\\n # edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'])\",\n \"def find_contours(thresh):\\n thresh = thresh.astype(np.uint8)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n\\n # filter outer contours\\n filtered_cont = []\\n for i in range(len(contours)):\\n if hierarchy[0, i, 3] == NO_PARENT:\\n filtered_cont.append(contours[i])\\n\\n return filtered_cont\",\n \"def detectBlocksInDepthImage(self):\\n depth_range_dict = {'1':[173,178],'2':[169,172],'3':[165,169],'4':[159,163],'5':[156,158],'6':[147,155],'7':[139,146],'8':[132,138]}\\n depth_frame = self.DepthFrameRaw\\n rgb_frame = self.VideoFrame\\n rgb_frame = cv2.resize(rgb_frame, (640,480))\\n depth_frame = cv2.resize(depth_frame, (640, 480))\\n np.clip(depth_frame,0,2**10 - 1,depth_frame)\\n depth_frame >>= 2\\n depth_frame = depth_frame.astype(np.uint8)\\n filt_block = []\\n for k,v in depth_range_dict.items():\\n thresh = cv2.inRange(depth_frame,v[0],v[1])\\n cv2.imwrite(\\\"/home/student/armlab-w20/log/img.jpeg\\\", thresh)\\n _ , contours, _ = cv2.findContours(thresh, 1, 2)\\n for cnt in contours:\\n area = cv2.contourArea(cnt)\\n if area > 400 and area < 700:\\n block = []\\n rect = cv2.minAreaRect(cnt)\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n color = self.determine_color(rgb_frame, box)\\n org = (box[0][0], box[0][1])\\n rgb_frame = cv2.putText(rgb_frame, color, org,cv2.FONT_HERSHEY_SIMPLEX , 0.5 ,(0,0,0),2, cv2.LINE_AA)\\n rgb_frame = cv2.drawContours(rgb_frame,[box],0,(0,0,0),0)\\n self.VideoFrame = rgb_frame\\n block.append(box)\\n block.append(int(k))\\n block.append(color)\\n filt_block.append(block)\\n return filt_block\",\n \"def watershed(self, debug=False):\\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg, sure_fg)\\n ret, markers = cv2.connectedComponents(sure_fg)\\n markers += 1\\n markers[unknown == 255] = 0\\n markers = cv2.watershed(self.img, markers)\\n self.add_color(markers)\\n if debug:\\n cv2.imshow(\\\"fg\\\", unknown)\\n cv2.imshow(\\\"op\\\", opening)\\n cv2.imshow(\\\"o3\\\", sure_bg)\",\n \"def analyze(self, frame: np.ndarray, debug: bool) -> Tuple[float, float]:\\n gate_center = self.output_class(250, 250)\\n filtered_frame = self.combined_filter(frame, display_figs=False)\\n filtered_frame_copies = [filtered_frame for _ in range(3)]\\n stacked_filter_frames = np.concatenate(filtered_frame_copies, axis=2)\\n mask = cv.inRange(\\n stacked_filter_frames, np.array([100, 100, 100]), np.array([255, 255, 255])\\n )\\n contours = cv.findContours(mask, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)[-2]\\n if len(contours) > 0:\\n contours.sort(reverse=True, key=self.findStraightness)\\n cnts = contours[:2]\\n rects = [cv.minAreaRect(c) for c in cnts]\\n centers = [np.array(r[0]) for r in rects]\\n boxpts = [cv.boxPoints(r) for r in rects]\\n box = [np.int0(b) for b in boxpts]\\n for b in box:\\n cv.drawContours(stacked_filter_frames, [b], 0, (0, 0, 255), 5)\\n if len(centers) >= 2:\\n gate_center = (centers[0] + centers[1]) * 0.5\\n if self.__ema is None:\\n self.__ema = gate_center\\n else:\\n self.__ema = (\\n self.__alpha * gate_center + (1 - self.__alpha) * self.__ema\\n )\\n gate_center = (int(self.__ema[0]), int(self.__ema[1]))\\n # TODO: clean this up via hyperparam or move to gate center algo\\n # if len(self.__past_centers) < 15:\\n # \\tself.__past_centers += [gate_center]\\n # else:\\n # \\tself.__past_centers.pop(0)\\n # \\tself.__past_centers += [gate_center]\\n # gate_center = sum(self.__past_centers) / len(self.__past_centers)\\n # gate_center = (int(gate_center[0]), int(gate_center[1]))\\n cv.circle(stacked_filter_frames, gate_center, 10, (0, 255, 0), -1)\\n\\n if debug:\\n return (gate_center[0], gate_center[1]), (frame, stacked_filter_frames)\\n return (gate_center[0], gate_center[1])\",\n \"def consolidate_instances_all_way(self, stats, segmented_instances):\\n\\n img = np.zeros(segmented_instances.shape).astype(np.uint8)\\n\\n #get all pixel labels in the segmented_instances mask\\n segment_numbers = np.unique(segmented_instances)\\n\\n # remove the background label\\n segment_numbers=segment_numbers[segment_numbers!=0]\\n\\n end_points = np.empty((len(segment_numbers),),dtype=np.object_)\\n end_points.fill([])\\n\\n for curr_segment in segment_numbers:\\n idx=[]\\n i=curr_segment-1\\n if curr_segment!=0:\\n #Show all segments of curr_segment. Only useful to view results\\n img[segmented_instances== curr_segment]= 255\\n #get indeces of the segments for curr_segment\\n idx = np.argwhere(segmented_instances == curr_segment)\\n if len(idx>0):\\n end_points[i]= self._get_end_points(segmented_instances, i, \\\\\\n stats, idx)\\n # add point markers and lines connecting each end point to centroid.\\n # useful only to view results\\n \\\"\\\"\\\"for pt_num, pt in enumerate(end_points[i]):\\n cv2.circle(img, (pt[0],pt[1]), 3, 100, -1)\\n cv2.line(img,(pt[0],pt[1]),\\\\\\n (stats['centroid'][i,0], stats['centroid'][i,1]),150,2)\\n cv2.circle(img, (stats['centroid'][i,0], stats['centroid'][i,1]), 3, 200, -1)\\\"\\\"\\\"\\n #self.showme(img, 'line '+str(i))\\n\\n # cluster segments into stem instances\\n cluster_mask, clustered_instances = self._cluster_segments_all_way(segmented_instances,\\\\\\n segment_numbers, end_points, \\\\\\n stats)\\n\\n #put all instances in one layer\\n if len(cluster_mask)>0:\\n single_layer_cluster_mask=np.zeros(cluster_mask[0].shape)\\n for i in xrange(len(cluster_mask)):\\n single_layer_cluster_mask[cluster_mask[i]>0]= i+1\\n\\n # self.showObjects(clustered_instances);\\n return single_layer_cluster_mask, clustered_instances\",\n \"def get_contour(atom_list):\\n initial = [atom for atom in atom_list if ((0 < len(identify_bonds(atom, atom_list)) < 3) and (check_connected(atom, identify_bonds(atom, atom_list)) == False))]\\n \\n extra_1 = []\\n for atom in atom_list:\\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n for i in neighbours:\\n neighbours2 = [bond[0] for bond in identify_bonds(i, atom_list)]\\n for j in neighbours2:\\n if j in initial:\\n extra_1.append(atom)\\n\\n extra_2 = []\\n for atom in atom_list:\\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n check = 0\\n for i in neighbours:\\n if i in initial:\\n check += 1\\n if ((check == 2) and (atom not in initial)):\\n extra_2.append(atom) \\n return (initial + extra_1 + extra_2)\",\n \"def get_patch_centers(self):\\n rows, cols = np.where(self.inv_overlap_mask)\\n patch_centers = tuple(zip(rows, cols))\\n # diff = np.diff(patch_centers)\\n # ind_stop_cont = np.where(np.abs(np.diff(np.reshape(diff, diff.shape[0]))) > 1)[0][0]\\n self.patch_centers = patch_centers[:: self.sampling_int // 2]\\n print(\\\"# of samples: {}\\\".format(len(self.patch_centers)))\",\n \"def get_descriptors(image,filtered_coords,wid=5):\\n desc = []\\n for coords in filtered_coords:\\n patch = image[coords[0]-wid:coords[0]+wid+1,\\n coords[1]-wid:coords[1]+wid+1].flatten()\\n desc.append(patch)\\n return desc\",\n \"def figure_detection_border(self, gray_img, binary_img, frame_position, time_stamp, contours_list_title):\\n img = gray_img.copy()\\n height, width = gray_img.shape\\n # # edge detection\\n edges = cv2.Canny(img, 31, 180, apertureSize=3)\\n # contour detection\\n contours = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[1]\\n # default values\\n table_x = -1\\n table_y = -1\\n # minimum values that a figure can have\\n table_w = 450\\n table_h = 200\\n\\n for contour in contours:\\n # get rectangle bounding contour\\n [x, y, w, h] = cv2.boundingRect(contour)\\n # Don't plot small false positives that aren't text\\n if w > table_w and h > table_h:\\n table_x = x\\n table_y = y\\n table_h = h\\n table_w = w\\n if not table_x == -1 and not table_y == -1 and not table_h > height - 50:\\n\\n if self.first:\\n # save cropped figure\\n cv2.imwrite(\\\"figures/\\\" + str(frame_position) + \\\".jpg\\\",\\n gray_img[table_y:table_y + table_h, table_x:table_x + table_w])\\n\\n self.first = False\\n self.previous_h = table_h\\n self.previous_w = table_w\\n # add details to frame details dictionary\\n # method call\\n self.ops_obj.add_to_dict_from_figure(frame_position, time_stamp)\\n # method call - to get text around the figure\\n self.text_extraction_obj.extract_text_string(binary_img[0:table_y, 0:width], frame_position, time_stamp,\\n contours_list_title)\\n\\n else:\\n if self.previous_w == table_w or self.previous_h == table_h:\\n # this scenario is not valid for detect relevant borders\\n pass\\n else:\\n # save cropped figure\\n cv2.imwrite(\\\"figures/\\\" + str(frame_position) + \\\".jpg\\\",\\n gray_img[table_y:table_y + table_h, table_x:table_x + table_w])\\n\\n self.previous_h = table_h\\n self.previous_w = table_w\\n # add details to frame details dictionary\\n # method call\\n self.ops_obj.add_to_dict_from_figure(frame_position, time_stamp)\\n # method call - to get text around the figure\\n self.text_extraction_obj.extract_text_string(binary_img[0:table_y, 0:width], frame_position,\\n time_stamp, contours_list_title)\\n else:\\n # method call\\n self.borderless_figure_detector_obj.figure_detection_borderless(gray_img, binary_img,\\n frame_position, time_stamp,\\n contours_list_title)\",\n \"def get_integral_descriptors(image,filtered_coords,wid=5):\\n desc = []\\n for coords in filtered_coords:\\n patch = image[coords[0]-wid:coords[0]+wid+1,\\n coords[1]-wid:coords[1]+wid+1]\\n desc.append(patch)\\n return desc\",\n \"def get_contours(img):\\n contours, hierarchy = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return contours, hierarchy[0]\",\n \"def enumerate_detector(det, thresholds, shot_ok=None, tiles=None, nimages=np.inf, startimg=0, stopimg=np.inf, correction=False, progress=True):\\n global terminated\\n Ncorrect = 64\\n correctionphotonthres = 3000\\n if not isinstance(det, h5py.Group):\\n raise TypeError('det should be a h5 group')\\n if tiles is None:\\n tiles = [k for k in det.keys() if 'tile' in k]\\n else:\\n newtiles = []\\n for t in tiles:\\n if t in det:\\n newtiles.append(t)\\n elif f'tile{t}' in det:\\n newtiles.append(f'tile{t}')\\n else:\\n raise KeyError(f'tile {t} not found')\\n tiles = newtiles\\n datanames = [(f'{det.name}/{t}/data') for t in tiles]\\n filename = det.file.filename\\n\\n nshots = det[f'{tiles[0]}/data'].shape[0]\\n startimg = int(np.clip(startimg, 0, nshots))\\n stopimg = int(np.clip(stopimg, startimg, nshots))\\n tileshape = det[f'{tiles[0]}/data'].shape[1:]\\n correctmask = [correctionmask(det[t]['absfft0/mean'], Ncorrect) for t in tiles]\\n if shot_ok is None:\\n shot_ok = np.ones(nshots, np.bool)\\n ind_filtered = 0\\n data = np.zeros((len(tiles), *tileshape))\\n willread = np.copy(shot_ok)\\n willread[:startimg] = False\\n willread[stopimg:] = False\\n with datasetreader(datanames, filename, sizecache=10, willread=willread) as reader:\\n\\n for ind_orig in range(startimg, stopimg):\\n if not shot_ok[ind_orig]:\\n continue\\n if ind_filtered >= nimages or terminated != 0:\\n return\\n if progress and ind_filtered % 10 == 0:\\n print(ind_filtered, end=' ', flush=True)\\n\\n for it, t in enumerate(tiles):\\n cdat = np.array(reader[ind_orig, it], dtype=np.float, order='C')\\n if correction:\\n correct(cdat, correctionphotonthres, Ncorrect, correctmask[it])\\n data[it, ...] = cdat\\n ev, number, scatter = getstats(data, thresholds)\\n\\n yield (ind_filtered, ind_orig, data, ev, number, scatter)\\n\\n ind_filtered += 1\",\n \"def get_cntr_points(self, contour, img_size):\\n res_arr = []\\n # for each row\\n for row in range(img_size):\\n tmp_arr = []\\n # for each column\\n for col in range(img_size):\\n # if point in contour\\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\\n # add point to current line\\n tmp_arr.append([row,col])\\n if len(tmp_arr):\\n # add current line to result array\\n res_arr.append(tmp_arr)\\n return res_arr\",\n \"def GetMatchedSubContourLists(\\n scListRef,\\n scList,\\n allValsByFrame,\\n orderOfSCsByValue,\\n splitLength=1,\\n fixedNumInteriorPoints=None,\\n):\\n ## NOT DONE! MERGE LATER??\\n return simplifiedSCListRef, simplifiedSCList\",\n \"def findings_2_idx(findings, corner_2_idx, funcx, funcy):\\n idx = []\\n for finding in findings:\\n x, y = finding\\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\\n idx.extend([corner_2_idx(c) for c in mesh])\\n\\n return np.unique(idx)\",\n \"def draw_all_position_patterns(img, found, contours):\\n draw_img = img.copy()\\n for i in found:\\n rect = cv2.minAreaRect(contours[i])\\n box = np.int0(cv2.cv.BoxPoints(rect))\\n cv2.drawContours(draw_img, [box], 0, (0, 0, 255), 2)\\n show(draw_img)\",\n \"def enumerate_detector(det, thresholds, shot_ok=None, tiles=None, nimages=np.inf, stats=True, correction=False, progress=True, photonfunction=None):\\n Ncorrect = 64\\n correctionphotonthres = 3000\\n if not isinstance(det, h5py.Group):\\n raise TypeError('det should be a h5 group')\\n if tiles is None:\\n tiles = [k for k in det.keys() if 'tile' in k]\\n else:\\n newtiles = []\\n for t in tiles:\\n if t in det:\\n newtiles.append(t)\\n elif f'tile{t}' in det:\\n newtiles.append(f'tile{t}')\\n else:\\n raise KeyError(f'tile {t} not found')\\n tiles = newtiles\\n multitiles = not (len(tiles) == 1 and 'data' in det[tiles[0]])\\n mincorners = []\\n maxcorners = []\\n rots = []\\n datanames = []\\n filename = det.file.filename\\n nshots = det[f'{tiles[0]}/data'].shape[0]\\n correctmask = []\\n for t in tiles:\\n d = det[t]\\n offset = np.rint(d.attrs['detector_tile_position_in_pixels'])\\n rot = int(d.attrs['detector_rotation_steps'][0])\\n rots.append(rot)\\n n, a, b = d['data'].shape\\n if n != nshots:\\n raise ValueError('tiles should have same number of shots')\\n shape = ((a, b), (-b, a), (-a, -b), (b, -a))[rot % 4]\\n corners = (offset, (shape + offset))\\n mincorners.append(np.min(corners, axis=0))\\n maxcorners.append(np.max(corners, axis=0))\\n datanames.append(f'{d.name}/data')\\n if correction:\\n correctmask.append(correctionmask(det[t]['absfft0/mean'], Ncorrect))\\n\\n globaloffset = np.floor(np.min(mincorners, axis=0)).astype(int)\\n extent = [fastlen(x) for x in (np.ceil(np.max(maxcorners, axis=0)) - globaloffset)]\\n startx, starty = [list(s) for s in (np.floor(mincorners - globaloffset).astype(int)).T]\\n\\n if shot_ok is None:\\n shot_ok = np.ones(nshots, np.bool)\\n assembled = np.zeros(extent, np.float64)\\n global terminated\\n ind_filtered = 0\\n with datasetreader(datanames, filename, willread=shot_ok) if multitiles else arrayreader(det[tiles[0]]['data']) as reader:\\n for ind_orig in range(nshots):\\n if not shot_ok[ind_orig]:\\n continue\\n if ind_filtered >= nimages or terminated != 0:\\n return\\n if progress and ind_filtered % 100 == 0:\\n print(ind_filtered, end=' ', flush=True)\\n\\n for t in range(len(tiles)):\\n if multitiles:\\n tile = np.asarray(reader[ind_orig, t], order='C', dtype=np.float64)\\n if correction:\\n correct(tile, correctionphotonthres, Ncorrect, correctmask[t], rots[t], assembled, startx[t], starty[t])\\n else:\\n place(tile, rots[t], assembled, startx[t], starty[t])\\n else:\\n if correction:\\n tile = np.asarray(reader[ind_orig], order='C', dtype=np.float64)\\n correct(tile, correctionphotonthres, Ncorrect, correctmask[t], rots[t], assembled, startx[t], starty[t])\\n else:\\n assembled = np.asarray(np.rot90(reader[ind_orig], rots[t]), order='C', dtype=np.float64)\\n \\n\\n \\n numberfromfunc = photonfunction(assembled) if photonfunction is not None else None\\n if thresholds is not None:\\n if stats:\\n ev, number, scatter = getstats(assembled, thresholds)\\n yield (ind_filtered, ind_orig, np.copy(assembled), ev, number, scatter, numberfromfunc)\\n else:\\n number = getphotons(assembled, thresholds)\\n yield (ind_filtered, ind_orig, np.copy(assembled), None, number, None, numberfromfunc)\\n else: \\n yield (ind_filtered, ind_orig, np.copy(assembled), None, None, None, numberfromfunc)\\n\\n \\n ind_filtered += 1\",\n \"def boundary_contour(self, time):\\n ti = np.where(time == self.times)[0][0]\\n image_mask = binary_erosion(binary_fill_holes(binary_dilation(self.masks[ti])))\\n padded_mask = np.pad(image_mask, 1, 'constant', constant_values=0)\\n c_out = find_contours(padded_mask, level=0.5, fully_connected=\\\"high\\\")\\n x_cont = self.x[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\\n y_cont = self.y[ti][np.floor(c_out[0][:, 0]).astype(int), np.floor(c_out[0][:, 1]).astype(int)]\\n ordered_coords = np.vstack([x_cont, y_cont])\\n return ordered_coords\",\n \"def find_targets(contours, frame):\\n # If there aren't any contours present, return frame without drawing\\n if len(contours) == 0:\\n return frame\\n # Copy frame, TODO why do we need to do this?\\n image = frame.copy()\\n screen_height, screen_width, _ = image.shape;\\n # TODO: Why subtract?\\n center_x = screen_width / 2 - .5\\n center_y = screen_height / 2 - .5\\n # List for storing found targets\\n targets = []\\n\\n if len(contours) >= 2:\\n # Sort contours in descending order by size\\n contours.sort(key=lambda contour: cv2.contourArea(contour), reverse=True)\\n\\n valid_contours = []\\n for contour in contours:\\n # Calculate areas of contour\\n contour_area = cv2.contourArea(contour)\\n if contour_area >= MIN_CONTOUR_SIZE:\\n # Get moments of contour for centroid calculations\\n moments = cv2.moments(contour)\\n # Find centroid of contour\\n if moments[\\\"m00\\\"] != 0:\\n cx = int(moments[\\\"m10\\\"] / moments[\\\"m00\\\"])\\n cy = int(moments[\\\"m01\\\"] / moments[\\\"m00\\\"])\\n else:\\n cx, cy = 0, 0\\n\\n ### CALCULATE CONTOUR ROTATION BY FITTING ELLIPSE ###\\n rotation = get_ellipse_rotation(image, contour)\\n\\n ### DRAW CONTOUR ###\\n # Draw white circle at center of contour\\n cv2.circle(image, (cx, cy), 6, (255, 255, 255))\\n\\n # Draw contour in green\\n cv2.drawContours(image, [contour], 0, (0, 200, 0), 1)\\n\\n # Append important info to array\\n valid_contours.append({\\\"cx\\\": cx, \\\"cy\\\": cy, \\\"rotation\\\": rotation})\\n\\n # Sort array based on coordinates (left to right) to make sure contours are adjacent\\n valid_contours.sort(key=lambda contour: contour[\\\"cx\\\"])\\n\\n # Find targets from contours\\n for i in range(len(valid_contours) - 1):\\n # Check rotation of adjacent contours\\n tilt_left = valid_contours[i][\\\"rotation\\\"]\\n tilt_right = valid_contours[i + 1][\\\"rotation\\\"]\\n\\n # Contour coordinates\\n cx_left = valid_contours[i][\\\"cx\\\"]\\n cx_right = valid_contours[i + 1][\\\"cx\\\"]\\n cy_left = valid_contours[i][\\\"cy\\\"]\\n cy_right = valid_contours[i + 1][\\\"cy\\\"]\\n\\n # If contour angles are opposite\\n # Negative tilt -> Rotated to the right\\n # NOTE: if using rotated rect (min area rectangle), negative tilt means rotated to left\\n # If left contour rotation is tilted to the left then skip iteration\\n # If right contour rotation is tilted to the right then skip iteration\\n if (len(valid_contours) == 2) or (np.sign(tilt_left) != np.sign(tilt_right) and\\n not (tilt_left > 0 and cx_left < cx_right or tilt_right > 0 and cx_right < cx_left)):\\n\\n target_cx = (cx_left + cx_right) / 2\\n target_cy = (cy_left + cy_right) / 2\\n\\n target_yaw = calculate_yaw(target_cx, center_x)\\n target_pitch = calculate_pitch(target_cy, center_y)\\n\\n targets.append({\\\"cx\\\": target_cx,\\n \\\"cy\\\": target_cy,\\n \\\"yaw\\\": target_yaw,\\n \\\"pitch\\\": target_pitch})\\n\\n # Check if there are targets seen\\n if len(targets) > 0:\\n # Get target with smallest yaw\\n nearest_target = min(targets, key=lambda target: math.fabs(target[\\\"yaw\\\"]))\\n # Write yaw of target in corner of image\\n cv2.putText(image, \\\"Yaw: %.3f\\\" % nearest_target[\\\"yaw\\\"], (1, 12), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255))\\n # Draw line at center of target\\n cv2.line(image, (int(nearest_target[\\\"cx\\\"]), screen_height), (int(nearest_target[\\\"cx\\\"]), 0), (255, 0, 0), 1)\\n # Draw line at center of screen\\n cv2.line(image, (round(center_x), screen_height), (round(center_x), 0), (255, 255, 255), 1)\\n\\n # Send our final data to NetworkTables\\n table.putBoolean(\\\"target_present\\\", True)\\n table.putNumber(\\\"targets_seen\\\", len(targets))\\n table.putNumber(\\\"target_yaw\\\", nearest_target[\\\"yaw\\\"])\\n table.putNumber(\\\"target_pitch\\\", nearest_target[\\\"pitch\\\"])\\n else:\\n table.putBoolean(\\\"target_present\\\", False)\\n table.putNumber(\\\"targets_seen\\\", 0)\\n table.putNumber(\\\"target_yaw\\\", 0)\\n table.putNumber(\\\"target_pitch\\\", 0)\\n table.putNumber(\\\"target_distance\\\", 0)\\n\\n return image\",\n \"def _check_intrusion(self, detections):\\n width, height = self.frame_size\\n\\n results = []\\n for i in range(len(detections)):\\n (bboxes, scores, classes, num_candidates) = detections[i]\\n\\n in_roi_cands = {}\\n for j in range(int(num_candidates[0])):\\n # Check if score passes the threshold.\\n if scores[0][j] < self.detect_threshold:\\n continue\\n # Check if the object in in the trigger list.\\n # XXX: Is it posssible to generate index that is not in the\\n # category_index list?\\n try:\\n label = self._category_index[int(classes[0][j])]\\n except KeyError:\\n continue\\n else:\\n if label not in self.triggers:\\n continue\\n # Check whether the object's bbox is in roi or not.\\n ymin, xmin, ymax, xmax = bboxes[0][j]\\n unnormalized_bbox = (xmin * width, ymin * height,\\n xmax * width, ymax * height)\\n if self._is_in_roi(unnormalized_bbox):\\n if not bool(in_roi_cands):\\n # This is the first detected object candidate\\n in_roi_cands = {\\\"bboxes\\\": [], \\\"scores\\\": [], \\\"labels\\\": []}\\n in_roi_cands[\\\"bboxes\\\"].append(bboxes[0][j].tolist())\\n in_roi_cands[\\\"scores\\\"].append(scores[0][j].tolist())\\n in_roi_cands[\\\"labels\\\"].append(label)\\n results.append(in_roi_cands)\\n return results\",\n \"def getValidNeighborsInformation(self, index, distances = False,coordinates=False,figuresOfMerit=False ):\\n try:\\n p = self.get_crds(index)\\n new_pnts = na.reshape(\\\\\\n na.inner(self.d124,\\\\\\n na.array([p[0],p[1],p[2],1])),\\\\\\n (124,3))\\n cx = new_pnts[:,0]\\n cy = new_pnts[:,1]\\n cz = new_pnts[:,2]\\n ind = na.nonzero((cx >=0 )*( cx < self.dim[0])*\\\\\\n (cy >=0 )*( cy < self.dim[1])*\\\\\\n (cz >=0 )*( cz < self.dim[2]))[0]\\n cx = na.take(cx,ind)\\n cy = na.take(cy,ind)\\n cz = na.take(cz,ind)\\n dst = na.take(self.ds124,ind)\\n \\n tind = self.get_ind(cx,cy,cz)\\n \\n # only keep points in current label value of mask\\n ind = self.getValidIndicies(tind)\\n \\n # now accumulate optional results\\n inds = na.take(tind,ind)\\n\\n indc = [self.maskMap[i] for i in inds]\\n return indc\\n except Exception as error:\\n print(\\\"failed in getValidNeighborsInformation() \\\", error)\",\n \"def locate_tracker(self, debug):\\n\\n # tmp_image =\\n # tmp_image = cv2.GaussianBlur(self.frame, (11, 11), 0) # Experiment with this\\n\\n hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) # Convert to HSV Color Space. This is temporary for testing using colored objects)\\n\\n mask = cv2.inRange(hsv, self.hueLower, self.hueUpper)\\n\\n try:\\n mask = cv2.inRange(hsv, self.hueLower2, self.hueUpper2) + mask\\n except AttributeError:\\n pass\\n\\n mask = cv2.erode(mask, None, iterations=2)\\n mask = cv2.dilate(mask, None, iterations=2)\\n\\n if debug:\\n tmpMask = imutils.resize(mask, width=1000, height=1000)\\n cv2.imshow(\\\"mask\\\", tmpMask)\\n\\n\\n # find contours in the mask and initialize the current (x, y) center of the object\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\\n center = None\\n\\n # only proceed if at least one contour was found\\n if len(cnts) > 0:\\n # find the largest contour in the mask, then use\\n # it to compute the minimum enclosing circle and\\n # centroid\\n c = max(cnts, key=cv2.contourArea)\\n\\n ((x, y), radius) = cv2.minEnclosingCircle(c)\\n M = cv2.moments(c)\\n center = (int(M[\\\"m10\\\"] / M[\\\"m00\\\"]), int(M[\\\"m01\\\"] / M[\\\"m00\\\"]))\\n\\n # only proceed if the radius meets a minimum size\\n # if radius > 10:\\n # # draw the circle and centroid on the frame,\\n # # then update the list of tracked points\\n # cv2.circle(frame, (int(x), int(y)), int(radius),\\n # (0, 255, 255), 2)\\n # cv2.circle(frame, center, 5, (0, 0, 255), -1)\\n if debug:\\n cv2.drawContours(self.frame, c, -1, (0, 255, 0), 20)\\n return center, radius\\n # update the points queue\\n cv2.imshow(\\\"mask\\\", imutils.resize(mask, width=1000, height=1000))\\n cv2.imshow(\\\"frame\\\", imutils.resize(self.frame, width=1000, height=1000))\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n raise OpenCVError(\\\"Could not find tracker!\\\")\\n\\n # return (1, 1), 1\",\n \"def fillHoles(img):\\n out,contour,hierarchy = cv2.findContours(img,cv2.RETR_CCOMP,cv2.CHAIN_APPROX_NONE)\\n i=0\\n for cnt in contour:\\n cv2.drawContours(img,contour,i,255,-1)\\n i+=1\\n return img\",\n \"def compute_contour(ptr_array):\\n hull = ConvexHull(ptr_array)\\n contour_index = hull.vertices.tolist() # indices are ordered\\n # contour_index = hull.simplices.flatten()\\n # contour_index = list(set(contour_index))\\n return contour_index\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7544308","0.72690433","0.6326455","0.6134341","0.6090655","0.60881174","0.60103273","0.59323454","0.589878","0.5895224","0.5728049","0.5722162","0.5446987","0.54307616","0.53550386","0.5353401","0.5350056","0.53280115","0.53188914","0.5309465","0.5292835","0.5292239","0.52916664","0.526759","0.5250293","0.5246763","0.5234527","0.52185136","0.5211725","0.51974916","0.51922596","0.5180996","0.5180728","0.51770824","0.51475424","0.51439667","0.51054007","0.5104887","0.51046944","0.5102081","0.5092409","0.5091323","0.5088226","0.50857824","0.5078357","0.5074127","0.5072796","0.50525486","0.50522906","0.50499475","0.50464773","0.50398767","0.5034414","0.5030286","0.50302774","0.50282574","0.5024958","0.50102836","0.5009219","0.50069153","0.500577","0.50016725","0.4997758","0.4993747","0.49929222","0.49910724","0.4987809","0.4986426","0.4961355","0.49540088","0.49533242","0.49517506","0.49477118","0.49450177","0.4944629","0.4941871","0.49385035","0.4930166","0.49223998","0.49193197","0.49163625","0.49147856","0.49131897","0.49104777","0.49100584","0.49094692","0.49059057","0.49029672","0.4901926","0.48926315","0.4886905","0.48858327","0.4884652","0.48827243","0.4879183","0.48760244","0.48757127","0.4875367","0.48752433","0.4874759"],"string":"[\n \"0.7544308\",\n \"0.72690433\",\n \"0.6326455\",\n \"0.6134341\",\n \"0.6090655\",\n \"0.60881174\",\n \"0.60103273\",\n \"0.59323454\",\n \"0.589878\",\n \"0.5895224\",\n \"0.5728049\",\n \"0.5722162\",\n \"0.5446987\",\n \"0.54307616\",\n \"0.53550386\",\n \"0.5353401\",\n \"0.5350056\",\n \"0.53280115\",\n \"0.53188914\",\n \"0.5309465\",\n \"0.5292835\",\n \"0.5292239\",\n \"0.52916664\",\n \"0.526759\",\n \"0.5250293\",\n \"0.5246763\",\n \"0.5234527\",\n \"0.52185136\",\n \"0.5211725\",\n \"0.51974916\",\n \"0.51922596\",\n \"0.5180996\",\n \"0.5180728\",\n \"0.51770824\",\n \"0.51475424\",\n \"0.51439667\",\n \"0.51054007\",\n \"0.5104887\",\n \"0.51046944\",\n \"0.5102081\",\n \"0.5092409\",\n \"0.5091323\",\n \"0.5088226\",\n \"0.50857824\",\n \"0.5078357\",\n \"0.5074127\",\n \"0.5072796\",\n \"0.50525486\",\n \"0.50522906\",\n \"0.50499475\",\n \"0.50464773\",\n \"0.50398767\",\n \"0.5034414\",\n \"0.5030286\",\n \"0.50302774\",\n \"0.50282574\",\n \"0.5024958\",\n \"0.50102836\",\n \"0.5009219\",\n \"0.50069153\",\n \"0.500577\",\n \"0.50016725\",\n \"0.4997758\",\n \"0.4993747\",\n \"0.49929222\",\n \"0.49910724\",\n \"0.4987809\",\n \"0.4986426\",\n \"0.4961355\",\n \"0.49540088\",\n \"0.49533242\",\n \"0.49517506\",\n \"0.49477118\",\n \"0.49450177\",\n \"0.4944629\",\n \"0.4941871\",\n \"0.49385035\",\n \"0.4930166\",\n \"0.49223998\",\n \"0.49193197\",\n \"0.49163625\",\n \"0.49147856\",\n \"0.49131897\",\n \"0.49104777\",\n \"0.49100584\",\n \"0.49094692\",\n \"0.49059057\",\n \"0.49029672\",\n \"0.4901926\",\n \"0.48926315\",\n \"0.4886905\",\n \"0.48858327\",\n \"0.4884652\",\n \"0.48827243\",\n \"0.4879183\",\n \"0.48760244\",\n \"0.48757127\",\n \"0.4875367\",\n \"0.48752433\",\n \"0.4874759\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6577085"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":93476,"cells":{"query":{"kind":"string","value":"Turn a cVLS into a list of points (xyList) and a dictionary of index lists (into xyList) with cellID keys (polyList) polyList basically contains the information that reconstructs each individual contour from points Appends the first point to the end of each list to close the loop and makes plotting cleaner, but be cautious of this"},"document":{"kind":"string","value":"def GetXYListAndPolyListFromCVLS(cVLS, allValsByFrame, orderOfSCsByValueByFrame):\n numFrames = len(cVLS)\n xyList = [\n sorted(list(set(tuple(pt) for c in cvlsByVal for pt in c[2])))\n for cvlsByVal in cVLS\n ]\n polyList = []\n\n for t in range(numFrames):\n polyList.append({})\n for v in allValsByFrame[t]:\n subContours = [\n (cVLS[t][-index][2][::-1] if index < 0 else cVLS[t][index][2])\n for index in orderOfSCsByValueByFrame[t][v]\n ] # reconstruct the sc's, flipping if index is negative\n polyList[-1][v] = [\n xyList[t].index(totuple(pt)) for sc in subContours for pt in sc[:-1]\n ]\n polyList[-1][v] = polyList[-1][v] + [\n polyList[-1][v][0]\n ] # Tack on the first point at the end to close the loop\n # VFMin doesn't like this format; make sure to remove this last point before saving to a file or passing to VFM...\n # polyList[-1][v] = removeDuplicates(polyList[-1][v])+[polyList[-1][v][0]] # Remove interior duplication...\n return xyList, polyList"},"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 individual_plot(z, cf_lvls, cl_lvls, cline_label_format=cline_label_format_default, log_scale=False ,\n extend=\"neither\"):\n map_plot.drawcoastlines(linewidth=.4)\n\n if log_scale:\n norm = colors.LogNorm(vmin=cf_lvls[0], vmax=cf_lvls[-1])\n else:\n norm = None\n\n if extend == 'neither':\n contour_fills = map_plot.contourf(x_grid, y_grid, z, cf_lvls, cmap=color_map, norm=norm)\n else:\n contour_fills = map_plot.contourf(x_grid, y_grid, z, cf_lvls, cmap=color_map, norm=norm, extend=extend)\n contour_lines = plt.contour(x_grid, y_grid, z, cl_lvls, colors='0.1', linewidths=1)\n\n # Label levels with specially formatted floats\n plt.rcParams['font.weight'] = 'bold'\n plt.clabel(contour_lines, fmt=cline_label_format, inline=1, fontsize=9, colors='k')\n plt.rcParams['font.weight'] = 'normal'\n\n return contour_fills","def get_cntr_points(self, contour, img_size):\n res_arr = []\n # for each row\n for row in range(img_size):\n tmp_arr = []\n # for each column\n for col in range(img_size):\n # if point in contour\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\n # add point to current line\n tmp_arr.append([row,col])\n if len(tmp_arr):\n # add current line to result array\n res_arr.append(tmp_arr)\n return res_arr","def polygons2PPC(xy, polygons, BL=None, PVxydict=None, check=False):\n # Prepare a polygon patch collection plot\n if PVxydict is not None and PVxydict != {}:\n BLdbl = np.vstack((BL, np.fliplr(BL)))\n\n PPC = []\n for poly in polygons:\n if PVxydict is not None and PVxydict != {}:\n xypoly, periodicpoly = periodic_polygon_indices2xy(poly, xy, BLdbl, PVxydict)\n\n # Add to list of polygon path patches\n pp = Path(np.array(xypoly), closed=True)\n ppp = patches.PathPatch(pp, lw=2)\n PPC.append(ppp)\n\n # If polygon was periodic, get other permutations of the polygon\n if periodicpoly:\n # print 'Dealing with periodic polygon here...'\n # make sure that polygon doesn't have repeated index\n # print 'poly = ', poly\n if poly[-1] == poly[0]:\n poly = poly[0:len(poly) - 1]\n\n oldpolys = [xypoly[0:len(xypoly) - 1]]\n for ii in range(len(poly)):\n # permute polygon, check if it is a cyclic permutation for any previously-plotted polygons\n poly = np.roll(poly, 1)\n # print 'rolled poly = ', poly\n newxyp, trash = periodic_polygon_indices2xy(poly, xy, BLdbl, PVxydict)\n # print 'oldxyp[:, 0] = ', np.array(oldpolys[0])[:, 0]\n # print 'newxyp[:, 0] = ', np.array(newxyp)[:, 0]\n xcyclic = np.array([is_cyclic_permutation(np.array(oldp)[:, 0].tolist(),\n np.array(newxyp)[:, 0].tolist()) for oldp in oldpolys])\n ycyclic = np.array([is_cyclic_permutation(np.array(oldp)[:, 1].tolist(),\n np.array(newxyp)[:, 1].tolist()) for oldp in oldpolys])\n if not xcyclic.any() or not ycyclic.any():\n # print '\\n\\n\\n\\n\\n adding new periodic polygon! \\n\\n\\n\\n'\n pp = Path(np.array(np.vstack((np.array(newxyp), np.array(newxyp)[0, :]))), closed=True)\n ppp = patches.PathPatch(pp, lw=2)\n PPC.append(ppp)\n oldpolys.append(newxyp)\n else:\n pp = Path(xy[poly], closed=True)\n ppp = patches.PathPatch(pp, lw=2)\n PPC.append(ppp)\n\n if check:\n fig = plt.figure()\n ax = fig.add_subplot(111)\n p = PatchCollection(PPC, cmap=cm.jet, alpha=0.5)\n colors = 100 * np.random.rand(len(PPC))\n p.set_array(np.array(colors))\n ax.add_collection(p)\n xlim = max(abs(xy[:, 0]))\n ylim = max(abs(xy[:, 1]))\n ax.set_xlim(-xlim, xlim)\n ax.set_ylim(-ylim, ylim)\n plt.show()\n plt.clf()\n\n return PPC","def polylinedictarraycopy(d):#d——原始图层多段线字典 \r\n dictlist=[]\r\n ratiolist=[] #放缩率列表\r\n rationumaccumulationlist=[] #放缩率数量累加列表\r\n \r\n eachrationum=globalconfig.X_ARRAY_NUM//globalconfig.RATIO_NUM\r\n leftrationum=globalconfig.X_ARRAY_NUM%globalconfig.RATIO_NUM\r\n \r\n eachrationumlist=[eachrationum]*globalconfig.RATIO_NUM #各个放缩率对应数量的列表\r\n \r\n for i in range((globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2,(globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2+leftrationum):\r\n eachrationumlist[i]=eachrationumlist[i]+1 #将整除后的余值加入到靠中间放缩率的方案中。\r\n \r\n rationumaccumulationlist.append(0) \r\n \r\n for i in range(1,globalconfig.RATIO_NUM): #计算放缩率数量累加列表\r\n rationumaccumulationlist.append(rationumaccumulationlist[i-1]+eachrationumlist[i-1])\r\n \r\n for i in range(0,globalconfig.RATIO_NUM): #计算放缩率列表\r\n ratiolist.append((globalconfig.CENTER_RATIO-((globalconfig.RATIO_NUM+1)//2-1)*globalconfig.RATIO_DIFF)+i*globalconfig.RATIO_DIFF) \r\n \r\n for i in range(0,globalconfig.RATIO_NUM): #每种放缩率\r\n for j in range(0,eachrationumlist[i]): #每种放缩率对应数量\r\n newdict={}\r\n for e in d: #将字典中值即每一图层对应的多段线列表进行复制并移动到指定位置\r\n newdict[e]=polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist)) \r\n #newdict.append([e,polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist))])\r\n dictlist.append(newdict) \r\n return (dictlist,ratiolist,eachrationumlist)","def holepolylinedictarraycopy(holepolylinedict):\r\n holepolylinearraydict={}\r\n for e in holepolylinedict: #对通孔图层多段线字典进行遍历，将里面的多段线向上阵列\r\n holepolylinedataset=[]\r\n for row in range(0,globalconfig.Y_ARRAY_NUM): \r\n holepolylinedataset.extend(datasetjustcopy(holepolylinedict[e], 1, 0, globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO*row))\r\n holepolylinearraydict[e]=holepolylinedataset\r\n return holepolylinearraydict","def layer_coords(label_lst): #full path\n \n #if a fundus then do this block\n gyrus_check = all(i.__contains__(\"fundus\") for i in label_lst)\n if gyrus_check:\n for layer in label_lst:\n #read data\n df_layer = pd.read_csv(layer)\n df_layer = df_layer.iloc[1:,0]\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\n\n #compute slope\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\n\n #split lam label into three\n split = math.floor(len(df_layer['X'].values)/3)\n df_layer_right = df_layer[0:split]\n df_layer_left = df_layer[-split:]\n df_layer_middle = df_layer[split:-split]\n\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000'\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\n plt.axis('off')\n plt.savefig('layer_contour.png')\n # plt.show()\n plt.close()\n\n #read, convert to grayscale, find edges\n layer_img = cv2.imread('layer_contour.png')\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\n\n #find contours\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n # cv2.imshow('contour', layer_edges)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\n \n #order contours\n contours = [np.squeeze(i) for i in contours]\n df_contours = pd.DataFrame(contours)\n contours_ord = df_contours.loc[6].values, df_contours.loc[4].values, \\\n df_contours.loc[3].values, df_contours.loc[2].values, \\\n df_contours.loc[1].values, df_contours.loc[0].values, \\\n df_contours.loc[5].values\n contours_ord = np.squeeze(contours_ord)\n \n\n #plot all layers and add coordinate data to dict \n lay_coords_dict = {}\n for laycon, i in zip(contours_ord, list(range(len(contours)))): \n #split coordinates into top and bottom edge\n if i == 0: #0 == pial\n c_idx = int(np.floor(len(laycon)/2))\n coords_top = np.array(list(reversed(laycon[:c_idx])))\n lay_coords_dict[i] = coords_top[10:]\n # print(coords_top)\n\n else:\n c_idx = int(np.floor(len(laycon)/2))\n coords_top = np.array(list(reversed(laycon[c_idx:])))\n lay_coords_dict[i] = coords_top[5:-7]\n\n \n #plot coords\n # for key, val in lay_coords_dict.items():\n # plt.plot([i[0] for i in val], [i[1] for i in val], lw=1.75)\n # plt.gca().invert_yaxis()\n # plt.show()\n # plt.close()\n # sys.exit()\n\n #delete edge detect image and return dict\n rm_img_cmd = \"rm layer_contour.png\"\n os.system(rm_img_cmd)\n return(lay_coords_dict)\n \n\n #for crown data do this block\n else:\n for layer in label_lst:\n #read data\n df_layer = pd.read_csv(layer)\n df_layer = df_layer.iloc[1:,0]\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\n\n #compute slope\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\n\n #split lam label into three\n split = math.floor(len(df_layer['X'].values)/3)\n df_layer_right = df_layer[0:split]\n df_layer_left = df_layer[-split:]\n df_layer_middle = df_layer[split:-split]\n\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000', lw=5\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\n plt.axis('off')\n plt.savefig('layer_contour.png')\n # plt.show()\n plt.close()\n\n #read, convert to grayscale, find edges\n layer_img = cv2.imread('layer_contour.png')\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\n\n #find contours\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n # cv2.imshow('contour', layer_edges)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\n \n\n #plot all layers and add coordinate data to dict\n lay_coords_dict = {}\n for laycon, i in zip(contours, list(range( len(contours) ) )[::-1] ):#7\n #split coordinates into top and bottom edge\n # print(laycon)\n coords_lst = [list(ii) for i in laycon for ii in i] # 0 == GWB\n # print(coords_lst)\n\n c_split = math.floor(len(coords_lst)/4)\n coords_top = coords_lst[:c_split][::-1] + coords_lst[-c_split:][::-1]\n lay_coords_dict[i] = coords_top\n df_coords = pd.DataFrame(coords_top, columns=['X', 'Y'])\n # print(df_coords)\n\n #plot using all coordinates\n plt.plot(df_coords['X'].values, df_coords['Y'].values, lw=3)\n plt.gca().invert_yaxis()\n # plt.show()\n plt.close()\n\n\n # use k means to get rid of extra coords on short lines\n for i in list(range(1,6)):\n # kMEANS clustering, separate short line bottom half\n df_short = pd.DataFrame(lay_coords_dict[i], columns=['X', 'Y']) #1=L1,\n # plt.scatter( df_short['X'].values, df_short['Y'].values, s=5 )\n # plt.gca().invert_yaxis()\n # plt.show()\n\n #scale data\n scaler = StandardScaler()\n scaler.fit( df_short[['X', 'Y']].values )\n short_scale = scaler.transform( df_short[['X', 'Y']].values )\n\n init = np.array([[0.514, -0.629], [-1.101, 1.344]])\n\n #predict\n # kmeans_classifier = KMeans(n_clusters=2, init=init) #fixed centroids\n kmeans_classifier = KMeans(n_clusters=2) \n\n y_kmeans = kmeans_classifier.fit_predict(short_scale)\n centroids = kmeans_classifier.cluster_centers_\n inertia = kmeans_classifier.inertia_\n\n\n #update df\n df_short.insert(2, column='kClass', value=y_kmeans)\n\n #df scaled\n df_short_scale = pd.DataFrame(short_scale, columns=['X', 'Y'])\n df_short_scale.insert(2, column='kClass', value=y_kmeans)\n \n\n \"\"\"\n #plot data points for k means, clusters\n colmap = {0: '#029386', 1: '#D2691E', 2: '#A52A2A'}\n for i in range(2):\n new_df = df_short_scale[df_short_scale['kClass']==i]\n plt.scatter(new_df['X'].values, new_df['Y'].values, s=20, \\\n label='cluster' + str(i+1), color=colmap[i])\n\n #plot centroids\n for i in range (2):\n plt.scatter(centroids[i][0], centroids[i][1], marker='x', s=500, \\\n label='centroid' + str(i+1), color=colmap[i])\n \n plt.legend()\n plt.gca().invert_yaxis()\n plt.show()\n \"\"\"\n\n\n #new df for clean data, take centroid with more data points\n num_class0 = len(df_short[df_short['kClass']==0])\n num_class1 = len(df_short[df_short['kClass']==1])\n\n if num_class0 > num_class1:\n \n df_short_clean = df_short[df_short['kClass']==0]\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\n df_short_clean['Y'].values)]\n else:\n df_short_clean = df_short[df_short['kClass']==1]\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\n df_short_clean['Y'].values)]\n\n #plot clean short line\n # plt.scatter(df_short_clean['X'].values, df_short_clean['Y'].values, s=20)\n # plt.gca().invert_yaxis()\n # plt.show()\n\n #delete edge detect image and return dict\n rm_img_cmd = \"rm layer_contour.png\"\n os.system(rm_img_cmd)\n return(lay_coords_dict)","def GetXYListAndPolyListWithLimitedPointsBetweenNodes_CVLS(\n cVLS,\n allValsByFrame,\n orderOfSCsByValueByFrame,\n splitLength=1,\n fixedNumInteriorPoints=None,\n interpolate=True,\n):\n cVLS2 = GetCVLSWithLimitedPointsBetweenNodes(\n cVLS,\n allValsByFrame,\n splitLength,\n fixedNumInteriorPoints,\n interpolate=interpolate,\n )\n return GetXYListAndPolyListFromCVLS(cVLS2, allValsByFrame, orderOfSCsByValueByFrame)","def _coords_from_ccdata(self, index):\n elements = [self.pt.element[Z] for Z in self.ccdata.atomnos]\n if self.ghost is not None:\n elements = [self.ghost if e is None else e for e in elements]\n elif None in elements:\n raise ValueError(\n f\"It seems that there is at least one ghost atom in these elements. Please use the ghost flag to specify a label for the ghost atoms.\"\n )\n atomcoords = self.ccdata.atomcoords[index]\n atomnos = self.ccdata.atomnos\n nos = range(self.ccdata.natom)\n\n lines = []\n for element, no, atomno, coord in zip(elements, nos, atomnos,\n atomcoords):\n x, y, z = map(round_molden, coord)\n lines.append(f\"{element:2s} {no + 1:5d} {atomno:2d} {x:12.6f} {y:12.6f} {z:12.6f}\")\n\n return lines","def get_MultiPolyLists_xy(mpoly):\n # Get the x or y coordinates\n x = []\n y = []\n if isinstance(mpoly,Polygon):\n mpoly = [mpoly]\n for poly in mpoly: # the polygon objects return arrays, it's important they be lists or Bokeh fails\n exterior_coords_x = poly.exterior.coords.xy[0].tolist();\n interior_coords_x = []\n exterior_coords_y = poly.exterior.coords.xy[1].tolist();\n interior_coords_y = []\n\n for interior in poly.interiors:\n if isinstance(interior.coords.xy[0],list):\n interior_coords_x += [interior.coords.xy[0]];\n interior_coords_y += [interior.coords.xy[1]];\n else:\n interior_coords_x += [interior.coords.xy[0].tolist()];\n interior_coords_y += [interior.coords.xy[1].tolist()];\n x.append([exterior_coords_x, *interior_coords_x])\n y.append([exterior_coords_y, *interior_coords_y])\n return (x,y)","def get_indices_from_cell_list(polydata, num_cells):\n cells_list = []\n\n polys = polydata.GetPolys() # get connectivity of polygon cells (polygon : {triangles, tetra, hexa, ..etc.})\n polys.InitTraversal() # initialize traversal so getnextcell starts at 0\n\n temp_list = []\n\n for i in range(num_cells):\n ptIds = vtk.vtkIdList()\n polys.GetNextCell(ptIds)\n num_pts = ptIds.GetNumberOfIds()\n cellids = []\n\n for j in range(num_pts):\n current_ptid = ptIds.GetId(j)\n if current_ptid in temp_list:\n continue\n else:\n cellids.append(current_ptid)\n\n temp_list.append(current_ptid)\n\n cells_list.append(cellids)\n\n\n return cells_list","def calculate_contours_fit(L_x, L_y, e, leaflet, ts, Plots, side):\n \n n = np.load(input_dir + 'directors_'+leaflet+'_tail_'+ str(ts) + '.npy') \n\n pos = np.load(input_dir + 'coordinates_'+leaflet+'_tail_' + str(ts) + '.npy') \n\n resid = np.load(input_dir + 'residues_'+leaflet+'_tail_' + str(ts) + '.npy')\n box = np.load(input_dir + 'box' + str(ts) + '.npy')\n\n \n chl = np.load(input_dir + 'cholesterol_'+leaflet+'_tail_' + str(ts) + '.npy')\n dlipc = np.load(input_dir + 'dlipc_'+leaflet+'_tail_' + str(ts) + '.npy') \n dspc = np.load(input_dir + 'dspc_'+leaflet+'_tail_' + str(ts) + '.npy')\n ssm = np.load(input_dir + 'ssm_'+leaflet+'_tail_' + str(ts) + '.npy')\n \n #n= np.ones(len(pos))\n \"\"\" END: read the input data \"\"\"\n\n\n field = order_vector_field(L_x, L_y, pos, n, e, box)\n\n c = pd.DataFrame(data=field).mean(axis=0).rolling(50, center=True, min_periods=1).mean() #50\n c.dropna(inplace=True)\n middle = 0.5*(np.max(c) + np.min(c)) \n #middle = 0.025\n contours = measure.find_contours(field, middle) # Marching Cubes algorith\n #save contours\n fac_x = box[0] / L_x #to get the right dimensions (range_x)\n fac_y = box[1] / L_y # (range_y)\n \n contours_x = []\n contours_y = []\n contours_x_y = []\n \n contours_all = []\n for m, contour in enumerate(contours):\n contours_x.append((contour[:, 1] * fac_x))\n contours_y.append((contour[:, 0] * fac_y))\n \n \n contours_x_y = np.column_stack((contours_x[m], contours_y[m]))\n contours_all.append(contours_x_y)\n np.save(output_contours + 'contours_'+leaflet+'.' + str(ts) + '.npy', contours_all)\n \n\n#===================================================\n#To assign resids to the different phases\n phase_belonging = np.zeros((len(pos)))\n ordered =[]\n disordered = []\n for i in np.arange(len(pos)):\n \n def apply_pbc(pos, box):\n if pos >= box:\n pos -= box\n if pos < 0:\n pos += box\n return pos\n \n idx_x = int(apply_pbc(pos[i,0], box[0]) / fac_x - 1.e-5) #the - 1.e-5 is because accuracy issue in the /\n idx_y = int(apply_pbc(pos[i,1], box[1]) / fac_y - 1.e-5) #this - 1.e-5 is because accuracy issue in the /\n #print(idx_x, idx_y)\n order= field[idx_y, idx_x]\n if (order > middle):\n ordered.append(order)\n order = 1 #ordered lipids\n \n else :\n disordered.append(order)\n order =0 #disordered lipids\n phase_belonging[i] = order\n \n\n resid_phases = np.column_stack((resid[:,0], phase_belonging))\n np.save(output_dir + 'resid_phases'+leaflet+'.'+ str(j) + '.npy', resid_phases)\n\n if Plots == True:\n plt.figure(figsize=(15,10)) \n \n contours_sorted = sorted(contours, key=len, reverse=True)\n \n for i in range(2):\n plt.plot(contours_sorted[i][:,1]* fac_x+0.5*fac_x, contours_sorted[i][:,0]* fac_y+0.5*fac_y, linewidth=3, color='#0000FF' ) ##00CC00\n \n #for m, contour in enumerate(contours_sorted):\n # print(contour[:,0])\n # for contour in contours: \n \n # plt.plot((contour[:, 1] * fac_x+0.5*fac_x),\n # (contour[:, 0] * fac_y+0.5*fac_y),\n # linewidth=4, color='#00CC00')\n \n plt.imshow(field, interpolation='nearest', \n cmap=plt.cm.gray_r,\n extent=[0, box[0], 0, box[1]], origin='lower', alpha=0.7) \n \n plt.axis('off')\n plot_scatter_order_field(pos, resid, dlipc, dspc, chl,ssm, n , box, ts, side) #phase_belonging.reshape(-1,1)\n plt.savefig(output_dir + 'contours-'+ leaflet + str(ts) + '.png', dpi=300) \n plt.close() \n \n return resid_phases #, ordered, disordered ","def plot_individual(xdict, ydict, xprop, yprop, documents, spline):\n figure_array = {}\n for item in documents:\n xlabel = \"\\\\textbf{\" + label_dict[xprop] + \"}\"\n ylabel = \"\\\\textbf{\" + label_dict[yprop] + \"}\"\n x = xdict[item[\"path_id\"]]\n y = ydict[item[\"path_id\"]]\n # fig_title = item[\"path_id\"] + \"(\" + item[\"pretty_formula\"] + \")\" # Individual traces\n # fig_title = yprop + item[\"cation_type\"] # Plot by cation\n fig_title = yprop # All together\n figure_array[item[\"path_id\"]] = plt.figure(fig_title, figsize=(6,6), dpi=plotting_dpi)\n ax = figure_array[item[\"path_id\"]].add_subplot(111) \n ax.scatter(x,y, s=70, zorder=2, color=color_dict[item[\"cation_type\"]], linewidths=2.5, edgecolors='black')\n if spline:\n tck = interpolate.splrep(x, y, s=0)\n xnew = np.arange(0, 100, 0.1)\n splfit = interpolate.splev(xnew, tck, der=0)\n x = xnew\n y = splfit\n if item[\"path_id\"][-3:] == \"002\":\n ax.plot(x,y, linewidth=2.5, zorder=1, color=color_dict[item[\"cation_type\"]], linestyle='dashed')\n elif item[\"path_id\"][-3:] == \"003\":\n ax.plot(x,y, linewidth=2.5, zorder=1, color=color_dict[item[\"cation_type\"]], linestyle='dotted')\n else:\n ax.plot(x,y, linewidth=2.5, zorder=1, color=color_dict[item[\"cation_type\"]])\n ax.set_xlabel(xlabel, fontsize=24)\n # ax.set_ylim([0,1200])\n # ax.set_xlim([0,100])\n ax.set_ylabel(ylabel, fontsize=24)\n ax.tick_params(axis='x', labelsize=22)\n ax.tick_params(axis='y', labelsize=22)\n border_width = 2\n [i.set_linewidth(border_width) for i in ax.spines.itervalues()]\n plt.tight_layout()\n plt.legend(loc='best', prop={'size': 14})\n plt.rc('text', usetex=True)\n plt.rc('font', family='sans-serif')\n plt.tight_layout()\n plt.show()","def plotVoronoiCell(self, cells):\n for i in cells:\n #i indexes volumes\n i = self.nonBI[i] #now i indexes vor.point_region\n\n vI = self.vor.regions[self.vor.point_region[i]]\n v = self.vor.vertices[vI, :]\n r = v\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Voronoi Cell of Particle ' + str(i))\n ax.set_xlabel('x [m]')\n ax.set_ylabel('y [m]')\n ax.set_zlabel('z [m]')\n ax.scatter(r[:, 0], r[:, 1], r[:, 2], s=5, alpha=0.5, label='Cell Boundaries')\n ax.scatter(self.data[i, 0], self.data[i, 1], self.data[i, 2], s=25, label='Cell Center')\n ax.set_xlim3d(np.min(self.data[:, 0]), np.max(self.data[:, 0]))\n ax.set_ylim3d(np.min(self.data[:, 1]), np.max(self.data[:, 1]))\n ax.set_zlim3d(np.min(self.data[:, 2]), np.max(self.data[:, 2]))\n # limits = np.vstack((np.array([np.max(self.data[:, 0]), np.max(self.data[:, 1]), np.max(self.data[:, 2])]), np.array([np.min(self.data[:, 0]), np.min(self.data[:, 1]), np.min(self.data[:, 2])])))\n # ax.scatter(limits[:, 0], limits[:, 1], limits[:, 2], s=1)\n ax.legend()","def add_poly_mesh_arrays_data_to_gl(self, key, fv_indices, points, face_normals, cstype, c, face_colors, vertex_colors):\n n_vertices_max = len(fv_indices[0])\n\n data_mesh_points_list = np.array([])\n data_mesh_normals_list = np.array([])\n data_mesh_colors_list = np.array([])\n n_all_vertices = 0\n\n max_iter = n_vertices_max - 1\n\n for corner_idx in range(1, max_iter):\n if n_vertices_max > 3:\n existing_triangles = fv_indices[:, corner_idx + 1] != -1\n\n if True not in existing_triangles:\n continue\n\n fv_indices_to_draw_all_vertices = fv_indices[existing_triangles]\n fv_indices_to_draw = fv_indices_to_draw_all_vertices[:, [0, corner_idx, corner_idx + 1]]\n face_normals_to_draw = face_normals[existing_triangles]\n else:\n fv_indices_to_draw = fv_indices\n face_normals_to_draw = face_normals\n\n fv_indices_flattened = fv_indices_to_draw.flatten()\n n_all_vertices += len(fv_indices_flattened)\n\n n_faces = len(fv_indices_to_draw)\n\n vertexData = self.createVertexData(fv_indices_flattened, points)\n\n normalData = self.createNormaldata(face_normals_to_draw)\n\n if cstype == 0:\n colorData = self.createConstantColorData(c, n_faces)\n elif cstype == 1:\n colorData = self.createFaceColorData(face_colors)\n elif cstype == 2:\n colorData = self.createVertexColorData(vertex_colors, fv_indices_flattened)\n\n if self._showBack:\n fv_indices_flattened_reversed = fv_indices_flattened[::-1]\n n_all_vertices += len(fv_indices_flattened_reversed)\n\n reversed_mesh_points = self.createVertexData(fv_indices_flattened_reversed, points)\n\n reversed_normals = self.createNormaldata(-face_normals_to_draw[::-1])\n\n if cstype == 0:\n reversed_colors = colorData\n elif cstype == 1:\n reversed_colors = self.createFaceColorData(face_colors[::-1])\n elif cstype == 2:\n reversed_colors = self.createVertexColorData(vertex_colors, fv_indices_flattened_reversed)\n\n data_mesh_points_list = np.concatenate([data_mesh_points_list, vertexData, reversed_mesh_points])\n data_mesh_normals_list = np.concatenate([data_mesh_normals_list, normalData, reversed_normals])\n data_mesh_colors_list = np.concatenate([data_mesh_colors_list, colorData, reversed_colors])\n else:\n data_mesh_points_list = np.concatenate([data_mesh_points_list, vertexData])\n data_mesh_normals_list = np.concatenate([data_mesh_normals_list, normalData])\n data_mesh_colors_list = np.concatenate([data_mesh_colors_list, colorData])\n\n vertex_data = np.array(data_mesh_points_list, dtype=GLHelpFun.numpydatatype(GLDataType.FLOAT))\n normal_data = np.array(data_mesh_normals_list, dtype=GLHelpFun.numpydatatype(GLDataType.FLOAT))\n color_data = np.array(data_mesh_colors_list, dtype=GLHelpFun.numpydatatype(GLDataType.FLOAT))\n\n self.setlistdata_f3xyzf3nf4rgba(key, vertex_data, normal_data, color_data)\n self.setVertexCounter_byNum(key, n_all_vertices)\n return","def _get_voronoi_poly_points(vert_index_list, voronoi_vertices,\n voronoi_centroid):\n voronoi_poly_points = []\n if -1 not in vert_index_list and len(vert_index_list) > 3:\n voronoi_poly_points = voronoi_vertices[vert_index_list]\n elif vert_index_list.size > 0:\n # ASSUME RECTANGLE\n vert_index_list = vert_index_list[vert_index_list >= 0]\n voronoi_poly_points = voronoi_vertices[vert_index_list]\n # CASE 1: 2 valid voronoi vertices\n if vert_index_list.size == 2:\n center_lon = voronoi_centroid[0]\n center_lat = voronoi_centroid[1]\n corner_lon1 = voronoi_poly_points[0][0]\n corner_lat1 = voronoi_poly_points[0][1]\n corner_lon2 = voronoi_poly_points[1][0]\n corner_lat2 = voronoi_poly_points[1][1]\n\n # check if need to add points in lon or lat\n if abs(corner_lon1-corner_lon2) > abs(corner_lat1-corner_lat2):\n dLat = center_lat - corner_lat1\n # append the corners in order\n voronoi_poly_points = np.array([\n [corner_lon1, corner_lat1],\n [corner_lon2, corner_lat2],\n [corner_lon2, center_lat + dLat],\n [corner_lon1, center_lat + dLat]\n ])\n else:\n dLon = center_lon - corner_lon1\n # append the corners in order\n voronoi_poly_points = np.array([\n [corner_lon1, corner_lat1],\n [corner_lon2, corner_lat2],\n [center_lon + dLon, corner_lat2],\n [center_lon + dLon, corner_lat1]\n ])\n # CASE 2: 1 valid voronoi vertex\n elif vert_index_list.size == 1:\n center_lon = voronoi_centroid[0]\n center_lat = voronoi_centroid[1]\n corner_lon = voronoi_poly_points[0][0]\n corner_lat = voronoi_poly_points[0][1]\n dLat = center_lat - corner_lat\n dLon = center_lon - corner_lon\n # append the corners in order\n voronoi_poly_points = np.array([\n [corner_lon, corner_lat],\n [center_lon + dLon, corner_lat],\n [center_lon + dLon, center_lat + dLat],\n [corner_lon, center_lat + dLat]\n ])\n\n return voronoi_poly_points","def make_plot(\n X: np.ndarray, Y: np.ndarray, Z: np.ndarray, \n int_coords: List[np.ndarray], levels: np.ndarray, \n color_range: List[str], inter_color: List[Union[str, float]], \n SAVE: bool, SAVE_NAME: str):\n color1 = Color(color_range[0])\n color2 = Color(color_range[1])\n \n # List of Color objects, need to convert for matplotlib\n color_list = list(color1.range_to(color2, len(levels)))\n \n contour_colors = []\n for color in color_list:\n contour_colors.append(color.hex)\n\n fig = plt.figure(figsize = [8, 6])\n ax1 = fig.add_subplot(111)\n\n # Set title\n fig.suptitle('Quartz Deformation Mechanism Map')\n \n CS = ax1.contour(X, Y, Z, levels, colors = contour_colors) \n \n # Add intersection lines to plot\n for coord_arr in int_coords:\n # Get x indices and y indices\n x, y = coord_arr.T\n \n # Get actual points to plot\n points_x = X[x, y]\n points_y = Y[x, y]\n\n ax1.plot(points_x, points_y, \n color = inter_color[0], alpha = inter_color[1])\n\n # Labels... hardcoded. May find a way to make this generic\n sr_labels = [\n r'$10^{-15}$', r'$10^{-14}$', r'$10^{-13}$', \n r'$10^{-12}$', r'$10^{-11}$', r'$10^{-10}$', \n r'$10^{-9}$', r'$10^{-8}$', r'$10^{-7}$', \n r'$10^{-6}$']\n\n # Make legend equal to contour values from sr_labels\n for i in range(len(sr_labels)):\n CS.collections[i].set_label(sr_labels[i])\n\n # Reverse legend order, set location and title\n handles, labels = ax1.get_legend_handles_labels()\n ax1.legend(reversed(handles), reversed(labels), \n loc = 'upper right', title = r'$\\.\\epsilon$')\n\n # Set log scale and ylim\n ax1.set_yscale('log')\n ax1.set_ylim([10 ** -6, 1])\n \n # Set labels... could be done better in Illustrator...\n ax1.set_ylabel(\n r'Shear Stress $log\\left( \\frac{\\sigma}{\\mu}\\right)$'\n )\n ax1.set_xlabel(\n r'Homologous Temperature $\\left( \\frac{T}{T_m} \\right)$'\n )\n\n # Plot tick marks\n ax1.grid()\n\n if SAVE:\n fig.savefig(SAVE_NAME)\n else:\n plt.show()","def drawContour(xlist, ylist, zmatrix, level):\n dislin.contur(xlist, len(xlist), ylist, len(ylist), zmatrix, level)","def transform_xy_coords(xy_coords, sc_plot):\r\n sorted_keys = xy_coords.keys()\r\n all_cids = []\r\n all_xcoords = []\r\n all_ycoords = []\r\n sc_plot.set_transform(sc_plot.axes.transData)\r\n trans = sc_plot.get_transform()\r\n\r\n for s_label in sorted_keys:\r\n s_data = xy_coords[s_label]\r\n if s_data[0] == []:\r\n pass\r\n else:\r\n icoords = trans.transform(zip(s_data[0], s_data[1]))\r\n xcoords, ycoords = zip(*icoords)\r\n all_cids.extend(s_data[2])\r\n all_xcoords.extend(xcoords)\r\n all_ycoords.extend(ycoords)\r\n\r\n return all_cids, all_xcoords, all_ycoords","def CII_vs_CO(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[1])\n fig,ax1 = plt.subplots()\n L_CII = getattr(GR,'L_[CII]158_sun')\n L_CO = getattr(GR,'L_CO(1-0)_sun')\n Zsfr = getattr(GR,'Zsfr')\n lL_CO, lL_CII = np.log10(L_CO), np.log10(L_CII) \n lL_CO, lL_CII = lL_CO[(L_CO > 0) & (L_CII > 0)], lL_CII[(L_CO > 0) & (L_CII > 0)]\n sc = ax1.scatter(np.log10(L_CO)-10, np.log10(L_CII)-10, marker='o', c=np.log10(Zsfr), cmap='viridis', zorder=10,\\\n vmin=np.log10(0.05), vmax=np.log10(3.1), \\\n s=10, alpha=0.8)#, label='SIGAME 100Mpc_arepoPDF')\n # print('Min Zsfr in Simba sample: ',np.min(Zsfr))\n # print('indices with L_CO < 1e0:')\n nbins = 100\n k = kde.gaussian_kde(np.column_stack([lL_CO,lL_CII]).T)\n x, y = np.mgrid[lL_CO.min():lL_CO.max():nbins*1j, \\\n 4:lL_CII.max():nbins*1j]\n z = k(np.vstack([x.flatten(), y.flatten()]))\n CS = ax1.contour(x, y, z.reshape(x.shape),colors='forestgreen',levels=8,zorder=10)\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF')\n\n GR = glo.global_results(sim_run=p.sim_runs[0],nGal=p.nGals[0],grid_ext=p.grid_exts[1])\n L_CII = getattr(GR,'L_[CII]158_sun')\n L_CO = getattr(GR,'L_CO(1-0)_sun')\n Zsfr = getattr(GR,'Zsfr')\n lL_CO, lL_CII = np.log10(L_CO), np.log10(L_CII) \n lL_CO, lL_CII = lL_CO[(L_CO > 0) & (L_CII > 0)], lL_CII[(L_CO > 0) & (L_CII > 0)]\n lL_CO = np.append(lL_CO,np.array([6.1,5]))\n lL_CII = np.append(lL_CII,np.array([8.9,9.7]))\n # ax1.scatter(np.log10(L_CO), np.log10(L_CII), marker='^', c=np.log10(Zsfr), cmap='viridis', zorder=10,\\\n # vmin=np.log10(0.05), vmax=np.log10(3.1), \\\n # s=10, alpha=0.8, label='SIGAME 25Mpc_arepoPDF')\n nbins = 100\n k = kde.gaussian_kde(np.column_stack([lL_CO,lL_CII]).T)\n x, y = np.mgrid[lL_CO.min():lL_CO.max():nbins*1j, \\\n 4:lL_CII.max():nbins*1j]\n z = k(np.vstack([x.flatten(), y.flatten()]))\n CS = ax1.contour(x, y, z.reshape(x.shape),colors='deepskyblue',linestyles='dotted',levels=6)\n CS.collections[0].set_label('SIGAME 25Mpc_arepoPDF')\n\n GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[0])\n L_CII = getattr(GR,'L_[CII]158_sun')\n L_CO = getattr(GR,'L_CO(1-0)_sun')\n Zsfr = getattr(GR,'Zsfr')\n lL_CO, lL_CII = np.log10(L_CO), np.log10(L_CII) \n lL_CO, lL_CII = lL_CO[(L_CO > 0) & (L_CII > 0)], lL_CII[(L_CO > 0) & (L_CII > 0)]\n lL_CO = np.append(lL_CO,np.array([-2.2,4.7]))\n lL_CII = np.append(lL_CII,np.array([8,9.3]))\n # ax1.scatter(np.log10(L_CO), np.log10(L_CII), marker='^', c=np.log10(Zsfr), cmap='viridis', zorder=10,\\\n # vmin=np.log10(0.05), vmax=np.log10(3.1), \\\n # s=10, alpha=0.8, label='SIGAME v3 Simba-%s' % (p.sim_runs[0].replace('_','').replace('Mpc','')))\n nbins = 100\n k = kde.gaussian_kde(np.column_stack([lL_CO,lL_CII]).T)\n x, y = np.mgrid[lL_CO.min():lL_CO.max():nbins*1j, \\\n 4:lL_CII.max():nbins*1j]\n z = k(np.vstack([x.flatten(), y.flatten()]))\n CS = ax1.contour(x, y, z.reshape(x.shape),colors='brown',levels=8,zorder=5,linestyles='dashed')\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF_no_ext')\n\n # Observations\n K16 = pd.read_pickle('data/observations/AHIMSA_sample_lit')\n K16_LCII = K16['[CII]158_Lsun']\n K16_LCO = K16['CO(1-0)_Lsun']\n ax1.plot(np.log10(K16_LCO), np.log10(K16_LCII), '>', color='grey', ms=6, fillstyle='none',alpha=0.8, mew=1,zorder=0,\\\n label='Mixed type galaxies [Kamenetzky+16]')\n\n C15 = pd.read_pickle('data/observations/DGS_Cormier_2015')\n C15_LCII = C15['L_[CII]158']\n C15_LCO = C15['L_CO(1-0)']\n C15_Z = C15['Z']\n # L_ul = C15['L_[CII]158'][(C15['L_[CII]158'] < 0) & (C15['L_CO(1-0)'] > 0)]\n # if len(L_ul) > 0:\n # ax1.plot(np.log10(C15['L_CO(1-0)'][C15['L_[CII]158'] < 0]),np.log10(-1.*L_ul),'s',ms=5,mew=0,color='grey',alpha=0.8)\n # ax1.errorbar(np.log10(C15['L_CO(1-0)'][C15['L_[CII]158'] < 0]),np.log10(-1.*L_ul), elinewidth=1,\\\n # uplims=np.ones(len(L_ul)),yerr=np.ones(len(L_ul))*1,color='grey',alpha=0.8,lw=0)\n ax1.scatter(np.log10(C15_LCO), np.log10(C15_LCII), marker='+', c=np.log10(C15_Z), cmap='viridis', zorder=0,\\\n vmin=np.log10(0.05), vmax=np.log10(3.1),\\\n s=100, lw=3, alpha=0.8, label='Dwarf galaxies [Cormier+15]')\n\n A17 = pd.read_pickle('data/observations/xCOLD_GASS_Accurso_2017')\n A17 = A17.loc[np.argwhere(A17['L_CO(1-0)'].values > 0).flatten()]\n ax1.scatter(A17['L_CO(1-0)'],A17['L_[CII]158'], marker='d', c=np.log10(A17['Z']), cmap='viridis', zorder=0,\\\n vmin=np.log10(0.05), vmax=np.log10(3.1),\\\n s=50, lw=0, alpha=0.8, label='COLD GASS [Accurso+17]') #c=np.log10(A17['Z']), \n\n CII_obs = np.log10(np.append(K16_LCII.values,C15_LCII.values))\n CO_obs = np.log10(np.append(K16_LCO.values,C15_LCO.values))\n CII_obs = np.append(CII_obs,A17['L_[CII]158'].values)\n CO_obs = np.append(CO_obs,A17['L_CO(1-0)'].values)\n index = np.argwhere((CII_obs > 0) & (CO_obs > 0)).flatten()\n CII_obs = CII_obs[index]\n CO_obs = CO_obs[index]\n\n x = np.linspace(0, 7, 100)\n fit = LinearRegression().fit(CO_obs.reshape(-1, 1),\\\n CII_obs.reshape(-1, 1))\n L_fit = fit.predict(x.reshape(-1, 1))\n ax1.plot(x, L_fit, color='black', linestyle='--', label='Log-linear fit to observations')\n\n ax1.set_ylabel('log ' + getlabel('[CII]158'))\n ax1.set_xlabel('log ' + getlabel('CO(1-0)'))\n plt.colorbar(sc,label=r'log $\\langle$Z$\\rangle_{\\rm SFR}$ [Z$_{\\rm \\odot}$]')\n\n handles, labels = ax1.get_legend_handles_labels()\n print(labels) # labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))\n # handles = [handles[_] for _ in [2,4,3,5,0,6,7,1]]\n # labels = [labels[_] for _ in [2,4,3,5,0,6,7,1]]\n handles = [handles[_] for _ in [2,4,3,5,6,0,1]]\n labels = [labels[_] for _ in [2,4,3,5,6,0,1]]\n plt.legend(handles,labels,loc='lower left',fontsize=10.,frameon=True)\n\n ax1.set_xlim([-3,6.2])\n ax1.set_ylim([4,10])\n\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/CO_vs_CII%s%s.png' % (p.grid_ext,p.table_ext), dpi=300)","def get_MultiPolyLists(mpoly,coord_type='x'):\n if coord_type == 'x':\n i=0\n elif coord_type == 'y':\n i=1\n\n # Get the x or y coordinates\n c = []\n if isinstance(mpoly,Polygon):\n mpoly = [mpoly]\n for poly in mpoly: # the polygon objects return arrays, it's important they be lists or Bokeh fails\n exterior_coords = poly.exterior.coords.xy[i].tolist();\n interior_coords = []\n for interior in poly.interiors:\n if isinstance(interior.coords.xy[i],list):\n interior_coords += [interior.coords.xy[i]];\n else:\n interior_coords += [interior.coords.xy[i].tolist()];\n c.append([exterior_coords, *interior_coords])\n return c","def get_contours_points(found, contours):\n contours_points = []\n for i in found:\n c = contours[i]\n for sublist in c:\n for p in sublist:\n contours_points.append(p)\n return contours_points","def p2p_xyz(start_point, end_point, top_left_cor, cellsize, dem):\n start_cell = (int((start_point[0] - top_left_cor[0]) / cellsize[0]),\n int((start_point[1] - top_left_cor[1]) / cellsize[1]))\n end_cell = (int((end_point[0] - top_left_cor[0]) / cellsize[0]),\n int((end_point[1] - top_left_cor[1]) / cellsize[1]))\n cells = misc.get_line(start_cell, end_cell) \n pnts = []\n elev = []\n \n dem_elv = dem[:,1]\n dem_indx = dem[:,2:4]\n\n for cell in cells:\n x = top_left_cor[0] + cell[0] * cellsize[0] + cellsize[0] / 2\n y = top_left_cor[1] + cell[1] * cellsize[1] + cellsize[1] / 2\n #xy_indx=[str(cell[0]),str(cell[1])]\n z_indx=np.logical_and(np.equal(dem_indx[:,0],cell[0]),np.equal(dem_indx[:,1],cell[1]))\n try:\n z=dem_elv[z_indx][0]\n except (np.sum(z_indx)>1):\n print(\"Oops! That was more than one indices in dem matching the query index (in getCellValue)\")\n #z_indx = [i for i,j in enumerate(dem_indx) if j == xy_indx]\n z = float(dem_elv[z_indx])\n pnts.append((x, y))\n elev.append(z)\n return pnts, elev","def printPolyCoeffs(lam) :\n ell = len(lam)\n useFormat = \"2.6e\"\n count = 0\n def printLine(s, count) :\n if lam[count] < 0 :\n s = s + 3 * \" \"\n else :\n s = s + 4 * \" \"\n s = s + \"{0:\" + useFormat + \"}\"\n print(s . format(lam[count]))\n count = count + 1\n return count\n if ell >= 1 :\n count = printLine(\"x0y0\", count)\n if ell >= 3 :\n count = printLine(\"x1y0\", count)\n count = printLine(\"x0y1\", count)\n if ell >= 6 :\n count = printLine(\"x2y0\", count)\n count = printLine(\"x1y1\", count)\n count = printLine(\"x0y2\", count)\n if ell >= 10 :\n count = printLine(\"x3y0\", count)\n count = printLine(\"x2y1\", count)\n count = printLine(\"x1y2\", count)\n count = printLine(\"x0y3\", count)\n if ell >= 15 :\n count = printLine(\"x4y0\", count)\n count = printLine(\"x3y1\", count)\n count = printLine(\"x2y2\", count)\n count = printLine(\"x1y3\", count)\n count = printLine(\"x0y4\", count)\n if ell >= 21 :\n count = printLine(\"x5y0\", count)\n count = printLine(\"x4y1\", count)\n count = printLine(\"x3y2\", count)\n count = printLine(\"x2y3\", count)\n count = printLine(\"x1y4\", count)\n count = printLine(\"x0y5\", count)\n if ell >= 28 :\n count = printLine(\"x6y0\", count)\n count = printLine(\"x5y1\", count)\n count = printLine(\"x4y2\", count)\n count = printLine(\"x3y3\", count)\n count = printLine(\"x2y4\", count)\n count = printLine(\"x1y5\", count)\n count = printLine(\"x0y6\", count)\n if ell >= 36 :\n count = printLine(\"x7y0\", count)\n count = printLine(\"x6y1\", count)\n count = printLine(\"x5y2\", count)\n count = printLine(\"x4y3\", count)\n count = printLine(\"x3y4\", count)\n count = printLine(\"x2y5\", count)\n count = printLine(\"x1y6\", count)\n count = printLine(\"x0y7\", count)\n if (ell > 36) or (ell < 1) :\n raise ValueError(\"Polynomial degree less than or equal to 7, please.\")","def outputholepos(dictlist,origindict): #dictlist-一行中所有图层的字典的列表，其中字典为(key：图层名，value：一个outline中的该图层多段线列表) origindict-原始的未进行操作的字典\r\n \r\n layernamelist=list(origindict.keys())\r\n \r\n hole_list=[]\r\n holepolylinedict={}\r\n \r\n for layername in layernamelist: #得到通孔层的名称列表\r\n if layername[0]=='V' or layername[0]=='v':\r\n hole_list.append(layername)\r\n \r\n for holelayer in hole_list: #已经阵列好的第一行中每一层通孔多段线存入新的“通孔名称”-“一行中所有通孔多段线”的字典\r\n holepolylinelist=[] \r\n for d in dictlist: \r\n holepolylinelist.extend(d[holelayer])\r\n holepolylinedict[holelayer]=holepolylinelist\r\n \r\n holepolylinearraydict=holepolylinedictarraycopy(holepolylinedict) #对以上生成的字典进行操作，生成新的字典。字典中对应的值“一行中所有通孔多段线”向上阵列布满整个菲林区域\r\n \r\n \r\n holenotefile=open('通孔模式说明'+'.txt','w') #输出通孔模式说明\r\n holenotefile.write(\"各通孔文件通孔数一览表(不包括5H):\\n\")\r\n for e in holepolylinearraydict:\r\n holeposfile=open(e+'.txt','w')\r\n centerposlist=calculatecenterpos(holepolylinearraydict[e])\r\n centerposlist.sort()\r\n holenotefile.write(\"通孔层 \"+e+\" 一共有通孔 \"+'{:d}'.format(len(centerposlist))+\" 个\\n\") #输出每一通孔层的中心点数。即对应通孔数量\r\n for pos in centerposlist:\r\n holeposfile.write('X{:.0f}Y{:.0f}\\n'.format(pos[0]*1000,pos[1]*1000)) #要格式化输出，所以先要乘以1000，然后输出小数点前的部分 \r\n holeposfile.close()","def transform(pts, ncfs, wo=2 * math.pi):\n npts = len(pts)\n h = ncfs // 2\n cfs = {}\n # Compute all coefficients\n for n in range(-h, h + 1):\n # Compute each coefficient\n cn = 0\n for iw in range(npts):\n w = iw / npts # w is not a frequency but the variable of a parametric equation\n fw = complex(*pts[iw])\n cn += fw * cmath.exp(-1j * n * w * wo)\n cn /= npts\n cfs[n] = cn\n return cfs","def dict_format(x_temp):\r\n\r\n shown_indexes = rangelist.range_find([Index(a_temp)\r\n for a_temp in x_temp[1]])\r\n if len(shown_indexes) < 20:\r\n return (abridge(x_temp[0],maxlength=30)\r\n +VERTLINE\r\n +shown_indexes)\r\n\r\n returnlist = []\r\n sp_temp = rangelist.split_up_range(shown_indexes,seg_length=3)\r\n\r\n\r\n returnlist.append(abridge(x_temp[0],maxlength=20)\r\n +VERTLINE+sp_temp[0])\r\n for s_temp in sp_temp[1:]:\r\n returnlist.append(VERTLINE+s_temp)\r\n\r\n return returnlist","def integrate(coords,data,fault_pts,dshape_hex8,gll_weights,elmt):\n norm=0.0\n normx=0.0\n normy=0.0\n normz=0.0\n div=0.0 #normalizing factor to divide by\n divx=0.\n divy=0.\n divz=0.\n\n eps=1.0*g.mesh_spacing/(g.ngllx-1.)\n print 'eps=', eps\n f=open('eliminated_coords.vtk','w')\n\n #create integer versions of arrays to use in pulling out gll pts for each element\n data_round=np.rint(data)\n dati=data_round.astype(int)\n coord_round=np.rint(coords)\n coordi=coord_round.astype(int)\n\n #remove duplicates from data array\n dat_struc=np.ascontiguousarray(dati).view(np.dtype((np.void,dati.dtype.itemsize *dati.shape[1])))\n _,idx=np.unique(dat_struc,return_index=True)\n datu=dati[idx]\n data_unique=data[idx]\n\n for i_elmt in range(g.nelmt):\n #pull out geometric coordinates for this element\n elmt_coord_id=[j-1 for j in elmt[i_elmt]]\n elmt_coord=coordi[elmt_coord_id]\n\n #find corresponding gll pts for this element\n xmin=min(elmt_coord[:,0]);xmax=max(elmt_coord[:,0])\n ymin=min(elmt_coord[:,1]);ymax=max(elmt_coord[:,1])\n zmin=min(elmt_coord[:,2]);zmax=max(elmt_coord[:,2])\n gll_coord_id=np.nonzero((datu[:,0]>=xmin) & (datu[:,0]<=xmax) & (datu[:,1]>=ymin) & (datu[:,1]<=ymax) & (datu[:,2]>=zmin) & (datu[:,2]<=zmax))\n elmt_data=data_unique[gll_coord_id]\n if len(gll_coord_id[0]) != g.ngll:\n print \"elmt=\", elmt_coord_id\n print xmin,xmax,ymin,ymax,zmin,zmax\n print 'elmt_data=', elmt_data\n print \"gll pts found=\", len(gll_coord_id[0])\n raise ValueError(\"incorrect number of gll points found in element!\")\n exit\n\n #sort the gll coords so they correspond the order of the arrays giving the weights and shape function\n dat_sorted=elmt_data[npi.argsort((elmt_data[:,0], elmt_data[:,1],elmt_data[:,2]))]\n func=dat_sorted[:,3:]\n\n #if any gll pt is too close to fault, remove the element from the integration\n dist=distance.cdist(fault_pts,dat_sorted[:,0:3],'euclidean')\n if (dist<eps).any():\n print \"eliminated element #\", i_elmt\n np.savetxt(f,dat_sorted[:,0:3],fmt='%3.3f')\n continue\n\n for i_gll in range(g.ngll):\n\n #compute jacobian, its derivative and inverse\n jac=np.matmul(dshape_hex8[:,:,i_gll],elmt_coord)\n det_jac=np.linalg.det(jac)\n\n #perform the integration\n norm=norm+det_jac*gll_weights[i_gll]*np.dot((func[i_gll,3:6]-func[i_gll,0:3]),(func[i_gll,3:6]-func[i_gll,0:3]))\n div=div+det_jac*gll_weights[i_gll]*np.dot(func[i_gll,3:6],func[i_gll,3:6])\n normx=normx+det_jac*gll_weights[i_gll]*(func[i_gll,3]-func[i_gll,0])**2\n divx=divx+det_jac*gll_weights[i_gll]*(func[i_gll,3])**2\n normy=normy+det_jac*gll_weights[i_gll]*(func[i_gll,4]-func[i_gll,1])**2\n divy=divy+det_jac*gll_weights[i_gll]*(func[i_gll,4])**2\n normz=normz+det_jac*gll_weights[i_gll]*(func[i_gll,5]-func[i_gll,2])**2\n divz=divz+det_jac*gll_weights[i_gll]*(func[i_gll,5])**2\n\n norm_finalx=sqrt(normx/divx)\n norm_finaly=sqrt(normy/divy)\n norm_finalz=sqrt(normz/divz)\n norm_final=sqrt(norm/div)\n\n f.close()\n\n return norm_finalx, norm_finaly, norm_finalz,norm_final","def draw(self, **kwargs):\n\n Lons = numpy.ones(self.data.shape)*0.5\n Lats = numpy.ones(self.data.shape)*0.5\n for ix in range(self.ncols):\n for iy in range(self.nrows):\n Lons[iy,ix] = self.xllcorner+float(ix)*self.cellsize\n Lats[iy,ix] = self.yllcorner+float(iy)*self.cellsize\n ContourMin = numpy.min(numpy.where(self.data != self.nodata,self.data, 1000000))\n ContourMax = numpy.max(numpy.where(self.data != self.nodata,self.data, -1000000))*1.10\n if kwargs.has_key('contours'):\n if type( kwargs['contours'] ) == type( 1 ):\n Contours = numpy.arange(ContourMin, ContourMax, (ContourMax-ContourMin)/float( kwargs['contours']+1))\n else:\n Contours = kwargs['contours']\n else:\n Contours = numpy.arange(ContourMin, ContourMax, (ContourMax-ContourMin)/11.)\n if kwargs.has_key('cmap'):\n mycmap = kwargs['cmap']\n else:\n mycmap = 'jet'\n if kwargs.has_key('dmap'):\n dmap = max(0,min(4,kwargs['dmap']))\n else:\n dmap = 4\n # Lambert Conformal Conic map.\n if kwargs.has_key('res'):\n if kwargs['res']=='med':\n mapres='i'\n elif kwargs['res']=='hi':\n mapres='h'\n else:\n mapres = 'l'\n else:\n mapres = 'l'\n if mapres not in ('c','l','i','h'):\n mapres = 'l'\n m = Basemap(llcrnrlon=Lons[0,0], llcrnrlat=Lats[0,0], urcrnrlon=Lons[self.nrows-1,self.ncols-1], urcrnrlat=Lats[self.nrows-1,self.ncols-1],\n projection='lcc',lat_1=30.,lat_2=60.,lon_0=(Lons[0,0]+Lons[self.nrows-1,self.ncols-1])/2.,\n resolution =mapres,area_thresh=1000.)\n # create figure, add axes.\n fig=p.figure()\n ax = fig.add_axes([0.1,0.1,0.7,0.7])\n #make a filled contour plot.\n x, y = m( Lons , Lats)\n CS = m.contourf(x,y,self.data, Contours, cmap=p.get_cmap(mycmap))\n\tpos = ax.get_position()\n\tl, b, w, h = getattr(pos, 'bounds', pos)\n #l,b,w,h=ax.get_position()\n cax = p.axes([l+w+0.075, b, 0.05, h]) # setup colorbar axes\n p.colorbar(drawedges=True, cax=cax) # draw colorbar\n p.axes(ax) # make the original axes current again\n\n if kwargs.has_key('shapefiles'):\n for s in kwargs['shapefiles']:\n try:\n lw = s[3]\n except:\n lw = 0.5\n try:\n clr = s[4]\n except:\n clr='k'\n shp_info = apply(m.readshapefile, (s[0],s[1]),{'drawbounds':s[2], 'linewidth':lw, 'color':clr} )\n # draw coastlines, meridians and parallels.\n if dmap > 1:\n m.drawcoastlines()\n if dmap > 2:\n m.drawcountries()\n if dmap > 3:\n m.drawstates()\n if dmap > 0:\n m.drawparallels(p.arange(10,70,10),labels=[1,1,0,0])\n m.drawmeridians(p.arange(-100,0,10),labels=[0,0,0,1])\n if kwargs.has_key('title'):\n p.title(kwargs['title'])\n else:\n p.title(self.name.title())\n if kwargs.has_key('format'):\n fn = self.name+'.'+kwargs['format']\n if kwargs.has_key('dpi'):\n dots = kwargs['dpi']\n else:\n dots = 100\n try:\n p.savefig(fn,dpi=dots)\n except:\n print 'Error saving to format : ', kwargs['format']\n else:\n p.show()","def compute_contour(ptr_array):\n hull = ConvexHull(ptr_array)\n contour_index = hull.vertices.tolist() # indices are ordered\n # contour_index = hull.simplices.flatten()\n # contour_index = list(set(contour_index))\n return contour_index","def load_drawings(self, contours, append=False):\n\n CONTOUR_IS_INTERPOLATED = 1\n\n if not append:\n self.drawings = defaultdict(list)\n\n endorser_contour_lookup = defaultdict(set)\n for cnt_id, contour in contours.iterrows():\n for editor in set([edit['username'] for edit in contour['edits']]):\n endorser_contour_lookup[editor].add(cnt_id)\n endorser_contour_lookup[contour['creator']].add(cnt_id)\n\n grouped = contours.groupby('section')\n\n for i_or_sec, group in grouped:\n # if i_or_sec not in self.data_feeder.sections: continue ## IS TIHS NECESSARY ?\n for contour_id, contour in group.iterrows():\n vertices = contour['vertices']\n contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\n self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\n linecolor='r', section=i_or_sec, type=contour_type,\n side=contour['side'],\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else False,\n side_manually_assigned=contour['side_manually_assigned'],\n edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'],\n contour_id=contour_id)\n\n # grouped = contours.groupby('position')\n #\n # for i_or_sec, group in grouped:\n # for contour_id, contour in group.iterrows():\n # vertices = contour['vertices']\n # contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\n # self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\n # linecolor='r', index=i_or_sec, type=contour_type,\n # side=contour['side'],\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else True,\n # edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'])","def add_rois_of_selected(self):\r\n \r\n for selected_index in self.selected_ML_Index:\r\n\r\n contours = self.selected_cells_infor_dict['cell{}_verts'.format(str(selected_index))]\r\n# contours = find_contours(self.Mask[:,:,selected_index], 0.5) # Find iso-valued contours in a 2D array for a given level value.\r\n \r\n for n, contour in enumerate(contours):\r\n contour_coord_array = contours[n]\r\n #Swap columns\r\n contour_coord_array[:, 0], contour_coord_array[:, 1] = contour_coord_array[:, 1], contour_coord_array[:, 0].copy()\r\n \r\n #Down sample the coordinates otherwise it will be too dense.\r\n contour_coord_array_del = np.delete(contour_coord_array, np.arange(2, contour_coord_array.shape[0]-3, 2), 0)\r\n \r\n self.selected_cells_infor_dict['cell{}_ROIitem'.format(str(selected_index))] = \\\r\n pg.PolyLineROI(positions=contour_coord_array_del, closed=True)\r\n \r\n self.Mask_edit_view.getView().addItem(self.selected_cells_infor_dict['cell{}_ROIitem'.format(str(selected_index))])","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 make_cspad_pix_coordinate_arrays (sp, xc_um, yc_um, orient_deg, tilt_deg) : # All lists of [4,8] \n sp.make_maps_of_2x1_pix_coordinates()\n\n sp.x_pix_um = np.zeros((sp.quads,sp.sects,sp.rows,sp.cols), dtype=np.float32)\n sp.y_pix_um = np.zeros((sp.quads,sp.sects,sp.rows,sp.cols), dtype=np.float32)\n\n angle_deg = orient_deg + tilt_deg\n \n for quad in range(sp.quads) :\n for sect in range(sp.sects) :\n\n angle_rad = math.radians(angle_deg[quad][sect]) \n S,C = math.sin(angle_rad), math.cos(angle_rad)\n Xrot, Yrot = rotation(sp.x_map2x1, sp.y_map2x1, C, S)\n\n sp.x_pix_um[quad][sect][:] = Xrot + xc_um[quad][sect]\n sp.y_pix_um[quad][sect][:] = Yrot + yc_um[quad][sect]\n\n sp.x_pix_um -= sp.x_pix_um.min() + 5 # add offset in um to get rid of \"rounding\" strips...\n sp.y_pix_um -= sp.y_pix_um.min() + 5","def polyhedra_from_xyz(xyz_file: str,\n try_convex_hull: bool = True)\\\n -> Tuple[List[Polyhedron],\\\n List[VertexCollection],\\\n List[Union[Polyhedron,VertexCollection]]]:\n\n object_coordinates_dict: Dict[str, List[List[float]]] = {}\n polyhedron_list: List[Polyhedron] = []\n vertex_collection_list: List[VertexCollection] = []\n object_list: List[Union[Polyhedron,VertexCollection]] = []\n type_order: List[str] = []\n with open(xyz_file, 'r') as f:\n lines = f.readlines()\n for i in range(len(lines)):\n line = lines[i].strip()\n if i == 0:\n l = re.search(\"\\d+$\", line)\n assert l is not None\n n_points = int(l.group())\n elif i == 1:\n l = re.search(\"\\d+$\", line)\n assert l is not None\n dim = int(l.group())\n assert dim <= 3, 'We cannot visualise the fourth dimension and\\\n above.'\n else:\n if line == '':\n continue\n l = re.search(\"([A-Za-z]+[0-9]*)[\\s\\t]+\", line)\n assert l is not None\n point_type = l.group(1)\n l2 = re.findall(\"[+-]?\\d+\\.\\d*\", line)\n point_coordinates = []\n for coordinate in l2:\n point_coordinates.append(float(coordinate))\n assert len(point_coordinates) == dim\n if point_type not in object_coordinates_dict:\n object_coordinates_dict[point_type] = []\n object_coordinates_dict[point_type].append(point_coordinates)\n if point_type not in type_order:\n type_order.append(point_type)\n\n for point_type in type_order:\n object_coordinates = np.array(object_coordinates_dict[point_type])\n if try_convex_hull:\n try:\n print(\"Attempting to construct a convex hull for {}...\"\\\n .format(point_type))\n polyhedron = construct_convex_hull_from_coords\\\n (object_coordinates)\n polyhedron_list.append(polyhedron)\n object_list.append(polyhedron) \n except:\n print(\"Failed to construct a convex hull for {}.\"\\\n .format(point_type))\n print(\"Falling back to vertex collection for {}...\"\\\n .format(point_type))\n vertex_collection = construct_vertex_collection_from_coords\\\n (object_coordinates, 2)\n vertex_collection_list.append(vertex_collection)\n object_list.append(vertex_collection) \n else:\n print(\"Constructing a vertex collection for {}...\"\\\n .format(point_type))\n vertex_collection = construct_vertex_collection_from_coords\\\n (object_coordinates, 2)\n vertex_collection_list.append(vertex_collection)\n object_list.append(vertex_collection) \n\n return polyhedron_list,vertex_collection_list,object_list","def sort_cutpoly_by_angle(self, polydata, cells_list, num_cells, numPoints):\n # 1: get numpy array of points from vtk polydata object\n points = polydata.GetPoints()\n pts = np.zeros((numPoints, 3), dtype=float)\n\n index = 0\n for cell in cells_list:\n for id in cell:\n pts[index] = np.asarray(points.GetPoint(id))\n index += 1\n\n # 2: convert them to 2d points and obtain the R rotation matrix\n pts_2d = project_onto_xy_plane(pts)\n\n # 3: compute center (average of all points)\n center_pt = np.mean(pts_2d, axis=0)\n\n # 4: find top points by pointdata label\n\n # 4: compute angles from center to average cell pts:nt vertical_dir = vert_pt_2d - center_pt # get vertical direction vector (from center pt to tp1)\n signed_angles = np.zeros((numPoints,), dtype=float)\n\n for i in range(numPoints):\n current_vec = pts_2d[i] - center_pt\n signed_angles[i] = compute_angle_between(vertical_dir, current_vec)\n self.pers_var = 1\n if self.pers_var: # ctrl-w for exit window key\n plt.figure()\n plt.scatter(center_pt[0], center_pt[1], color='r', s=2)\n plt.scatter(pts_2d[:,0], pts_2d[:,1], color='b', s=0.5)\n plt.scatter(vert_pt_2d[0], vert_pt_2d[1], color='g', s=10)\n plt.scatter(pts_2d[i][0], pts_2d[i][1], color='k', s=7)\n plt.xlabel('angle = ' + str(signed_angles[i]))\n figManager = plt.get_current_fig_manager()\n figManager.window.showMaximized()\n plt.show()\n\n # 5: sort angles (no matter ascending or descending)\n sorted_idxs = np.argsort(signed_angles)\n\n # 6: sorted points\n sorted_pts = pts[sorted_idxs]\n\n return sorted_pts, sorted_idxs","def _pco_list(self, hdr, name, pos):\n if name not in ('poly', 'champs', 'offset'):\n raise TypeError('Name must be one of \"poly\", \"champs\", or \"offset\".')\n\n hdr.seek(pos + 16)\n length = unpack(self._bo + 'i', hdr.read(4))[0]\n d = []\n for p in range(length):\n if name == 'poly':\n d.append(self._species(hdr))\n else:\n raise NotImplementedError(\n '{}List is non-null, don\\'t know how to read.'\n ''.format(name.capitalize()))\n hdr.seek(4, 1)\n return d","def output_grid_information():\n # translate = [-74.26, 40.50]\n # scale = [0.02, 0.02]\n # step = 1\n\n translate = [0, 0]\n scale = [1, 1]\n step = 0.02\n\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\n\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\n\n all_json = {\n \"type\": \"FeatureCollection\"\n }\n\n gr_id = 0\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\n features = []\n\n for lat in lats:\n for lon in lons:\n w_lon = lon\n e_lon = lon + step\n s_lat = lat\n n_lat = lat + step\n\n c_lon = lon + step / 2\n c_lat = lat + step / 2\n\n grid_df = grid_df.append(pd.DataFrame({\"gr_id\": [gr_id],\n \"c_lon\": [c_lon], \"c_lat\": [c_lat],\n \"w_lon\": [w_lon], \"s_lat\": [s_lat],\n \"e_lon\": [e_lon], \"n_lat\": [n_lat]}))\n\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\n [s_lat, e_lon], [s_lat, w_lon]]]\n\n feature = {\n \"type\": \"Feature\",\n \"geometry\": {\n \"type\": \"Polygon\",\n \"coordinates\": coor\n },\n \"properties\": {\n \"id\": str(gr_id)\n }\n }\n\n features.append(feature)\n\n gr_id += 1\n\n all_json['features'] = features\n\n with open(BaseDir + '/grid.geojson', 'w') as f:\n json.dump(all_json, f)\n\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)","def plotConic(L, R, points_x, points_y, xBounds=[-50,50], yBounds=[-50,50]): \n \n x = np.linspace(xBounds[0],xBounds[1],5000)\n y = np.linspace(yBounds[0],yBounds[1],5000)\n x, y = np.meshgrid(x, y)\n #assert B**2 - 4*A*C == 0 \n A = L[0,0]\n B = 2*L[0,1]\n C = L[1,1]\n D = 2*L[0,2]\n E = 2*L[1,2]\n F = L[2,2] \n plt.contour(x, y,(A*x**2 + B*x*y + C*y**2 + D*x + E*y + F), [0], colors='g')\n A = R[0,0]\n B = 2*R[0,1]\n C = R[1,1]\n D = 2*R[0,2]\n E = 2*R[1,2]\n F = R[2,2] \n plt.contour(x, y,(A*x**2 + B*x*y + C*y**2 + D*x + E*y + F), [0], colors='r')\n plt.scatter(points_x, points_y, marker='o', color='k')\n plt.show()","def contours_to_patient_coord_sys_and_points_to_skull_axial_axis(datasets, series_arr):\n mean_points_real = [0, 0, 0] # to storage points on the skull axis line (healthy slices)\n contours_list = [None] * series_arr.shape[2] # list of all contours of all slices\n contours_mean_point_list = [None] * series_arr.shape[2] # list of all mean points of contours of interest\n rotation_info_list = [] # to storage rotation info found by the icp\n # Converts all contours for patient coordinate space based on DICOM tag information\n for i in range(series_arr.shape[2]):\n img = series_arr[:, :, i]\n # Collecting image information\n img_orient_pat = [float(x) for x in list(datasets[i].ImageOrientationPatient)]\n img_position_pat = [float(x) for x in list(datasets[i].ImagePositionPatient)]\n pixel_spacing = [float(x) for x in list(datasets[i].PixelSpacing)]\n iop1 = np.array(img_orient_pat[0:3])\n iop2 = np.array(img_orient_pat[3:6])\n # Finding contours\n [cw, pma] = select_contours(img)\n # Setting which one is the internal / external contour (internal=[0], external=[1]) when needed\n if len(pma) == 2:\n contour_0_len = len(cw[0])\n contour_1_len = len(cw[1])\n if contour_0_len >= contour_1_len:\n cw[0], cw[1] = cw[1], cw[0]\n cw_real = copy.copy(cw)\n # Coordinate system conversion for all contours\n for contour in cw_real:\n for k in range(len(contour)):\n contour[k] = img_position_pat \\\n + iop1 * pixel_spacing[1] * contour[k][0] \\\n + iop2 * pixel_spacing[0] * contour[k][1]\n contours_list[i] = cw_real\n # Collecting points to skull axial axis and lateral symmetry calculation\n if len(pma) == 2: # healthy skull slice has outside and inside contours (pixel_mean_array has 2 points)\n # uses the mean point of the external contour (contours are approx. concentric)\n pixel_mean_real = img_position_pat \\\n + iop1 * pixel_spacing[1] * pma[1][0] \\\n + iop2 * pixel_spacing[0] * pma[1][1]\n contours_mean_point_list[i] = pixel_mean_real\n mean_points_real = np.vstack([mean_points_real, pixel_mean_real])\n # Lateral symmetry\n # external_contour_mirrored = mirror_contour_point(cw_real[1][:, 0:2], pixel_mean_real[0:2])\n # T = icp_wrap(cw_real[1][:, 0:2], external_contour_mirrored, debug=True)\n # rotation_info_list.append(T)\n\n return contours_list","def cfdProcessElementTopology(self):\r\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \r\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\r\n\r\n ## (list of lists) list of face indices forming each element\r\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\r\n \r\n #populates self.elementNeighbours\r\n for iFace in range(self.numberOfInteriorFaces):\r\n own=self.owners[iFace]\r\n nei=self.neighbours[iFace]\r\n \r\n #adds indices of neighbour cells\r\n self.elementNeighbours[own].append(nei)\r\n self.elementNeighbours[nei].append(own)\r\n \r\n #adds interior faces\r\n self.elementFaces[own].append(iFace)\r\n self.elementFaces[nei].append(iFace)\r\n \r\n #adds boundary faces ('patches')\r\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\r\n own=self.owners[iFace]\r\n self.elementFaces[own].append(iFace)\r\n \r\n ## List of lists containing points forming each element\r\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n \r\n for faceIndex in self.elementFaces[iElement]:\r\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\r\n \r\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\r\n \r\n ## Upper coefficient indices (owners)\r\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n ## Lower coefficient indices (owners)\r\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n ## Element number from 1 to numberOfElements + 1\r\n iNb=1\r\n for faceIndex in self.elementFaces[iElement]:\r\n \r\n #skip if it is a boundary face\r\n if faceIndex > self.numberOfInteriorFaces-1:\r\n continue\r\n \r\n own = self.owners[faceIndex]\r\n nei = self.neighbours[faceIndex]\r\n \r\n if iElement == own:\r\n self.upperAnbCoeffIndex[faceIndex] = iNb\r\n elif iElement == nei:\r\n self.lowerAnbCoeffIndex[faceIndex] = iNb\r\n \r\n iNb = iNb +1","def generatePolygons():","def collect_lines(xy, BL, bs, climv):\n lines = [zip(xy[BL[i, :], 0], xy[BL[i, :], 1]) for i in range(len(BL))]\n line_segments = LineCollection(lines, # Make a sequence of x,y pairs\n linewidths=1., # could iterate over list\n linestyles='solid',\n cmap='coolwarm',\n norm=plt.Normalize(vmin=-climv, vmax=climv))\n line_segments.set_array(bs)\n print(lines)\n return line_segments","def buildxy(self):\n\n x_dim = float(self.metadata['XPTS'])\n xmin = float(self.metadata['XMIN'])\n xrange = float(self.metadata['XWID'])\n\n d_x = xrange/(x_dim-1)\n x_axis = (np.arange(xmin, xmin+x_dim*d_x, d_x))\n\n # y_dim = float(\"\".join(ProcessSpectra.get_from_dict('YPTS')))\n # ymin = list(map(float, get_from_dict('YMIN')))\n # yrange = float(\"\".join(ProcessSpectra.get_from_dict('YWID')))\n\n frwidth = 1000/(x_axis[0])\n frinc = frwidth/(len(self.zdata))\n freq = np.arange(-frwidth, frwidth, frinc*2)\n xdata = freq\n ydata = freq\n\n return xdata, ydata","def bezierPoly(ctrlP):\n n = len(ctrlP) - 1 #degree of the polynomial\n first = True\n for t in np.linspace(0.0, 1.0, 5 * n):\n point = bezierFunc(ctrlP, t)\n if first: # Initialize list of points in the polynomial\n bezierPointsList = np.copy(point)\n first = False\n else:\n bezierPointsList = np.append(bezierPointsList, point, axis=0)\n return bezierPointsList","def cell_verts(self, idx):\r\n coords = []\r\n xyz = [0, 0, 0]\r\n cell = self.grid.GetCell(idx[0] - 1, idx[1] - 1, idx[2] - 1)\r\n p_ids = cell.GetPointIds()\r\n n_ids = pointIds.GetNumberOfIds()\r\n for n in range(n_ids):\r\n p = p_ids.GetId(n)\r\n self.grid.GetPoint(p, xyz)\r\n coords.append(copy.deepcopy(xyz))\r\n return coords","def collisionFromLoops(mesh):\n polys = list()\n for f in mesh.polygons:\n for lID in f.loop_indices:\n loop = mesh.loops[lID]\n #vIndex = IDTransl[loop.vertex_index]\n\n #creating a polyVert with only the poly index, since we only need that for collisions\n polys.append(PolyVert(loop.vertex_index))\n \n return [ polys ]","def GetCVLSWithLimitedPointsBetweenNodes(\n cVLS, allValsByFrame, splitLength=1, fixedNumInteriorPoints=None, interpolate=True\n):\n allValues = list(set(tuple(flatten(allValsByFrame))))\n allPairs = sorted(\n list(set([tuple(c[0]) for cVLSByFrame in cVLS for c in cVLSByFrame]))\n ) # Value pairs...\n\n if fixedNumInteriorPoints:\n numInteriorPoints = {p: fixedNumInteriorPoints for p in allPairs}\n else:\n minLength = {}\n for p in allPairs:\n # minLength is the number of points of the shortest subcountour between cells p[0] and p[1] from all frames\n minLength[p] = min(\n [\n len(c[2])\n for cVLSByFrame in cVLS\n for c in cVLSByFrame\n if tuple(c[0]) == p\n ]\n )\n # length of subcontour\n numInteriorPoints = {}\n for p in allPairs:\n numInteriorPoints[p] = minLength[p] // splitLength\n\n cVLS2 = deepcopy(\n cVLS\n ) # otherwise, we'd also change the input argument cVLS in the outside world!\n limIntPtsFunc = (\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\n )\n\n for cvlsByFrame in cVLS2:\n for c in cvlsByFrame:\n c[2] = limIntPtsFunc(c[2], numInteriorPoints[tuple(c[0])])\n\n return cVLS2","def calc_positions(zpoints, dsq_list):\n\n pos_map = {}\n points_map = {}\n\n for z, p in zpoints.items():\n if z in dsq_list:\n p = -1\n if p not in points_map:\n points_map[p] = set()\n points_map[p].add(z)\n\n i = 1\n for p in sorted(list(points_map.keys()), reverse = True):\n pos_map[i] = points_map[p]\n i += len(points_map[p])\n\n return pos_map","def extract_data(data_file):\n\n data_points = set()\n points_to_coordinates = {}\n x_coor_dict = {}\n # need this since we need to iterate through the first point indices in a fixed order\n first_point_indices = []\n\n with open(data_file) as input_file:\n # consume the first line, it only tells us how many points there are\n input_file.readline()\n point_number = 0\n current_x_coor = inf\n # point that's used as the indexing point for a list of points with the same x coordinates\n first_point_index = 1\n\n for line in input_file:\n point_number += 1\n line = line.strip('\\n')\n split_line = line.split(\" \")\n print(split_line)\n x_coor = float(split_line[1])\n # if we're seeing this x coordinate for the first time\n if current_x_coor != x_coor:\n first_point_index = point_number\n first_point_indices.append(first_point_index)\n x_coor_dict[first_point_index] = []\n current_x_coor = x_coor\n x_coor_dict[first_point_index].append(point_number)\n new_point = Point(x_coor, float(split_line[2]))\n points_to_coordinates[point_number] = new_point\n data_points.add(point_number)\n\n return data_points, points_to_coordinates, x_coor_dict, first_point_indices","def update_ptable(self):\n from bokeh.sampledata.periodic_table import elements\n romans = [\"I\", \"II\", \"III\", \"IV\", \"V\", \"VI\", \"VII\"]\n\n elements[\"atomic mass\"] = elements[\"atomic mass\"].astype(str)\n\n elements[\"period\"] = [x for x in elements.period]\n elements = elements[elements.group != \"-\"]\n\n group_range = [str(x) for x in range(1, 19)]\n print ('reaches colormap def')\n colormap = {\n \"c\" : \"#ffa07a\",\n \"nc\" : \"#A9A9A9\"\n }\n elems_colorpair = {}\n\n fcc_B_extrapol_props = {}\n fcc_dB_extrapol_props = {}\n fcc_V0_extrapol_props = {}\n fcc_E0_extrapol_props = {}\n\n bcc_B_extrapol_props = {}\n bcc_dB_extrapol_props = {}\n bcc_V0_extrapol_props = {}\n bcc_E0_extrapol_props = {}\n\n hcp_B_extrapol_props = {}\n hcp_dB_extrapol_props = {}\n hcp_V0_extrapol_props = {}\n hcp_E0_extrapol_props = {}\n\n available_elems = []\n\n for e in elements[\"symbol\"]:\n if e in np.unique(list(self.plot_data['element'])):\n available_elems.append(e)\n for s in np.unique(list(self.plot_data['structure'])):\n plot_struct = self.plot_data[self.plot_data['structure']==s]\n plot_struct_elem = plot_struct[plot_struct['element']==e]\n if s=='fcc':\n try:\n fcc_B_extrapol_props.update({e:list(plot_struct_elem['B'])[0]})\n\n fcc_dB_extrapol_props.update({e:list(plot_struct_elem['BP'])[0]})\n\n fcc_V0_extrapol_props.update({e:list(plot_struct_elem['V0'])[0]})\n\n fcc_E0_extrapol_props.update({e:list(plot_struct_elem['E0'])[0]})\n except:\n pass\n elif s=='bcc':\n try:\n bcc_B_extrapol_props.update({e:list(plot_struct_elem['B'])[0]})\n\n bcc_dB_extrapol_props.update({e:list(plot_struct_elem['BP'])[0]})\n\n bcc_V0_extrapol_props.update({e:list(plot_struct_elem['V0'])[0]})\n\n bcc_E0_extrapol_props.update({e:list(plot_struct_elem['E0'])[0]})\n except:\n pass\n elif s=='hcp':\n try:\n hcp_B_extrapol_props.update({e:list(plot_struct_elem['B'])[0]})\n\n hcp_dB_extrapol_props.update({e:list(plot_struct_elem['BP'])[0]})\n\n hcp_V0_extrapol_props.update({e:list(plot_struct_elem['V0'])[0]})\n\n hcp_E0_extrapol_props.update({e:list(plot_struct_elem['E0'])[0]})\n except:\n pass\n fcc_E0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_E0_extrapol_props})\n fcc_V0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_V0_extrapol_props})\n fcc_B_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_B_extrapol_props})\n fcc_dB_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_dB_extrapol_props})\n\n bcc_E0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_E0_extrapol_props})\n bcc_V0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_V0_extrapol_props})\n bcc_B_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_B_extrapol_props})\n bcc_dB_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_dB_extrapol_props})\n\n hcp_E0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_E0_extrapol_props})\n hcp_V0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_V0_extrapol_props})\n hcp_B_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_B_extrapol_props})\n hcp_dB_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_dB_extrapol_props})\n\n elems_colorpair.update( { key:'c' for key in np.unique(available_elems) } )\n elems_colorpair.update( { key:'nc' for key in list(elements['symbol']) if key not in list(elems_colorpair.keys()) } )\n\n\n print ([ colormap[elems_colorpair[x]] for x in elements['symbol'] ])\n\n source = ColumnDataSource(\n data=dict(\n group=[str(x) for x in elements[\"group\"]],\n period=[str(y) for y in elements[\"period\"]],\n symx=[str(x)+\":0.1\" for x in elements[\"group\"]],\n numbery=[str(x)+\":0.8\" for x in elements[\"period\"]],\n massy=[str(x)+\":0.15\" for x in elements[\"period\"]],\n namey=[str(x)+\":0.3\" for x in elements[\"period\"]],\n sym=elements[\"symbol\"],\n name=elements[\"name\"],\n# cpk=elements[\"CPK\"],\n atomic_number=elements[\"atomic number\"],\n# electronic=elements[\"electronic configuration\"],\n fcc_B=[fcc_B_extrapol_props[x] for x in elements[\"symbol\"]],\n fcc_dB=[fcc_dB_extrapol_props[x] for x in elements[\"symbol\"]],\n fcc_V0=[fcc_V0_extrapol_props[x] for x in elements[\"symbol\"]],\n fcc_E0=[fcc_E0_extrapol_props[x] for x in elements[\"symbol\"]],\n bcc_B=[bcc_B_extrapol_props[x] for x in elements[\"symbol\"]],\n bcc_dB=[bcc_dB_extrapol_props[x] for x in elements[\"symbol\"]],\n bcc_V0=[bcc_V0_extrapol_props[x] for x in elements[\"symbol\"]],\n bcc_E0=[bcc_E0_extrapol_props[x] for x in elements[\"symbol\"]],\n hcp_B=[hcp_B_extrapol_props[x] for x in elements[\"symbol\"]],\n hcp_dB=[hcp_dB_extrapol_props[x] for x in elements[\"symbol\"]],\n hcp_V0=[hcp_V0_extrapol_props[x] for x in elements[\"symbol\"]],\n hcp_E0=[hcp_E0_extrapol_props[x] for x in elements[\"symbol\"]],\n type=elements[\"metal\"],\n type_color=[ colormap[elems_colorpair[x]] for x in elements['symbol'] ],\n )\n )\n\n # plot the periodic layout\n #name = source.data[\"name\"]\n #B = source.data[\"B\"]\n\n ptable = figure(title=\"Periodic Table\", tools=\"hover\",\n x_range=group_range, y_range=list(reversed(romans)))\n ptable.background_fill_color='white'\n ptable.plot_width = 1500\n ptable.toolbar_location = None\n ptable.outline_line_color = None\n\n ptable.rect(\"group\", \"period\", 0.9, 0.9, source=source,\n fill_alpha=0.3, color='type_color')\n\n text_props = {\n \"source\": source,\n \"angle\": 0,\n \"color\": \"black\",\n \"text_align\": \"left\",\n \"text_baseline\": \"middle\"\n }\n\n ptable.text(x=\"symx\", y=\"period\", text=\"sym\",\n text_font_style=\"bold\", text_font_size=\"22pt\", **text_props)\n\n ptable.text(x=\"symx\", y=\"numbery\", text=\"atomic_number\",\n text_font_size=\"9pt\", **text_props)\n\n# ptable.text(x=\"symx\", y=\"namey\", text=\"name\",\n# text_font_size=\"6pt\", **text_props)\n\n# ptable.text(x=\"symx\", y=\"massy\", text=\"mass\",\n# text_font_size=\"5pt\", **text_props)\n\n ptable.grid.grid_line_color = None\n\n\n ptable.select_one(HoverTool).tooltips = [\n (\"name\", \"@name\"),\n (\"fcc, V0 (A^3 per atom)\", \"@fcc_V0\"),\n (\"fcc, B (GPa)\", \"@fcc_B\"),\n (\"fcc, dB/dP\", \"@fcc_dB\"),\n (\"bcc, V0 (A^3 per atom)\", \"@bcc_V0\"),\n (\"bcc, B (GPa)\", \"@bcc_B\"),\n (\"bcc, dB/dP\", \"@bcc_dB\"),\n (\"hcp, V0 (A^3 per atom)\", \"@hcp_V0\"),\n (\"hcp, B (GPa)\", \"@hcp_B\"),\n (\"hcp, dB/dP\", \"@hcp_dB\")]\n return ptable","def _store_2D_coefficients(hdr, poly_model, coeff_prefix, keeplinear=False):\n mindeg = int(not keeplinear)\n degree = poly_model.degree\n for i in range(0, degree + 1):\n for j in range(0, degree + 1):\n if (i + j) > mindeg and (i + j < degree + 1):\n hdr[f'{coeff_prefix}_{i}_{j}'] = getattr(poly_model, f'c{i}_{j}').value","def drawContourLine(xlist, ylist, level):\n dislin.concrv(xlist, ylist, len(xlist), level)","def _get_unstructured_collection(vlon, vlat, xm, vmin, vmax, basemap_object=None):\n\n #init\n Path = mpath.Path\n patches = []\n pdata = xm[0, :] * 1. # full list of data\n vmsk = np.ones_like(pdata).astype('bool') # mask to indicate which cells contain valid data\n\n for i in xrange(x.ncell):\n if np.any(vlon[i, :]) > 180.: # todo fix this properly !!!\n vmsk[i] = False\n continue\n if basemap_object is None:\n xv = vlon[i, :]\n yv = vlat[i, :]\n else:\n xv, yv = basemap_object(vlon[i, :], vlat[i, :]) # todo: how to properly deal with boundary problem ????\n if (vlon[i, :].min() < -100.) & (vlon[i, :].max() > 100.): # todo\n #... triangles across the boundaries of the projection are a problem\n # ... solution: generate two triangles ! TODO\n vmsk[i] = False\n continue\n\n verts = np.asarray([xv, yv]).T\n\n #--- specify how vertices are interconnected (here simple connection by lines)\n codes = [Path.MOVETO, Path.LINETO, Path.LINETO]\n\n #--- construct object and append to library of objects ---\n path = mpath.Path(verts, codes, closed=True)\n patches.append(mpatches.PathPatch(path))\n\n pdata = np.asarray(pdata)\n\n if vmin is None:\n vmin = pdata.min()\n if vmax is None:\n vmax = pdata.max()\n\n norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)\n collection = PatchCollection(patches, cmap=cmap, norm=norm, alpha=1., match_original=False, edgecolors='grey') # construct library of all objects\n collection.set_array(pdata[vmsk]) # assign data values here\n\n return collection","def plot_vor_boundary(self,x,ax,tri=False):\n\n x = x[~np.isnan(x[:,0])]\n c_types_print = np.ones(x.shape[0],dtype=np.int32)*-1\n c_types_print[:self.n_C] = self.c_types\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(x))\n\n\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\n if type(self.c_types) is list:\n # ax.scatter(x[:, 0], x[:, 1],color=\"grey\",zorder=1000)\n for region in regions:\n polygon = vertices[region]\n plt.fill(*zip(*polygon), alpha=0.4, color=\"grey\")\n\n else:\n cols = self.cols\n patches = []\n if self.plot_scatter is True:\n ax.scatter(x[:self.n_C, 0], x[:self.n_C, 1], color=\"black\", zorder=1000)\n ax.scatter(x[self.n_C:, 0], x[self.n_C:, 1], color=\"grey\", zorder=1000)\n\n for i, region in enumerate(regions):\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],edgecolor=\"white\",alpha=0.5))\n\n p = PatchCollection(patches, match_original=True)\n # p.set_array(c_types_print)\n ax.add_collection(p)\n if tri is not False:\n for TRI in tri:\n for j in range(3):\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\n if (a >= 0) and (b >= 0):\n X = np.stack((x[a], x[b])).T\n ax.plot(X[0], X[1], color=\"black\")","def distance_from_boundaries(xy, boundaries, PVxydict, interp_n=None, check=False):\n jj = 0\n dists = []\n # print 'dists = ', dists\n # print 'boundaries = ', boundaries\n null = np.array([0., 0.])\n if not isinstance(boundaries, tuple):\n if len(np.shape(boundaries)) > 1:\n print 'boundaries = ', boundaries\n print 'np.shape(boundaries) = ', np.shape(boundaries)\n raise RuntimeError('assuming boundary has been stored as M x #boundaries array, where each boundary has '\n + 'M elements, but it should be given as tuple or single array')\n else:\n boundary = tuple([boundaries])\n\n # If there is no periodicity, then make PVxydict an empty dict\n if PVxydict is None:\n PVxydict = {}\n\n for boundary in boundaries:\n if interp_n is None:\n boundarypts = xy[boundary]\n else:\n xb = []\n yb = []\n nn = len(boundary)\n for ii in range(nn):\n # Get periodic vector by which\n if (ii, nn) in PVxydict:\n pvii = PVxydict[(ii, nn)]\n elif (nn, ii) in PVxydict:\n pvii = - PVxydict[(nn, ii)]\n else:\n pvii = null\n xb.append(np.linspace(xy[boundary[ii], 0],\n xy[boundary[(ii + 1) % nn], 0] + pvii[0], interp_n + 2).tolist())\n yb.append(np.linspace(xy[boundary[ii], 1],\n xy[boundary[(ii + 1) % nn], 1] + pvii[1], interp_n + 2).tolist())\n\n xb = np.array(xb).ravel()\n yb = np.array(yb).ravel()\n if check:\n print 'xnew = ', xb\n print 'ynew = ', yb\n plt.scatter(xb, yb, alpha=0.3, c='r')\n plt.plot(xy[:, 0], xy[:, 1])\n plt.show()\n\n boundarypts = np.dstack((xb, yb))[0]\n\n d_all = dh.dist_pts(xy, boundarypts)\n # print 'd_all = ', d_all\n dists.append(np.min(d_all, axis=1))\n jj += 1\n\n return tuple(dists)","def plot_figure11():\n height_ceilings = [200., 300., 400.]\n height_ceiling_ids = [list(height_range_ceilings).index(height_ceiling) for height_ceiling in height_ceilings]\n\n baseline_height_ceiling = 500.\n baseline_height_ceiling_id = list(height_range_ceilings).index(baseline_height_ceiling)\n\n plot_item00 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[0], :, :],\n 'contour_fill_levels': np.linspace(50, 100, 21),\n 'contour_line_levels': [70., 80., 90., 95.],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(50, 100, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n 'extend': 'min',\n }\n plot_item01 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[1], :, :],\n 'contour_fill_levels': np.linspace(70, 100, 21),\n 'contour_line_levels': [70., 80., 90., 95.],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(70, 100, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n 'extend': 'min',\n }\n plot_item02 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[2], :, :],\n 'contour_fill_levels': np.linspace(80, 100, 21),\n 'contour_line_levels': [70., 80., 90., 95.],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(80, 100, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n 'extend': 'min',\n }\n\n column_titles = [\"200 m\", \"300 m\", \"400 m\"]\n plot_items = [plot_item00, plot_item01, plot_item02]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\n\n linspace10 = np.linspace(0., 11., 21)\n plot_item10 = {\n 'data': -(100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[0], :, :])+\n (100.-nc.variables[\"p_ceiling_rank40\"][baseline_height_ceiling_id, :, :]),\n 'contour_fill_levels': linspace10,\n 'contour_line_levels': sorted([1.1]+list(linspace10[::4])),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': linspace10[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability decrease [%]',\n }\n linspace11 = np.linspace(0., 23., 21)\n plot_item11 = {\n 'data': (100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[1], :, :])-\n (100.-nc.variables[\"p_ceiling_rank40\"][baseline_height_ceiling_id, :, :]),\n 'contour_fill_levels': linspace11,\n 'contour_line_levels': sorted([2.3]+list(linspace11[::4])),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': linspace11[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability increase [%]',\n }\n linspace12 = np.linspace(0., 38., 21)\n plot_item12 = {\n 'data': (100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[2], :, :])-\n (100.-nc.variables[\"p_ceiling_rank40\"][baseline_height_ceiling_id, :, :]),\n 'contour_fill_levels': linspace12,\n 'contour_line_levels': sorted([3.8]+list(linspace12[::4])),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': linspace12[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability increase [%]',\n }\n\n column_titles = None\n plot_items = [plot_item10, plot_item11, plot_item12]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)","def fun_contours(self, params):\n shape_coeffs = params[:self.num_shape_params]\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\n\n vertices3d = self.vertices3d\n vertices3d_from_mesh = np.zeros_like(vertices3d)\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\n\n inner_idx = 0\n for idx in range(vertices3d.shape[0]):\n lm_idx = idx % 66\n obs_num = int(np.floor(idx/66))\n\n if lm_idx in self.contour_lms_list[0]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_right[obs_num])\n elif lm_idx in self.contour_lms_list[1]:\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\n vertices3d_left[obs_num])\n else:\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\n inner_idx += 1\n if inner_idx == 50:\n inner_idx = 0\n\n return (vertices3d_from_mesh - vertices3d).ravel()","def PVxydict2PV(PVxydict, check=False, periodic_strip=False):\n # Make a flattened list of periodic vectors so that all elements are 2 x 1\n pvlist = []\n for key in PVxydict:\n tmp = PVxydict[key]\n if len(np.shape(tmp)) == 1:\n pvlist.append(tmp)\n else:\n for row in tmp:\n pvlist.append(row)\n\n if check:\n print 'le: pvlist = ', pvlist\n pvarr = np.array(pvlist)\n pvs = dh.unique_rows(pvarr)\n if check:\n print 'le: pvs = ', pvs\n if len(pvs) > 0:\n print 'le: pvs = ', pvs\n if (pvs[:, 1] < 0).all():\n pvs[:, 1] = -pvs[:, 1]\n\n minax = np.argmin(np.abs(pvs[:, 0]))\n minay = np.argmin(np.abs(pvs[:, 1]))\n # Order the vectors by x-dominant, y-dominant, with both dominant vector components > 0, ie\n # PV -> [[+Lx, small], [small, +Ly]]\n if (pvs[:, 1] == pvs[0, 1]).all() and not periodic_strip:\n print 'le.PVxydict2PV: two lattice vecs have the same Y value, adding them together...'\n maxx = np.argmax(pvs[:, 0])\n other = np.setdiff1d([0, 1], [maxx])\n pvnew = pvs[maxx] - pvs[other]\n PV = np.vstack((pvnew, pvs[maxx]))\n print 'le.PVxydict2PV: PV = ', PV\n elif not periodic_strip:\n if minax != minay:\n PV = np.vstack((pvs[minax], pvs[minay]))\n else:\n if minay == 0:\n other = 1\n else:\n other = 0\n PV = np.vstack((pvs[minay], pvs[other]))\n else:\n print 'le.PVxydict2PV: since periodic_strip, returning single 1 x 2 PV array'\n PV = pvs\n\n if check:\n print 'le.PVxydict2PV: PV = ', PV\n else:\n print 'le: No periodic vectors found, returning empty PV array'\n PV = pvs\n\n print 'le: PVxydict2PV: returning PV'\n return PV","def surface_contacts(struc,SASA):\n\tplot_single = False\n\n\tcmap_cutoff = 5.0 # nm\n\tsasa_cutoff = 0.5\n\t# identify surface residues\n\tS = []\n\tN = np.array(range(struc.n_residues))\n\tfor r in N:\n\t\tind = struc.topology.select('resid '+str(r))\n\t\tSASA_per_res = np.sum(SASA[0][ind[0]:ind[-1]],axis=0)\n\t\tif SASA_per_res > sasa_cutoff:\n\t\t\tS.append(SASA_per_res)\n\t\telse:\n\t\t\tS.append(0.0)\n\t#import ipdb; ipdb.set_trace()\n\tsurf_res = N[np.where(np.array(S) > 0)]\n\tcmap = contact_maps(struc.atom_slice(struc.topology.select('name CA'))[0].xyz[0])\n\tfor n in N:\n\t\tfor m in N:\n\t\t\tif (n not in surf_res or m not in surf_res) or n < m:\n\t\t\t\tcmap[n][m] = 0\n\t\t\telif cmap[n][m] < cmap_cutoff:\n\t\t\t\tcmap[n][m] = 1\n\tif plot_single == True:\n\t\tfor it,rn in enumerate(resnames):\n\t\t\tif rn in hydrophobic:\n\t\t\t\tplt.axhline(y=it,c='grey',linewidth=2)\n\t\t\t\tplt.axvline(x=it,c='grey',linewidth=2)\n\t\t\telif rn in hydrophilic:\n\t\t\t\tplt.axhline(y=it,c='g',linewidth= 2)\n\t\t\t\tplt.axvline(x=it,c='g',linewidth= 2)\n\t\t\telif rn in poscharge:\n\t\t\t\tplt.axhline(y=it,c='b',linewidth= 2)\n\t\t\t\tplt.axvline(x=it,c='b',linewidth= 2)\n\t\t\telif rn in negcharge:\n\t\t\t\tplt.axhline(y=it,c='r',linewidth= 2)\n\t\t\t\tplt.axvline(x=it,c='r',linewidth= 2)\n\t\t\telse:\n\t\t\t\tprint \"unknown restype:\", rn\n\t\tscat = np.array(zip(np.where(np.array(cmap) > 0)[0], np.where(np.array(cmap) > 0)[1])).T\n\t\tplt.scatter(scat[0], scat[1],marker='s',c='k',s=90)\n\t\t#plt.imshow(cmap,cmap='Greys')\n\t\tplt.show()\n\treturn cmap","def get_ptsByCntByRoi(rts, sopuids, p2c=False):\n \n # Get the ContourSequence-to-slice indices by ROI:\n c2sIndsByRoi, c2sInds = get_c2sIndsByRoi(rts, sopuids)\n \n numRois = len(c2sIndsByRoi)\n \n if p2c:\n print('\\n\\n', '-'*120)\n print('Running of get_ptsByCntByRoi():')\n print('\\n\\n', '-'*120)\n #print(f' c2sIndsByRoi = {c2sIndsByRoi}')\n print_indsByRoi(c2sIndsByRoi)\n print(f'numRois = {numRois}')\n \n ptsByCntByRoi = []\n \n for r in range(numRois):\n # Number of contours in this ROI:\n numCnts = len(c2sIndsByRoi[r])\n \n # Get a list of the ContourSequences in this ROI:\n #sequences = deepcopy(rts.ROIContourSequence[r].ContourSequence)\n sequences = list(rts.ROIContourSequence[r].ContourSequence)\n \n # Get a list of all ReferencedSOPInstanceUIDs from ContourSequences:\n #RefSopUids = [sequence.ContourImageSequence[0]\\\n # .ReferencedSOPInstanceUID for sequence in ContourSequences]\n \n if False:#p2c:\n print(f' r = {r}')\n print(f' numCnts = {numCnts}')\n print(f' number of Contour Sequences = {len(sequences)}')\n \n ptsByCnt = []\n \n # Loop through each contour sequence:\n for c in range(len(sequences)):\n # Get the indices of all matching RefSopUids:\n #ind = RefSopUids.index(SopUid) # this will only find the first \n # match, and there may be more than one!\n #inds = [i for i, e in enumerate(RefSopUids) if e==SopUid]\n \n # Iterate for each index in inds:\n #for ind in inds:\n \n #ContourSequence = deepcopy(ContourSequences[c])\n \n #ContourData = [float(item) for item in ContourSequence.ContourData]\n \n #cntData = deepcopy(sequence.ContourData)\n cntData = list(sequences[c].ContourData)\n \n pts = cntdata_to_pts(cntData)\n \n ptsByCnt.append(pts)\n \n if False:#p2c:\n print(f' c = {c}')\n print(f' len(pts) = {len(pts)}')\n \n ptsByCntByRoi.append(ptsByCnt)\n \n cntdataByCntByRoi = ptsByCntByRoi_to_cntdataByCntByRoi(\n ptsByCntByRoi\n )\n \n if p2c:\n #R = len(ptsByCntByRoi)\n #print(f'\\n len(ptsByCntByRoi) = {R}')\n #for r in range(R):\n # print(f' len(ptsByCntByRoi[{r}]) = {len(ptsByCntByRoi[r])}')\n print_ptsByCntByRoi(ptsByCntByRoi)\n print('-'*120)\n\n return ptsByCntByRoi, cntdataByCntByRoi, c2sIndsByRoi, c2sInds","def loess(xvals, yvals, alpha, poly_degree=1):\r\n # Sort dataset by xvals.\r\n all_data = sorted(zip(xvals, yvals), key=lambda x: x[0])\r\n xvals, yvals = zip(*all_data)\r\n\r\n locsDF = pd.DataFrame(\r\n columns=[\r\n 'loc','x','weights','v','y','raw_dists',\r\n 'scale_factor','scaled_dists'\r\n ])\r\n evalDF = pd.DataFrame(\r\n columns=[\r\n 'loc','est','b','v','g'\r\n ])\r\n\r\n n = len(xvals)\r\n m = n + 1\r\n q = int(np.floor(n * alpha) if alpha <= 1.0 else n)\r\n avg_interval = ((max(xvals)-min(xvals))/len(xvals))\r\n v_lb = max(0,min(xvals)-(.5*avg_interval))\r\n v_ub = (max(xvals)+(.5*avg_interval))\r\n v = enumerate(np.linspace(start=v_lb, stop=v_ub, num=m), start=1)\r\n #print('liste v=', list(v))\r\n # Generate design matrix based on poly_degree.\r\n xcols = [np.ones_like(xvals)]\r\n for j in range(1, (poly_degree + 1)):\r\n xcols.append([i ** j for i in xvals])\r\n X = np.vstack(xcols).T\r\n\r\n\r\n for i in v:\r\n\r\n print('i=', i) #pour voir à quelle vitesse cela défile.\r\n iterpos = i[0]\r\n iterval = i[1]\r\n\r\n # Determine q-nearest xvals to iterval.\r\n iterdists = sorted([(j, np.abs(j-iterval)) \\\r\n for j in xvals], key=lambda x: x[1])\r\n\r\n _, raw_dists = zip(*iterdists)\r\n\r\n # Scale local observations by qth-nearest raw_dist.\r\n scale_fact = raw_dists[q-1]\r\n scaled_dists = [(j[0],(j[1]/scale_fact)) for j in iterdists]\r\n weights = [(j[0],((1-np.abs(j[1]**3))**3 \\\r\n if j[1]<=1 else 0)) for j in scaled_dists]\r\n\r\n # Remove xvals from each tuple:\r\n _, weights = zip(*sorted(weights, key=lambda x: x[0]))\r\n _, raw_dists = zip(*sorted(iterdists, key=lambda x: x[0]))\r\n _, scaled_dists = zip(*sorted(scaled_dists,key=lambda x: x[0]))\r\n\r\n iterDF1 = pd.DataFrame({\r\n 'loc' :iterpos,\r\n 'x' :xvals,\r\n 'v' :iterval,\r\n 'weights' :weights,\r\n 'y' :yvals,\r\n 'raw_dists' :raw_dists,\r\n 'scale_fact' :scale_fact,\r\n 'scaled_dists':scaled_dists\r\n })\r\n\r\n locsDF = pd.concat([locsDF, iterDF1])\r\n W = np.diag(weights)\r\n y = yvals\r\n b = np.linalg.inv(X.T @ W @ X) @ (X.T @ W @ y)\r\n local_est = loc_eval(iterval, b)\r\n iterDF2 = pd.DataFrame({\r\n 'loc':[iterpos],\r\n 'b' :[b],\r\n 'v' :[iterval],\r\n 'g' :[local_est]\r\n })\r\n\r\n evalDF = pd.concat([evalDF, iterDF2])\r\n\r\n # Reset indicies for returned DataFrames.\r\n locsDF.reset_index(inplace=True)\r\n locsDF.drop('index', axis=1, inplace=True)\r\n locsDF['est'] = 0; evalDF['est'] = 0\r\n locsDF = locsDF[['loc','est','v','x','y','raw_dists',\r\n 'scale_fact','scaled_dists','weights']]\r\n\r\n # Reset index for evalDF.\r\n evalDF.reset_index(inplace=True)\r\n evalDF.drop('index', axis=1, inplace=True)\r\n evalDF = evalDF[['loc','est', 'v', 'b', 'g']]\r\n\r\n return(locsDF, evalDF)","def trackCells(self): \n # variable initialization\n self.t_appearance = []\n self.id_seq = []\n self._n_cell = 0\n self.division = []\n self.dict_track = {}\n\n t_ini = self.configs[self.TIME_INI_KEY]\n\n # Initialize points with first frame\n self.dict_track[0] = {}\n for id_num in self.pos[0][4]:\n self._addTrack(0, id_num)\n\n # From frame=1 on...\n for t, data_t in enumerate(self.pos[1:]):\n self.dict_track[t+1] = {}\n # check all the cells in this frame\n for cell, id_num in enumerate(data_t[4]):\n parent = data_t[5][cell]\n if parent == -1:\n # new track\n self._addTrack(t+1, id_num)\n elif parent in self.dict_track[t]:\n # check if parent is in the previous list\n index = self.dict_track[t][parent]\n if index in self.dict_track[t+1].values():\n # then we have cell division, and we monitor the child separarely\n self._addDivision(t+1, id_num, index)\n else:\n # cell continues in the same track\n self.id_seq[index].append(id_num)\n self.dict_track[t+1][id_num] = index\n else:\n # weird things happened!\n print(\"Warning! Time %s, Cell ID %s lost track\"%(str(t+t_ini), str(id_num)))\n\n\n # all track indexes are included, no filter (yet)\n self.index_filter = list(range(len(self.id_seq)))\n\n return self.id_seq, self.t_appearance","def contours(subject, colour='gray'):\n for row in data.get_contours(subject)['contours']:\n for col in row:\n xs = []\n ys = []\n for pair in col['arr']:\n xs.append(pair['x'])\n ys.append(pair['y'])\n ys = config['surveys']['atlas']['fits_height'] - numpy.array(ys)\n matplotlib.pyplot.plot(xs, ys, c=colour)","def _calc_coords(self, X, Y, Z):\r\n def _write_coords(coord):\r\n XX.append(X[coord])\r\n YY.append(Y[coord])\r\n ZZ.append(Z[coord])\r\n\r\n def _build_layer():\r\n for j in range(self.size[1]):\r\n for i in range(self.size[0]):\r\n # write NW corner\r\n if i == 0:\r\n nwCoord = 2 * i + 4 * self.size[0] * j + const\r\n _write_coords(nwCoord)\r\n # write NE corner\r\n neCoord = 2 * i + 4 * self.size[0] * j + const + 1\r\n _write_coords(neCoord)\r\n if j == self.size[1] - 1:\r\n for i in range(self.size[0]):\r\n # write SW corner\r\n if i == 0:\r\n swCoord = 2 * i + 4 * self.size[0] * j + 2 * self.size[0] + const\r\n _write_coords(swCoord)\r\n # write SE corner\r\n seCoord = 2 * i + 4 * self.size[0] * j + 2 * self.size[0] + const + 1\r\n _write_coords(seCoord)\r\n\r\n # At this point, we have all points needed for unstructured grid in X,Y,Z\r\n # However, they must be re-arranged so we can define Hexahedrons\r\n # TODO: REFINE CELLS\r\n # PSUEDO:\r\n # find cell to be refined\r\n # add new cells (as easy as pie)\r\n\r\n XX, YY, ZZ = ([] for i in range(3))\r\n const = 0\r\n for k in range(self.size[2]):\r\n _build_layer()\r\n if k == self.size[2] - 1:\r\n const += self.size[0] * self.size[1] * 4\r\n _build_layer()\r\n break\r\n else:\r\n const += self.size[0] * self.size[1] * 8\r\n return XX, YY, ZZ","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 trapezoid_decomposition_linear(polygons):\n # Enumerate all the edges and iteratively build up the set of trapezoids\n # Add a vertical line for each point in the polygon\n all_polygons = np.concatenate(polygons, axis=0)\n vertical_lines = SortedDict({x[0]: [x[1], 1000000, 0] for x in all_polygons})\n\n # Loop over Polygons to determine end-points\n for polygon in polygons:\n start_vertex = polygon[0]\n for vertex in polygon[1:]:\n # find the lines in front of the smaller \n x_start = start_vertex[0]\n x_curr = vertex[0]\n start_idx = vertical_lines.bisect_right(min(x_start, x_curr))\n end_idx = vertical_lines.bisect_left(max(x_start, x_curr))\n x_vals = vertical_lines.keys()\n for i in range(start_idx, end_idx):\n x = x_vals[i]\n if x < min(x_start, x_curr) or x > max(x_start, x_curr):\n continue\n y, top, bottom = vertical_lines[x]\n y_val = linear_interpolation(start_vertex, vertex, x)\n if y_val > y and y_val < top:\n vertical_lines[x][1] = y_val\n elif y_val < y and y_val > bottom:\n vertical_lines[x][2] = y_val\n start_vertex = vertex\n return vertical_lines","def RegularPolygonPoints(n,c):\n coord = []\n for i in range(n):\n x = m.cos(2*m.pi*i/n)+c[0]\n y = m.sin(2*m.pi*i/n)+c[1]\n coord.append([x,y])\n return(coord)","def plot2Ddata(\n xyz,\n data,\n vec=False,\n nx=100,\n ny=100,\n ax=None,\n mask=None,\n level=False,\n figname=None,\n ncontour=10,\n dataloc=False,\n contourOpts={},\n levelOpts={},\n streamplotOpts={},\n scale=\"linear\",\n clim=None,\n method=\"linear\",\n shade=False,\n shade_ncontour=100,\n shade_azimuth=-45.0,\n shade_angle_altitude=45.0,\n shadeOpts={},\n):\n\n # Error checking and set vmin, vmax\n vlimits = [None, None]\n\n if clim is not None:\n vlimits = [np.min(clim), np.max(clim)]\n\n for i, key in enumerate([\"vmin\", \"vmax\"]):\n if key in contourOpts.keys():\n if vlimits[i] is None:\n vlimits[i] = contourOpts.pop(key)\n else:\n if not np.isclose(contourOpts[key], vlimits[i]):\n raise Exception(\n \"The values provided in the colorbar limit, clim {} \"\n \"does not match the value of {} provided in the \"\n \"contourOpts: {}. Only one value should be provided or \"\n \"the two values must be equal.\".format(\n vlimits[i], key, contourOpts[key]\n )\n )\n contourOpts.pop(key)\n vmin, vmax = vlimits[0], vlimits[1]\n\n # create a figure if it doesn't exist\n if ax is None:\n fig = plt.figure()\n ax = plt.subplot(111)\n\n # interpolate data to grid locations\n xmin, xmax = xyz[:, 0].min(), xyz[:, 0].max()\n ymin, ymax = xyz[:, 1].min(), xyz[:, 1].max()\n x = np.linspace(xmin, xmax, nx)\n y = np.linspace(ymin, ymax, ny)\n X, Y = np.meshgrid(x, y)\n xy = np.c_[X.flatten(), Y.flatten()]\n\n if vec is False:\n if method == \"nearest\":\n F = NearestNDInterpolator(xyz[:, :2], data)\n else:\n F = LinearNDInterpolator(xyz[:, :2], data)\n DATA = F(xy)\n DATA = DATA.reshape(X.shape)\n\n # Levels definitions\n dataselection = np.logical_and(~np.isnan(DATA), np.abs(DATA) != np.inf)\n if scale == \"log\":\n DATA = np.abs(DATA)\n\n # set vmin, vmax if they are not already set\n vmin = DATA[dataselection].min() if vmin is None else vmin\n vmax = DATA[dataselection].max() if vmax is None else vmax\n\n if scale == \"log\":\n levels = np.logspace(np.log10(vmin), np.log10(vmax), ncontour + 1)\n norm = colors.LogNorm(vmin=vmin, vmax=vmax)\n else:\n levels = np.linspace(vmin, vmax, ncontour + 1)\n norm = colors.Normalize(vmin=vmin, vmax=vmax)\n\n if mask is not None:\n Fmask = NearestNDInterpolator(xyz[:, :2], mask)\n MASK = Fmask(xy)\n MASK = MASK.reshape(X.shape)\n DATA = np.ma.masked_array(DATA, mask=MASK)\n\n contourOpts = {\"levels\": levels, \"norm\": norm, \"zorder\": 1, **contourOpts}\n cont = ax.contourf(X, Y, DATA, **contourOpts)\n\n if level:\n levelOpts = {\"levels\": levels, \"zorder\": 3, **levelOpts}\n CS = ax.contour(X, Y, DATA, **levelOpts)\n\n else:\n # Assume size of data is (N,2)\n datax = data[:, 0]\n datay = data[:, 1]\n if method == \"nearest\":\n Fx = NearestNDInterpolator(xyz[:, :2], datax)\n Fy = NearestNDInterpolator(xyz[:, :2], datay)\n else:\n Fx = LinearNDInterpolator(xyz[:, :2], datax)\n Fy = LinearNDInterpolator(xyz[:, :2], datay)\n DATAx = Fx(xy)\n DATAy = Fy(xy)\n DATA = np.sqrt(DATAx ** 2 + DATAy ** 2).reshape(X.shape)\n DATAx = DATAx.reshape(X.shape)\n DATAy = DATAy.reshape(X.shape)\n if scale == \"log\":\n DATA = np.abs(DATA)\n\n # Levels definitions\n dataselection = np.logical_and(~np.isnan(DATA), np.abs(DATA) != np.inf)\n\n # set vmin, vmax\n vmin = DATA[dataselection].min() if vmin is None else vmin\n vmax = DATA[dataselection].max() if vmax is None else vmax\n\n if scale == \"log\":\n levels = np.logspace(np.log10(vmin), np.log10(vmax), ncontour + 1)\n norm = colors.LogNorm(vmin=vmin, vmax=vmax)\n else:\n levels = np.linspace(vmin, vmax, ncontour + 1)\n norm = colors.Normalize(vmin=vmin, vmax=vmax)\n\n if mask is not None:\n Fmask = NearestNDInterpolator(xyz[:, :2], mask)\n MASK = Fmask(xy)\n MASK = MASK.reshape(X.shape)\n DATA = np.ma.masked_array(DATA, mask=MASK)\n\n contourOpts = {\"levels\": levels, \"norm\": norm, \"zorder\": 1, **contourOpts}\n cont = ax.contourf(X, Y, DATA, **contourOpts)\n\n streamplotOpts = {\"zorder\": 4, \"color\": \"w\", **streamplotOpts}\n ax.streamplot(X, Y, DATAx, DATAy, **streamplotOpts)\n\n if level:\n levelOpts = {\"levels\": levels, \"zorder\": 3, **levelOpts}\n CS = ax.contour(X, Y, DATA, levels=levels, zorder=3, **levelOpts)\n\n if shade:\n\n def hillshade(array, azimuth, angle_altitude):\n \"\"\"\n coded copied from https://www.neonscience.org/create-hillshade-py\n \"\"\"\n azimuth = 360.0 - azimuth\n x, y = np.gradient(array)\n slope = np.pi / 2.0 - np.arctan(np.sqrt(x * x + y * y))\n aspect = np.arctan2(-x, y)\n azimuthrad = azimuth * np.pi / 180.0\n altituderad = angle_altitude * np.pi / 180.0\n shaded = np.sin(altituderad) * np.sin(slope) + np.cos(altituderad) * np.cos(\n slope\n ) * np.cos((azimuthrad - np.pi / 2.0) - aspect)\n return 255 * (shaded + 1) / 2\n\n shadeOpts = {\n \"cmap\": \"Greys\",\n \"alpha\": 0.35,\n \"antialiased\": True,\n \"zorder\": 2,\n **shadeOpts,\n }\n\n ax.contourf(\n X,\n Y,\n hillshade(DATA, shade_azimuth, shade_angle_altitude),\n shade_ncontour,\n **shadeOpts\n )\n\n if dataloc:\n ax.plot(xyz[:, 0], xyz[:, 1], \"k.\", ms=2)\n ax.set_aspect(\"equal\", adjustable=\"box\")\n if figname:\n plt.axis(\"off\")\n fig.savefig(figname, dpi=200)\n if level:\n return cont, ax, CS\n else:\n return cont, ax","def getContourListByDic(groupDic):\n\tcontourList = []\n\n\tfor glyph in groupDic.keys():\n\t\tfor idx in groupDic[glyph]:\n\t\t\tcontourList.append(glyph.contours[idx])\n\n\treturn contourList","def save_contour(fname, cs, fmt = 'matlab', simplify = 1e-3, **kwargs):\n\n\tdef write_path_matlab(fout, x_vec, y_vec, z):\n\t\t# Now dump this data back out\n\t\t# Header is level followed by number of rows\n\t\tfout.write('%15.15e\\t%15d\\n' % (z, len(x_vec)))\n\t\tfor x, y in zip(x_vec, y_vec):\n\t\t\tfout.write(\"%15.15e\\t%15.15e\\n\" % (x,y))\n\n\tdef write_path_prepared(fout, x_vec, y_vec, z):\n\t\tfout.write(\"%15.15e\\t%15.15e\\t%15.15e\\n\" % (x0,y0,z))\n\t\tfout.write(\"\\t\\t\\t\\n\")\n\n\tif fmt == 'matlab':\n\t\twrite_path = write_path_matlab\n\telif fmt == 'prepared':\n\t\twrite_path = write_path_prepared\n\telse:\n\t\traise NotImplementedError\n\n\twith open(fname, 'w') as fout:\n\t\tfor col, z in zip(cs.collections, cs.levels):\n\t\t\tfor path in col.get_paths():\n\t\t\t\tpath.simplify_threshold = simplify\n\t\t\t\tx_vec = []\n\t\t\t\ty_vec = []\n\t\t\t\tfor i, ((x,y), code) in enumerate(path.iter_segments(simplify = True)):\n\t\t\t\t\tif code == Path.MOVETO:\n\t\t\t\t\t\tif len(x_vec) !=0:\n\t\t\t\t\t\t\twrite_path(fout, x_vec, y_vec, z)\n\t\t\t\t\t\t\tx_vec = []\n\t\t\t\t\t\t\ty_vec = []\n\t\t\t\t\t\tx_vec.append(x)\n\t\t\t\t\t\ty_vec.append(y)\n\t\t\t\t\t\n\t\t\t\t\telif code == Path.LINETO:\n\t\t\t\t\t\tx_vec.append(x)\n\t\t\t\t\t\ty_vec.append(y)\n\n\t\t\t\t\telif code == Path.CLOSEPOLY:\n\t\t\t\t\t\tx_vec.append(x_vec[0])\n\t\t\t\t\t\ty_vec.append(y_vec[0])\n\t\t\t\t\telse:\n\t\t\t\t\t\tprint(\"received code\", code)\n\n\t\t\t\twrite_path(fout, x_vec, y_vec, z)","def colorToBeads(clidx, filament_list, color, part_list_x, part_list_y, part_list_phi):\n cl_beads_x = []\n cl_beads_y = []\n cl_beads_p = []\n for i in filament_list:\n for j in range(N):\n ind = int(i*N+j)\n clidx[ind] = color\n cl_beads_x.append(part_list_x[ind])\n cl_beads_y.append(part_list_y[ind])\n cl_beads_p.append(part_list_phi[ind])\n \n xmin = min(cl_beads_x)\n ymin = min(cl_beads_y)\n xmax = max(cl_beads_x)\n ymax = max(cl_beads_y)\n \n flag = False\n x_span = xmax-xmin\n y_span = ymax-ymin\n if x_span > Lx/2:\n flag = True\n elif y_span > Ly/2:\n flag = True\n \n return cl_beads_x, cl_beads_y, cl_beads_p, xmin, xmax, ymin, ymax, flag","def get_interpolated_contours(contours_grouped_by_pos, len_interval, level_interval=1):\n\n contours_grouped_by_adjusted_pos = {}\n for i, (pos, contour) in enumerate(sorted(contours_grouped_by_pos.iteritems())):\n if i == 0:\n contours_grouped_by_adjusted_pos[int(np.ceil(pos))] = contour\n elif i == len(contours_grouped_by_pos)-1:\n contours_grouped_by_adjusted_pos[int(np.floor(pos))] = contour\n else:\n contours_grouped_by_adjusted_pos[int(np.round(pos))] = contour\n\n zs = sorted(contours_grouped_by_adjusted_pos.keys())\n n = len(zs)\n\n interpolated_contours = {}\n\n for i in range(n):\n z0 = zs[i]\n interpolated_contours[z0] = np.array(contours_grouped_by_adjusted_pos[z0])\n if i + 1 < n:\n z1 = zs[i+1]\n interp_cnts = interpolate_contours(contours_grouped_by_adjusted_pos[z0], contours_grouped_by_adjusted_pos[z1], nlevels=z1-z0+1, len_interval_0=len_interval)\n for zi, z in enumerate(range(z0+1, z1)):\n interpolated_contours[z] = interp_cnts[zi+1]\n\n return interpolated_contours","def build_coeff_dict(l):\n coeff_dict = {}\n for triplet in l:\n coeff_dict[triplet[0]] = triplet[2]\n return coeff_dict","def add_other_contours(self, xlabel, ylabel):\n import matplotlib.pyplot as plt\n plt.rcParams['text.usetex'] = True\n for contour_dict in self.contour_dicts:\n if (xlabel in contour_dict['vars']) and \\\n (ylabel in contour_dict['vars']):\n if isinstance(contour_dict['contour'], dict):\n for i, ckey in enumerate(contour_dict['contour'].keys()):\n self.make_other_contour(\n contour_vals=contour_dict['contour'][ckey],\n xlabel=xlabel,\n ylabel=ylabel,\n contour_dict=contour_dict,\n do_label=i\n )\n else:\n self.make_other_contour(\n contour_vals=contour_dict['contour'],\n xlabel=xlabel,\n ylabel=ylabel,\n contour_dict=contour_dict,\n do_label=1\n )","def m1_make_lower_shape_points_list(tx, ty, m1_info, SEN_info):\n \"\"\"\n 1 Get information from m1_info & SEN_info\n \"\"\"\n x_m1 = m1_info[0]\n y_m1 = m1_info[1]\n z_m = m1_info[2]\n\n m1_points = m1_info[3]\n\n m1_p0 = m1_points[0]\n m1_p1 = m1_points[1]\n m1_p2 = m1_points[2]\n m1_p3 = m1_points[3]\n\n w_sen = SEN_info[0]\n n_w_sen = SEN_info[1]\n h_sen = SEN_info[2]\n t_sen = SEN_info[3]\n u_n = SEN_info[4]\n l_n = SEN_info[5]\n set = SEN_info[6]\n u_offset = SEN_info[7]\n l_offset = SEN_info[8]\n\n \"\"\"\n 2 Make lists.\n lower_shape_upper_left_row list\n lower_shape_upper_right_row list\n\n lower_shape_lower_left_row list\n lower_shape_lower_right_row list\n \"\"\"\n # upper side\n lower_shape_upper_left_row = []\n lower_shape_upper_right_row = []\n\n for i in range(u_n):\n # left row\n ix = tx + t_sen\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p4, p3, p2, p1, p8, p7, p6, p5]\n lower_shape_upper_left_row.extend((left_points))\n\n for i in range(u_n - 1, -1, -1):\n # right row\n ix = tx + (x_m1 - t_sen)\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p8, p7, p6, p5, p4, p3, p2, p1]\n lower_shape_upper_right_row.extend(right_points)\n\n # lower side\n lower_shape_lower_left_row = []\n lower_shape_lower_right_row = []\n\n for i in range(l_n - 1, -1, -1):\n # left row\n ix = tx + t_sen\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p4, p3, p2, p1, p8, p7, p6, p5]\n lower_shape_lower_left_row.extend((left_points))\n\n for i in range(l_n):\n # right row\n ix = tx + (x_m1 - t_sen)\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p8, p7, p6, p5, p4, p3, p2, p1]\n lower_shape_lower_right_row.extend(right_points)\n\n lower_shape_upper = [lower_shape_upper_left_row, lower_shape_upper_right_row]\n lower_shape_lower = [lower_shape_lower_left_row, lower_shape_lower_right_row]\n\n return lower_shape_upper, lower_shape_lower","def get_interpolated_contours(contours_grouped_by_pos, len_interval):\n\n contours_grouped_by_adjusted_pos = {}\n for i, (pos, contour) in enumerate(sorted(contours_grouped_by_pos.iteritems())):\n if i == 0:\n contours_grouped_by_adjusted_pos[int(np.ceil(pos))] = contour\n elif i == len(contours_grouped_by_pos)-1:\n contours_grouped_by_adjusted_pos[int(np.floor(pos))] = contour\n else:\n contours_grouped_by_adjusted_pos[int(np.round(pos))] = contour\n\n zs = sorted(contours_grouped_by_adjusted_pos.keys())\n n = len(zs)\n\n interpolated_contours = {}\n\n for i in range(n):\n z0 = zs[i]\n interpolated_contours[z0] = np.array(contours_grouped_by_adjusted_pos[z0])\n if i + 1 < n:\n z1 = zs[i+1]\n interp_cnts = interpolate_contours(contours_grouped_by_adjusted_pos[z0], contours_grouped_by_adjusted_pos[z1], nlevels=z1-z0+1, len_interval_0=len_interval)\n for zi, z in enumerate(range(z0+1, z1)):\n interpolated_contours[z] = interp_cnts[zi+1]\n\n return interpolated_contours","def periodic_polygon_indices2xy(poly, xy, BLdbl, PVxydict):\n periodicpoly = False\n tups = pairwise(poly)\n xypoly = []\n pervec = np.array([0., 0.])\n # Add first point to coordinate list\n xypoly.append((xy[tups[0][0], :] + pervec).tolist())\n for tup in tups:\n # Check if the matching row of BL is all positive --> if so, then not periodic bond\n # NOTE: If tup is positive, and bond is periodic, then will not register a match!\n match = (BLdbl[:, 0] == tup[0]) & (BLdbl[:, 1] == tup[1])\n if match.any() and (BLdbl[match, :] > -0.5).all():\n xypoly.append((xy[tup[1], :] + pervec).tolist())\n else:\n # # Check if the matching row of BL flippedlr is all positive --> if so, then not periodic bond\n # match2 = (BL[:, 0] == tup[1]) & (BL[:, 1] == tup[0])\n # if match2.any() and (BL[match2, :] > -0.5).all():\n # xypoly.append((xy[tup[0], :] + pervec).tolist())\n # xypoly.append((xy[tup[1], :] + pervec).tolist())\n # else:\n\n # Declare that this polygon exists on at least two sides\n periodicpoly = True\n # Add periodic vector (PVx, PVy) to forming polygon\n try:\n pervec += PVxydict[tup]\n except KeyError:\n pervec += -PVxydict[(tup[1], tup[0])]\n xypoly.append((xy[tup[1], :] + pervec).tolist())\n\n return xypoly, periodicpoly","def points2contour(points):\n return points.reshape(-1, 1, 2)","def get_positions_by_slits(slits):\r\n xy = []\r\n for i, slit in enumerate(slits):\r\n index = canvas.slits.ids.index(slit)\r\n xy.append([canvas.slits.x[index], canvas.slits.y[index]])\r\n return np.array(xy)","def _dense_point_array(self, geoms, distance, index):\n # interpolate lines to represent them as points for Voronoi\n points = []\n ids = []\n\n if pygeos.get_type_id(geoms[0]) not in [1, 2, 5]:\n lines = pygeos.boundary(geoms)\n else:\n lines = geoms\n lengths = pygeos.length(lines)\n for ix, line, length in zip(index, lines, lengths):\n if length > distance: # some polygons might have collapsed\n pts = pygeos.line_interpolate_point(\n line,\n np.linspace(0.1, length - 0.1, num=int((length - 0.1) // distance)),\n ) # .1 offset to keep a gap between two segments\n points.append(pygeos.get_coordinates(pts))\n ids += [ix] * len(pts)\n\n points = np.vstack(points)\n\n return points, ids\n\n # here we might also want to append original coordinates of each line\n # to get a higher precision on the corners","def trapezoid_decomposition_pl(polygons, bounds):\n polygons = Polygons(polygons)\n # print(bounds)\n point_locator = PointLocator(bounds)\n for edge in polygons.random_edge_sampler():\n point_locator.add_line(edge)\n return point_locator","def get_positions(specs):\r\n xy = []\r\n for i, spec in enumerate(specs):\r\n slit = spec.split(\"n3311\", 1)[1].replace(\".fits\", \"\")\r\n # slit = spec.split(\".\")[0].split(\"_\", 1)[1][5:]\r\n index = canvas.slits.ids.index(slit)\r\n xy.append([canvas.slits.x[index], canvas.slits.y[index]])\r\n return np.array(xy)","def make_3d_plots_invue(data, groups_and_colors, intp_pts, polyh_pts, offset):\n data3d = data['coord'][1][:,:3]\n centroid = np.average(data3d,axis=0)\n for i in range(polyh_pts):\n idx = np.sqrt(np.sum(np.square(data3d-centroid),axis=1)).argmax()\n if i==0:\n polypts = [data3d[idx]]\n centroid = polypts\n elif i==1:\n polypts = np.append(polypts,[data3d[idx]],axis=0)\n centroid = np.average(polypts[:i+1],axis=0)\n elif i==2:\n polypts = np.append(polypts,[data3d[idx]],axis=0)\n polypts = np.append(polypts,[polypts[0]],axis=0)\n centroid = np.average(polypts[:i+1],axis=0)\n lastpts = polypts[:-1]\n elif i==3:\n polypts = np.append(polypts,[data3d[idx]],axis=0)\n polypts = np.append(polypts,polypts[i-2:i],axis=0)\n lastpts = np.append(lastpts,[data3d[idx]],axis=0)\n centroid = np.average(lastpts[:-3],axis=0)\n else:\n polypts = np.append(polypts,[data3d[idx]],axis=0)\n polypts = np.append(polypts,polypts[i-2:i-1],axis=0)\n polypts = np.append(polypts,[data3d[idx]],axis=0)\n lastpts = np.append(lastpts,[data3d[idx]],axis=0)\n centroid = np.average(lastpts[:-3],axis=0)\n \n smp_lbl = {}\n smp_lbl_grp = {}\n for i in range(len(groups_and_colors)):\n labelname=groups_and_colors[i][0]\n groups=groups_and_colors[i][1]\n colors=groups_and_colors[i][2]\n data_colors=groups_and_colors[i][3]\n \n # Binning data per metadata info\n smp_lbl[labelname] = {'coords': [], 'headrs': []}\n smp_lbl_grp[labelname] = {}\n for gr in groups:\n smp_lbl_grp[labelname][gr] = {'coords':[], 'headrs':[]}\n \n for elm in groups[gr]:\n try:\n idx = data['coord'][0].index(elm)\n except (ValueError):\n continue\n #raise ValueError, 'ValueError: list.index(x): %s not in list' % elm\n \n # Creating interpolation points\n if intp_pts==0:\n smp_lbl_grp[labelname][gr]['coords'].append(data['coord'][1][idx][:3])\n smp_lbl_grp[labelname][gr]['headrs'].append(elm)\n else:\n if len(smp_lbl_grp[labelname][gr]['coords'])==0:\n smp_lbl_grp[labelname][gr]['coords'].append(data['coord'][1][idx][:3])\n smp_lbl_grp[labelname][gr]['headrs'].append(elm)\n pass\n else:\n new_pts = linear_gradient(prev_pts,data['coord'][1][idx][:3],intp_pts+2)\n for j,tmp in enumerate(new_pts[1:]):\n smp_lbl_grp[labelname][gr]['headrs'].append(\"%s.%d\" % (elm,j))\n smp_lbl_grp[labelname][gr]['coords'].append(array(tmp))\n \n prev_pts=data['coord'][1][idx][:3]\n \n # Saving the coords\n smp_lbl[labelname]['coords'].append(np.append(data['coord'][1][idx][:3],\\\n [data_colors[colors[gr]].toInt()]))\n smp_lbl[labelname]['headrs'].append(elm)\n \n return smp_lbl, smp_lbl_grp, polypts*offset","def plotContour(verts, data, comp=2):\n z = data[:,:,comp].flatten()\n x = verts[:,0]\n y = verts[:,1]\n\n xi = np.linspace(x.min(), x.max(), x.size)\n yi = np.linspace(y.min(), y.max(), y.size)\n zi = griddata(x,y,z, xi,yi, interp='nn') #'nn' #NOTE: for irregularly spaced data\n\n plt.figure()\n #plt.gca().set_aspect('equal')\n compDict = {0:'X',1:'Y',2:'Z'}\n C = compDict[comp]\n\n CS = plt.contour(xi,yi,zi,15,linewidths=0.5,colors='k')\n CS = plt.contourf(xi,yi,zi,15,cmap=plt.cm.jet)\n plt.title( C + ' Displacement')\n plt.xlabel('Distance [m]')\n plt.ylabel('Distance [m]')\n cb = plt.colorbar()\n cb.set_label('[m]')","def maplot_c(pdata, pdata1, title='', precip='no'):\n from mpl_toolkits.basemap import Basemap, shiftgrid\n import numpy as np\n import matplotlib.pyplot as plt\n from netcdfread import ncread\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\n plt.figure()\n\n pdata, lon1 = shiftgrid(180., pdata, lon, start=False)\n pdata1, lon = shiftgrid(180., pdata1, lon, start=False)\n meshlon, meshlat = np.meshgrid(lon, lat)\n\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\n m.drawcoastlines()\n m.drawmapboundary()\n x, y = m(meshlon, meshlat)\n plot = m.contour(x, y, pdata, [4, 5, 6], colors='k')\n plt.clabel(plot, inline=1, fontsize=10)\n plot1 = m.contour(x, y, pdata1, [4, 5, 6], colors='r', linestyles='--')\n plt.clabel(plot, inline=1, fontsize=10)\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\n m.drawparallels(parallels, labels=[True, True, True, True])\n m.drawmeridians(meridians, labels=[True, True, True, True])\n plt.title(title, y=1.08)\n plt.show()","def source_positions(self, dist_cutoff=None):\n \n crds = {}\n for fn in self.srclists:\n \n print(\"OM::source_positions -- checking: \",fn) \n ff = pyfits.open(fn)\n idf = fn[-20:-14]\n obsid = ff[0].header[\"OBS_ID\"]\n print(obsid, idf)\n try:\n ra, dec = ff[1].data[\"RA\"], ff[1].data[\"DEC\"]\n except:\n print(fn,\" does not contain RA, Dec coordinates.\")\n continue\n rate = ff[1].data[\"CORR_RATE\"]\n coords = C.SkyCoord(ra, dec, unit=(\"deg\", \"deg\"), frame='icrs')\n tc = []\n ci = []\n for i, c in enumerate(coords):\n #print(c)\n if len(tc) == 0: \n tc.append(c.to_string(\"hmsdms\",sep=':', precision=2, pad=True))\n ci.append(i)\n continue\n #print(c, tc, sc)\n dist = c.separation(coords[ci]).arcsec\n #print(\"dist: \",dist)\n gi = np.where(dist>2)[0]\n for j in gi:\n tc.append(c.to_string(\"hmsdms\",sep=':', precision=2, pad=True))\n #ci.append(j)\n if len(tc)>0:\n crds[idf] = tc\n #else:\n if len(crds) == 0:\n return None\n return {obsid:crds}","def build_xy_data(params, dimension, fold, sub_list):\n XZ = get_x_data(params, dimension, fold, subject_list=sub_list)\n Y = []\n if params[\"data_source\"] == \"ABIDE\":\n classified_file = open(\n \"/scratch/mmahaut/scripts/INT_fMRI_processing/url_preparation/subs_list_asd_classified.json\"\n ) # Hardwriten non-modifiable paths in script is bad practice. modify later !\n classified_dict = json.load(classified_file)\n # no normalisation step (which kind of seems legit for classification)\n for key in classified_dict:\n Y.append(1 if classified_dict[key] == \"asd\" else 0)\n elif params[\"data_source\"] == \"interTVA\":\n # Hardcoding this array is probably not the most reusable solution...\n # Error 1 found on 30/07/2020 : bad correspondance between subject file and hardcoded Y,\n # subjects in subject file were not in the same order\n Y = [\n 81.25,\n 81.25,\n 93.75,\n 93.75,\n 93.75,\n 62.5,\n 81.25,\n 100,\n 100,\n 87.5,\n 87.5,\n 68.75,\n 68.75,\n 87.5,\n 93.75,\n 100,\n 62.5,\n 87.5,\n 93.75,\n 87.5,\n 81.25,\n 81.25,\n 81.25,\n 93.75,\n 50,\n 62.5,\n 93.75,\n 81.25,\n 81.25,\n 87.5,\n 68.75,\n 81.25,\n 87.5,\n 87.5,\n 87.5,\n 75,\n 93.75,\n 93.75,\n 93.75,\n ]\n y = np.array(Y)\n YZ = (y - min(y)) / (max(y) - min(y))\n return XZ, YZ","def rectpolyctl(xmin,xmax,ymin,ymax):\n pc=[]\n pc.append((xmin,ymin))\n pc.append((xmin,ymax))\n pc.append((xmax,ymax))\n pc.append((xmax,ymin))\n pc.append((xmin,ymin))\n return pc","def pointListForCurve(x, y, type):\n\n\tif x < 10:\n\t\txString = \"0%d\" % x\n\telse:\n\t\txString = \"%d\" % x\n\n\tif x < 11:\n\t\txMString = \"0%d\" % (x - 1)\n\telse:\n\t\txMString = \"%d\" % (x - 1)\n\n\tif x < 9:\n\t\txPString = \"0%d\" % (x + 1)\n\telse:\n\t\txPString = \"%d\" % (x + 1)\n\n\tif x < 8:\n\t\txPPString = \"0%d\" % (x + 2)\n\telse:\n\t\txPPString = \"%d\" % (x + 2)\n\n\tif y < 11:\n\t\tyMString = \"0%d\" % (y - 1)\n\telse:\n\t\tyMString = \"%d\" % (y - 1)\n\n\tif y < 9:\n\t\tyPString = \"0%d\" % (y + 1)\n\telse:\n\t\tyPString = \"%d\" % (y + 1)\n\n\tif y < 8:\n\t\tyPPString = \"0%d\" % (y + 2)\n\telse:\n\t\tyPPString = \"%d\" % (y + 2)\n\n\tif y < 10:\n\t\tyString = \"0%d\" % y\n\telse:\n\t\tyString = \"%d\" % y\n\n\tinnerRadius = 54.0 / 64.0\n\touterRadius = 87.0 / 64.0\n\n\tslices = 10\n\n\t# Dots are numbered as xxyy[IO]z\n\t# The I means it is the inside trek, the O the outside\n\t# The z is which particular dot it is (0-9)\n\t# Note that all paths are marked as being inside the top-left square\n\t# Except for entrence and exit dots.\n\t# Curves are generated from star + 10 to end - 10\n\n\tif type == 8:\t\t\t# Bottom right\n\t\tcenterX = 25.0 / 64.0\n\t\tcenterY = 25.0 / 64.0\n\t\tstart = 0.0\n\t\tend = 90.0\n\n\t\tenterIn =\t[\"%s%sTL\" % (xPString, yString), 0.25, 0.25, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sBL\" % (xString, yPString), 0.25, 0.75, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sTL\" % (xString, yPString), 0.25, 0.25, [\"%s%sTR\" % (xMString, yPString)]]\n\t\texitOut =\t[\"%s%sTR\" % (xPString, yString), 0.75, 0.25, [\"%s%sBR\" % (xPString, yMString)]]\n\n\t\tendIn = \"%s%sTL\" % (xString, yPString)\n\t\tendOut = \"%s%sTR\" % (xPString, yString)\n\n\telif type == 9:\t\t\t# Bottom left\n\t\tcenterX = 103.0 / 64.0\n\t\tcenterY = 25.0 / 64.0\n\t\tstart = 90.0\n\t\tend = 180.0\n\n\t\tenterIn =\t[\"%s%sTR\" % (xPString, yPString), 0.75, 0.25, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sTR\" % (xString, yString), 0.75, 0.25, [\"%s%sBR\" % (xString, yMString)]]\n\t\texitOut =\t[\"%s%sBR\" % (xPString, yPString), 0.75, 0.75, [\"%s%sBL\" % (xPPString, yPString)]]\n\n\t\tendIn = \"%s%sTR\" % (xString, yString)\n\t\tendOut = \"%s%sBR\" % (xPString, yPString)\n\n\telif type == 10:\t\t# Top left\n\t\tcenterX = 103.0 / 64.0\n\t\tcenterY = 103.0 / 64.0\n\t\tstart = 180.0\n\t\tend = 270.0\n\n\t\tenterIn =\t[\"%s%sBR\" % (xString, yPString), 0.75, 0.75, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sTR\" % (xPString, yString), 0.75, 0.25, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sBR\" % (xPString, yString), 0.75, 0.75, [\"%s%sBL\" % (xPPString, yString)]]\n\t\texitOut =\t[\"%s%sBL\" % (xString, yPString), 0.25, 0.75, [\"%s%sTL\" % (xString, yPPString)]]\n\n\t\tendIn = \"%s%sBR\" % (xPString, yString)\n\t\tendOut = \"%s%sBL\" % (xString, yPString)\n\n\telse: # type == 11:\t\t# Top right\n\t\tcenterX = 25.0 / 64.0\n\t\tcenterY = 103.0 / 64.0\n\t\tstart = 270.0\n\t\tend = 360.0\n\n\t\tenterIn =\t[\"%s%sBL\" % (xString, yString), 0.25, 0.75, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sBR\" % (xPString, yPString), 0.75, 0.75, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sBL\" % (xPString, yPString), 0.25, 0.75, [\"%s%sTL\" % (xPString, yPPString)]]\n\t\texitOut =\t[\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\"%s%sTR\" % (xMString, yString)]]\n\n\t\tendIn = \"%s%sBL\" % (xPString, yPString)\n\t\tendOut = \"%s%sTL\" % (xString, yString)\n\n\tpointList = [enterIn, enterOut, exitIn, exitOut]\n\n\tstring = \"%s%s\" % (xString, yString)\n\tstep = ((end - 1) - (start + 1)) / float(slices)\n\n\tfor i in range(slices):\n\n\t\tangle = radians(start + step * i)\n\n\t\tif i < 9:\n\t\t\ttemp = [\"%sI%d\" % (string, i), centerX + cos(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[\"%sI%d\" % (string, i + 1)]]\n\t\telse:\n\t\t\ttemp = [\"%sI%d\" % (string, i), centerX + cos(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[endIn]]\n\n\t\tpointList.append(temp)\n\n\t\tangle = radians(start + step * (10 - i))\n\n\t\tif i < 9:\n\t\t\ttemp = [\"%sO%d\" % (string, i), centerX + cos(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[\"%sO%d\" % (string, i + 1)]]\n\t\telse:\n\t\t\ttemp = [\"%sO%d\" % (string, i), centerX + cos(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[endOut]]\n\n\t\tpointList.append(temp)\n\n\treturn pointList","def toArray(parsedList):\n interpretCommand = {\n 'C' : lambda x, prevL : x[-2:], # bezier curve. Ignore the curve.\n 'L' : lambda x, prevL : x[0:2],\n 'M' : lambda x, prevL : x[0:2],\n 'Z' : lambda x, prevL : prevL[0],\n }\n\n points =[]\n for i,(c, arg) in enumerate(parsedList):\n #debug('toArray ', i, c , arg)\n newp = interpretCommand[c](arg, points)\n points.append( newp)\n a=numpy.array( points )\n\n # Some times we have points *very* close to each other\n # these do not bring any meaning full info, so we remove them\n #\n x,y, w,h = computeBox(a)\n sizeC = 0.5*(w+h)\n #deltas = numpy.zeros((len(a),2) )\n deltas = a[1:] - a[:-1] \n #deltas[-1] = a[0] - a[-1]\n deltaD = numpy.sqrt(numpy.sum( deltas**2, 1 ))\n sortedDind = numpy.argsort(deltaD)\n # expand longuest segments\n nexp = int(len(deltaD)*0.9)\n newpoints=[ None ]*len(a)\n medDelta = deltaD[sortedDind[len(deltaD)/2] ]\n for i,ind in enumerate(sortedDind):\n if deltaD[ind]/sizeC<0.005: continue\n if i>nexp:\n np = int(deltaD[ind]/medDelta)\n pL = [a[ind]]\n #print i,'=',ind,'adding ', np,' _ ', deltaD[ind], a[ind], a[ind+1]\n for j in range(np-1):\n f = float(j+1)/np\n #print '------> ', (1-f)*a[ind]+f*a[ind+1]\n pL.append( (1-f)*a[ind]+f*a[ind+1] )\n newpoints[ind] = pL\n else:\n newpoints[ind]=[a[ind]]\n if(D(a[0],a[-1])/sizeC > 0.005 ) :\n newpoints[-1]=[a[-1]]\n\n points = numpy.concatenate([p for p in newpoints if p!=None] )\n ## print ' medDelta ', medDelta, deltaD[sortedDind[-1]]\n ## print len(a) ,' ------> ', len(points)\n\n rel_norms = numpy.sqrt(numpy.sum( deltas**2, 1 )) / sizeC\n keep = numpy.concatenate([numpy.where( rel_norms >0.005 )[0],numpy.array([len(a)-1])])\n\n #return a[keep] , [ parsedList[i] for i in keep]\n #print len(a),' ',len(points)\n return points , []","def props_for_contours(contours, ary):\n c_info = []\n for c in contours:\n x, y, w, h = cv2.boundingRect(c)\n c_im = np.zeros(ary.shape)\n cv2.drawContours(c_im, [c], 0, 255, -1)\n c_info.append({\n 'x1': x,\n 'y1': y,\n 'x2': x + w - 1,\n 'y2': y + h - 1,\n 'sum': np.sum(ary * (c_im > 0)) / 255\n })\n return c_info","def _createMap(self,dimensions, density):\n compMap = []\n xmin, xmax = dimensions[0], dimensions[1]\n imin, imax = dimensions[2], dimensions[3]\n\n #Ideally the hsteps and the vsteps are the same\n hsteps = int((xmax - xmin)/density)\n vsteps = int((imax - imin)/density)\n\n for im in range(vsteps):\n compMap.append([])\n for x in range(hsteps):\n myComplexPair = complex(xmin + (density * x), imin + (density * im))\n compMap[im].append(myComplexPair)\n compMap.reverse()\n return compMap","def build_raw_xy_data(params, fold, sub_list):\n # Some repeated code from load_data : not super smart\n X = get_raw_x_data(params, fold, subject_list=sub_list)\n XZ = np.array(X)\n Y = []\n if params[\"data_source\"] == \"ABIDE\":\n classified_file = open(\n \"/scratch/mmahaut/scripts/INT_fMRI_processing/url_preparation/subs_list_asd_classified.json\"\n ) # Hardwriten non-modifiable paths in script is bad practice. modify later !\n classified_dict = json.load(classified_file)\n # no normalisation step (which kind of seems legit for classification)\n for key in classified_dict:\n Y.append(1 if classified_dict[key] == \"asd\" else 0)\n elif params[\"data_source\"] == \"interTVA\":\n # Hardcoding this array is probably not the most reusable solution...\n # Error 1 found on 30/07/2020 : bad correspondance between subject file and hardcoded Y,\n # subjects in subject file were not in the same order\n Y = [\n 81.25,\n 81.25,\n 93.75,\n 93.75,\n 93.75,\n 62.5,\n 81.25,\n 100,\n 100,\n 87.5,\n 87.5,\n 68.75,\n 68.75,\n 87.5,\n 93.75,\n 100,\n 62.5,\n 87.5,\n 93.75,\n 87.5,\n 81.25,\n 81.25,\n 81.25,\n 93.75,\n 50,\n 62.5,\n 93.75,\n 81.25,\n 81.25,\n 87.5,\n 68.75,\n 81.25,\n 87.5,\n 87.5,\n 87.5,\n 75,\n 93.75,\n 93.75,\n 93.75,\n ]\n x = np.array(Y)\n YZ = (x - min(x)) / (max(x) - min(x))\n return XZ, YZ","def getDictCWells(self,itype):\n #Method begins here\n #nx=self.__grid['nx'] #From the geometry in grid\n ny=self.__grid['ny']\n nz=self.__grid['nz']\n minx=self.__grid['ox']\n miny=self.__grid['oy']\n minz=self.__grid['oz']\n rx=self.__grid['dx']\n ry=self.__grid['dy']\n rz=self.__grid['dz']\n \n # well package\n # Remember to use zero-based layer, row, column indices!\n lcoordw=np.zeros((self.__ncwells,3),dtype=np.int32)\n for i in range (self.__ncwells):\n lcoordw[i,0]=floor((self.__dfclst.iloc[i,3]-minx)/rx)\n #In MODFLOW y ans z coordinates are inverted\n lcoordw[i,1]=floor((miny+ry*ny-self.__dfclst.iloc[i,4])/ry)\n lcoordw[i,2]=floor((minz+rz*nz-self.__dfclst.iloc[i,5])/rz)\n \n nper=self.__df.getForcPer()\n ssm_data = {}\n print('Number of conc periods='+str(nper)) \n for i in range(nper):\n lst=[]\n for j in range(self.__ncwells):\n conc_rate=self.__dfcwells.iloc[i+1,j+1]\n lst.append( [ lcoordw[j,2], lcoordw[j,1], lcoordw[j,0], conc_rate, itype['WEL'] ] )\n ssm_data[i]=lst\n print(ssm_data)\n \n print('*--- Succesfull reading of concentration wells ---*')\n \n return ssm_data","def get_p_polys(self, calc, rholabel, elabels, comm):\n #Check if everything is computed already\n if all([((rholabel, elabel) in self.p_polys) for elabel in elabels]):\n return [self.p_polys[(rholabel, elabel)] for elabel in elabels]\n\n #Otherwise compute poly\n polys = [calc.prs_as_compact_polys(rholabel, elabels, opstr, comm)\n for opstr in self.generate_circuit_list(permute=False)]\n\n ret = []\n for i, elabel in enumerate(elabels):\n if (rholabel, elabel) not in self.p_polys:\n tapes = [p[i] for p in polys]\n vtape = _np.concatenate([t[0] for t in tapes])\n ctape = _np.concatenate([t[1] for t in tapes])\n self.p_polys[(rholabel, elabel)] = (vtape, _np.asarray(ctape, complex))\n # create ctape *complex* so they're all the same type?\n ret.append(self.p_polys[(rholabel, elabel)])\n\n #OLD - using raw polys via get_raw_polys\n #ret = []\n #polys = self.get_raw_polys(calc, rholabel, elabels, comm)\n #for i,elabel in enumerate(elabels):\n # if (rholabel,elabel) not in self.p_polys:\n # tapes = [ poly.compact() for poly in polys[i] ]\n # vtape = _np.concatenate( [ t[0] for t in tapes ] )\n # ctape = _np.concatenate( [ t[1] for t in tapes ] )\n # self.p_polys[ (rholabel,elabel) ] = (vtape, ctape)\n # ret.append( self.p_polys[ (rholabel,elabel) ] )\n\n return ret","def voxelize_single_contour(self, contour,res,llc,voxSlice, direction):\n\t\t# prepare contour for the point check\n\t\tverts = [ (P[(direction + 1) % 3],P[(direction + 2) % 3]) for P in contour ]\n\t\tverts.append((contour[0][(direction + 1) % 3],contour[0][(direction + 2) % 3]))\n\t\tcodes = [Path.MOVETO]\n\t\t[codes.append(Path.LINETO) for i in range(len(verts)-2)]\n\t\tcodes.append(Path.CLOSEPOLY)\n\t\tpath = Path(verts, codes)\n\t\t\n\t\t# prepare the list of points to check\n\t\tindices=numpy.transpose(numpy.array(numpy.nonzero(voxSlice==False)))\n\t\tpositions=[(p[0],p[1]) for p in list(indices*res+numpy.array([llc[(direction + 1) % 3],llc[(direction + 2) % 3]]))]\n\t\t\n\t\t# do the check and reshape the result\n\t\tresult=numpy.array(path.contains_points(positions),dtype='bool').reshape(voxSlice.shape)\n\t\t\n\t\treturn result","def BL2PVxydict(BL, xy, PV):\n # The ijth element of PVx is the xcomponent of the vector taking NL[i,j] to its image as seen by particle i.\n PVxydict = {}\n # check both directions along each periodic vector\n PVtmp = np.vstack((PV, -PV))\n\n # For each bond that is a periodic bond, determine its periodic boundary vector (a row of the array PV)\n pBs = np.unique(np.where(BL < 0)[0])\n print 'le: BL[pBs] = ', BL[pBs]\n print 'le: pBs = ', pBs\n for ind in pBs:\n # Find the PV (periodic vector) that brings the second particle (j) closest to the first (i).\n # This will be PVxydict[(i,j)], since particle i sees j at xy[j]+PVxydict[(i,j)]\n a1 = xy[np.abs(BL[ind, 0])]\n a2 = xy[np.abs(BL[ind, 1])]\n try:\n distxy = a2 + PVtmp - a1\n except ValueError:\n print 'a1 = ', a1\n print 'a2 = ', a2\n print 'PVtmp = ', PVtmp\n raise RuntimeError('dimensions do not match')\n dist = distxy[:, 0] ** 2 + distxy[:, 1] ** 2\n # print 'a1, a2 = ', a1, a2\n # print 'distxy = ', distxy\n # print 'PV = ', PV\n # print 'dist = ', dist\n if np.argmin(dist) > len(PV) - 1:\n PVxydict[(np.abs(BL[ind, 0]), np.abs(BL[ind, 1]))] = -PV[np.argmin(dist) % len(PV)]\n else:\n PVxydict[(np.abs(BL[ind, 0]), np.abs(BL[ind, 1]))] = PV[np.argmin(dist) % len(PV)]\n\n print 'le: PVxydict = ', PVxydict\n return PVxydict","def define_ccd_pos(ccd_pos_dict, raft_name, slot_names, xpos, ypos):\n ccd_pos_dict[raft_name] = {slot:[xpos[i],ypos[i]] for i,slot in enumerate(slot_names)}","def plot_collective(xdict, ydict, xprop, yprop, documents):\n x_ion = {\"Mg\": [], \"Ca\": [], \"Zn\": [], \"Li\": [], \"Na\": []}\n y_ion = {\"Mg\": [], \"Ca\": [], \"Zn\": [], \"Li\": [], \"Na\": []}\n for item in documents:\n if item[\"path_id\"][-3:] == \"001\":\n x_ion[item[\"cation_type\"]].append(xdict[item[\"path_id\"]])\n y_ion[item[\"cation_type\"]].append(ydict[item[\"path_id\"]])\n fig = plt.figure(figsize=(6,6), dpi=plotting_dpi)\n ax = fig.add_subplot(111)\n for ion in [\"Mg\", \"Ca\", \"Zn\", \"Li\", \"Na\"]:\n ax.scatter(x_ion[ion], y_ion[ion], s=70, zorder=2, color=color_dict[ion], linewidths=2.5, edgecolors='black',\n label=ion)\n xlabel = \"\\\\textbf{\" + label_dict[xprop] + \"}\"\n ylabel = \"\\\\textbf{\" + label_dict[yprop] + \"}\"\n \n # # Plot lines for fitting, if useful\n # x2 = np.arange(-700, 3300, 1)\n # ax.plot(x2, x2)\n \n # # For setting axis boundaries\n # ax.set_xlim([-700, 3500])\n # ax.set_ylim([0,100])\n \n # Plot display settings\n ax.set_xlabel(xlabel, fontsize=24)\n ax.set_ylabel(ylabel, fontsize=24)\n ax.tick_params(axis='x', labelsize=22)\n ax.tick_params(axis='y', labelsize=22)\n border_width = 2\n [i.set_linewidth(border_width) for i in ax.spines.itervalues()]\n plt.tight_layout()\n plt.legend(loc='best', prop={'size':10})\n # plt.legend(loc='best')\n plt.rc('text', usetex=True)\n plt.rc('font', family='sans-serif')\n plt.show()","def cfdReadPointsFile(self):\r\n\r\n with open(self.pointsFile,\"r\") as fpid:\r\n \r\n print('Reading points file ...')\r\n points_x=[]\r\n points_y=[]\r\n points_z=[]\r\n \r\n for linecount, tline in enumerate(fpid):\r\n \r\n if not io.cfdSkipEmptyLines(tline):\r\n continue\r\n \r\n if not io.cfdSkipMacroComments(tline):\r\n continue\r\n \r\n if \"FoamFile\" in tline:\r\n dictionary=io.cfdReadCfdDictionary(fpid)\r\n continue\r\n \r\n if len(tline.split()) ==1:\r\n if \"(\" in tline:\r\n continue\r\n if \")\" in tline:\r\n continue\r\n else:\r\n self.numberOfNodes = int(tline.split()[0])\r\n continue\r\n \r\n tline=tline.replace(\"(\",\"\")\r\n tline=tline.replace(\")\",\"\")\r\n tline=tline.split()\r\n \r\n points_x.append(float(tline[0]))\r\n points_y.append(float(tline[1]))\r\n points_z.append(float(tline[2]))\r\n \r\n ## (array) with the mesh point coordinates \r\n self.nodeCentroids = np.array((points_x, points_y, points_z), dtype=float).transpose()"],"string":"[\n \"def individual_plot(z, cf_lvls, cl_lvls, cline_label_format=cline_label_format_default, log_scale=False ,\\n extend=\\\"neither\\\"):\\n map_plot.drawcoastlines(linewidth=.4)\\n\\n if log_scale:\\n norm = colors.LogNorm(vmin=cf_lvls[0], vmax=cf_lvls[-1])\\n else:\\n norm = None\\n\\n if extend == 'neither':\\n contour_fills = map_plot.contourf(x_grid, y_grid, z, cf_lvls, cmap=color_map, norm=norm)\\n else:\\n contour_fills = map_plot.contourf(x_grid, y_grid, z, cf_lvls, cmap=color_map, norm=norm, extend=extend)\\n contour_lines = plt.contour(x_grid, y_grid, z, cl_lvls, colors='0.1', linewidths=1)\\n\\n # Label levels with specially formatted floats\\n plt.rcParams['font.weight'] = 'bold'\\n plt.clabel(contour_lines, fmt=cline_label_format, inline=1, fontsize=9, colors='k')\\n plt.rcParams['font.weight'] = 'normal'\\n\\n return contour_fills\",\n \"def get_cntr_points(self, contour, img_size):\\n res_arr = []\\n # for each row\\n for row in range(img_size):\\n tmp_arr = []\\n # for each column\\n for col in range(img_size):\\n # if point in contour\\n if cv2.pointPolygonTest(contour,(row,col),True)> 0:\\n # add point to current line\\n tmp_arr.append([row,col])\\n if len(tmp_arr):\\n # add current line to result array\\n res_arr.append(tmp_arr)\\n return res_arr\",\n \"def polygons2PPC(xy, polygons, BL=None, PVxydict=None, check=False):\\n # Prepare a polygon patch collection plot\\n if PVxydict is not None and PVxydict != {}:\\n BLdbl = np.vstack((BL, np.fliplr(BL)))\\n\\n PPC = []\\n for poly in polygons:\\n if PVxydict is not None and PVxydict != {}:\\n xypoly, periodicpoly = periodic_polygon_indices2xy(poly, xy, BLdbl, PVxydict)\\n\\n # Add to list of polygon path patches\\n pp = Path(np.array(xypoly), closed=True)\\n ppp = patches.PathPatch(pp, lw=2)\\n PPC.append(ppp)\\n\\n # If polygon was periodic, get other permutations of the polygon\\n if periodicpoly:\\n # print 'Dealing with periodic polygon here...'\\n # make sure that polygon doesn't have repeated index\\n # print 'poly = ', poly\\n if poly[-1] == poly[0]:\\n poly = poly[0:len(poly) - 1]\\n\\n oldpolys = [xypoly[0:len(xypoly) - 1]]\\n for ii in range(len(poly)):\\n # permute polygon, check if it is a cyclic permutation for any previously-plotted polygons\\n poly = np.roll(poly, 1)\\n # print 'rolled poly = ', poly\\n newxyp, trash = periodic_polygon_indices2xy(poly, xy, BLdbl, PVxydict)\\n # print 'oldxyp[:, 0] = ', np.array(oldpolys[0])[:, 0]\\n # print 'newxyp[:, 0] = ', np.array(newxyp)[:, 0]\\n xcyclic = np.array([is_cyclic_permutation(np.array(oldp)[:, 0].tolist(),\\n np.array(newxyp)[:, 0].tolist()) for oldp in oldpolys])\\n ycyclic = np.array([is_cyclic_permutation(np.array(oldp)[:, 1].tolist(),\\n np.array(newxyp)[:, 1].tolist()) for oldp in oldpolys])\\n if not xcyclic.any() or not ycyclic.any():\\n # print '\\\\n\\\\n\\\\n\\\\n\\\\n adding new periodic polygon! \\\\n\\\\n\\\\n\\\\n'\\n pp = Path(np.array(np.vstack((np.array(newxyp), np.array(newxyp)[0, :]))), closed=True)\\n ppp = patches.PathPatch(pp, lw=2)\\n PPC.append(ppp)\\n oldpolys.append(newxyp)\\n else:\\n pp = Path(xy[poly], closed=True)\\n ppp = patches.PathPatch(pp, lw=2)\\n PPC.append(ppp)\\n\\n if check:\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n p = PatchCollection(PPC, cmap=cm.jet, alpha=0.5)\\n colors = 100 * np.random.rand(len(PPC))\\n p.set_array(np.array(colors))\\n ax.add_collection(p)\\n xlim = max(abs(xy[:, 0]))\\n ylim = max(abs(xy[:, 1]))\\n ax.set_xlim(-xlim, xlim)\\n ax.set_ylim(-ylim, ylim)\\n plt.show()\\n plt.clf()\\n\\n return PPC\",\n \"def polylinedictarraycopy(d):#d——原始图层多段线字典 \\r\\n dictlist=[]\\r\\n ratiolist=[] #放缩率列表\\r\\n rationumaccumulationlist=[] #放缩率数量累加列表\\r\\n \\r\\n eachrationum=globalconfig.X_ARRAY_NUM//globalconfig.RATIO_NUM\\r\\n leftrationum=globalconfig.X_ARRAY_NUM%globalconfig.RATIO_NUM\\r\\n \\r\\n eachrationumlist=[eachrationum]*globalconfig.RATIO_NUM #各个放缩率对应数量的列表\\r\\n \\r\\n for i in range((globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2,(globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2+leftrationum):\\r\\n eachrationumlist[i]=eachrationumlist[i]+1 #将整除后的余值加入到靠中间放缩率的方案中。\\r\\n \\r\\n rationumaccumulationlist.append(0) \\r\\n \\r\\n for i in range(1,globalconfig.RATIO_NUM): #计算放缩率数量累加列表\\r\\n rationumaccumulationlist.append(rationumaccumulationlist[i-1]+eachrationumlist[i-1])\\r\\n \\r\\n for i in range(0,globalconfig.RATIO_NUM): #计算放缩率列表\\r\\n ratiolist.append((globalconfig.CENTER_RATIO-((globalconfig.RATIO_NUM+1)//2-1)*globalconfig.RATIO_DIFF)+i*globalconfig.RATIO_DIFF) \\r\\n \\r\\n for i in range(0,globalconfig.RATIO_NUM): #每种放缩率\\r\\n for j in range(0,eachrationumlist[i]): #每种放缩率对应数量\\r\\n newdict={}\\r\\n for e in d: #将字典中值即每一图层对应的多段线列表进行复制并移动到指定位置\\r\\n newdict[e]=polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist)) \\r\\n #newdict.append([e,polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist))])\\r\\n dictlist.append(newdict) \\r\\n return (dictlist,ratiolist,eachrationumlist)\",\n \"def holepolylinedictarraycopy(holepolylinedict):\\r\\n holepolylinearraydict={}\\r\\n for e in holepolylinedict: #对通孔图层多段线字典进行遍历，将里面的多段线向上阵列\\r\\n holepolylinedataset=[]\\r\\n for row in range(0,globalconfig.Y_ARRAY_NUM): \\r\\n holepolylinedataset.extend(datasetjustcopy(holepolylinedict[e], 1, 0, globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO*row))\\r\\n holepolylinearraydict[e]=holepolylinedataset\\r\\n return holepolylinearraydict\",\n \"def layer_coords(label_lst): #full path\\n \\n #if a fundus then do this block\\n gyrus_check = all(i.__contains__(\\\"fundus\\\") for i in label_lst)\\n if gyrus_check:\\n for layer in label_lst:\\n #read data\\n df_layer = pd.read_csv(layer)\\n df_layer = df_layer.iloc[1:,0]\\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\\\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\\n\\n #compute slope\\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\\n\\n #split lam label into three\\n split = math.floor(len(df_layer['X'].values)/3)\\n df_layer_right = df_layer[0:split]\\n df_layer_left = df_layer[-split:]\\n df_layer_middle = df_layer[split:-split]\\n\\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000'\\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\\n plt.axis('off')\\n plt.savefig('layer_contour.png')\\n # plt.show()\\n plt.close()\\n\\n #read, convert to grayscale, find edges\\n layer_img = cv2.imread('layer_contour.png')\\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\\n\\n #find contours\\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n # cv2.imshow('contour', layer_edges)\\n # cv2.waitKey(0)\\n # cv2.destroyAllWindows()\\n \\n #order contours\\n contours = [np.squeeze(i) for i in contours]\\n df_contours = pd.DataFrame(contours)\\n contours_ord = df_contours.loc[6].values, df_contours.loc[4].values, \\\\\\n df_contours.loc[3].values, df_contours.loc[2].values, \\\\\\n df_contours.loc[1].values, df_contours.loc[0].values, \\\\\\n df_contours.loc[5].values\\n contours_ord = np.squeeze(contours_ord)\\n \\n\\n #plot all layers and add coordinate data to dict \\n lay_coords_dict = {}\\n for laycon, i in zip(contours_ord, list(range(len(contours)))): \\n #split coordinates into top and bottom edge\\n if i == 0: #0 == pial\\n c_idx = int(np.floor(len(laycon)/2))\\n coords_top = np.array(list(reversed(laycon[:c_idx])))\\n lay_coords_dict[i] = coords_top[10:]\\n # print(coords_top)\\n\\n else:\\n c_idx = int(np.floor(len(laycon)/2))\\n coords_top = np.array(list(reversed(laycon[c_idx:])))\\n lay_coords_dict[i] = coords_top[5:-7]\\n\\n \\n #plot coords\\n # for key, val in lay_coords_dict.items():\\n # plt.plot([i[0] for i in val], [i[1] for i in val], lw=1.75)\\n # plt.gca().invert_yaxis()\\n # plt.show()\\n # plt.close()\\n # sys.exit()\\n\\n #delete edge detect image and return dict\\n rm_img_cmd = \\\"rm layer_contour.png\\\"\\n os.system(rm_img_cmd)\\n return(lay_coords_dict)\\n \\n\\n #for crown data do this block\\n else:\\n for layer in label_lst:\\n #read data\\n df_layer = pd.read_csv(layer)\\n df_layer = df_layer.iloc[1:,0]\\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\\\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\\n\\n #compute slope\\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\\n\\n #split lam label into three\\n split = math.floor(len(df_layer['X'].values)/3)\\n df_layer_right = df_layer[0:split]\\n df_layer_left = df_layer[-split:]\\n df_layer_middle = df_layer[split:-split]\\n\\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000', lw=5\\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\\n plt.axis('off')\\n plt.savefig('layer_contour.png')\\n # plt.show()\\n plt.close()\\n\\n #read, convert to grayscale, find edges\\n layer_img = cv2.imread('layer_contour.png')\\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\\n\\n #find contours\\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n # cv2.imshow('contour', layer_edges)\\n # cv2.waitKey(0)\\n # cv2.destroyAllWindows()\\n \\n\\n #plot all layers and add coordinate data to dict\\n lay_coords_dict = {}\\n for laycon, i in zip(contours, list(range( len(contours) ) )[::-1] ):#7\\n #split coordinates into top and bottom edge\\n # print(laycon)\\n coords_lst = [list(ii) for i in laycon for ii in i] # 0 == GWB\\n # print(coords_lst)\\n\\n c_split = math.floor(len(coords_lst)/4)\\n coords_top = coords_lst[:c_split][::-1] + coords_lst[-c_split:][::-1]\\n lay_coords_dict[i] = coords_top\\n df_coords = pd.DataFrame(coords_top, columns=['X', 'Y'])\\n # print(df_coords)\\n\\n #plot using all coordinates\\n plt.plot(df_coords['X'].values, df_coords['Y'].values, lw=3)\\n plt.gca().invert_yaxis()\\n # plt.show()\\n plt.close()\\n\\n\\n # use k means to get rid of extra coords on short lines\\n for i in list(range(1,6)):\\n # kMEANS clustering, separate short line bottom half\\n df_short = pd.DataFrame(lay_coords_dict[i], columns=['X', 'Y']) #1=L1,\\n # plt.scatter( df_short['X'].values, df_short['Y'].values, s=5 )\\n # plt.gca().invert_yaxis()\\n # plt.show()\\n\\n #scale data\\n scaler = StandardScaler()\\n scaler.fit( df_short[['X', 'Y']].values )\\n short_scale = scaler.transform( df_short[['X', 'Y']].values )\\n\\n init = np.array([[0.514, -0.629], [-1.101, 1.344]])\\n\\n #predict\\n # kmeans_classifier = KMeans(n_clusters=2, init=init) #fixed centroids\\n kmeans_classifier = KMeans(n_clusters=2) \\n\\n y_kmeans = kmeans_classifier.fit_predict(short_scale)\\n centroids = kmeans_classifier.cluster_centers_\\n inertia = kmeans_classifier.inertia_\\n\\n\\n #update df\\n df_short.insert(2, column='kClass', value=y_kmeans)\\n\\n #df scaled\\n df_short_scale = pd.DataFrame(short_scale, columns=['X', 'Y'])\\n df_short_scale.insert(2, column='kClass', value=y_kmeans)\\n \\n\\n \\\"\\\"\\\"\\n #plot data points for k means, clusters\\n colmap = {0: '#029386', 1: '#D2691E', 2: '#A52A2A'}\\n for i in range(2):\\n new_df = df_short_scale[df_short_scale['kClass']==i]\\n plt.scatter(new_df['X'].values, new_df['Y'].values, s=20, \\\\\\n label='cluster' + str(i+1), color=colmap[i])\\n\\n #plot centroids\\n for i in range (2):\\n plt.scatter(centroids[i][0], centroids[i][1], marker='x', s=500, \\\\\\n label='centroid' + str(i+1), color=colmap[i])\\n \\n plt.legend()\\n plt.gca().invert_yaxis()\\n plt.show()\\n \\\"\\\"\\\"\\n\\n\\n #new df for clean data, take centroid with more data points\\n num_class0 = len(df_short[df_short['kClass']==0])\\n num_class1 = len(df_short[df_short['kClass']==1])\\n\\n if num_class0 > num_class1:\\n \\n df_short_clean = df_short[df_short['kClass']==0]\\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\\\\n df_short_clean['Y'].values)]\\n else:\\n df_short_clean = df_short[df_short['kClass']==1]\\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\\\\n df_short_clean['Y'].values)]\\n\\n #plot clean short line\\n # plt.scatter(df_short_clean['X'].values, df_short_clean['Y'].values, s=20)\\n # plt.gca().invert_yaxis()\\n # plt.show()\\n\\n #delete edge detect image and return dict\\n rm_img_cmd = \\\"rm layer_contour.png\\\"\\n os.system(rm_img_cmd)\\n return(lay_coords_dict)\",\n \"def GetXYListAndPolyListWithLimitedPointsBetweenNodes_CVLS(\\n cVLS,\\n allValsByFrame,\\n orderOfSCsByValueByFrame,\\n splitLength=1,\\n fixedNumInteriorPoints=None,\\n interpolate=True,\\n):\\n cVLS2 = GetCVLSWithLimitedPointsBetweenNodes(\\n cVLS,\\n allValsByFrame,\\n splitLength,\\n fixedNumInteriorPoints,\\n interpolate=interpolate,\\n )\\n return GetXYListAndPolyListFromCVLS(cVLS2, allValsByFrame, orderOfSCsByValueByFrame)\",\n \"def _coords_from_ccdata(self, index):\\n elements = [self.pt.element[Z] for Z in self.ccdata.atomnos]\\n if self.ghost is not None:\\n elements = [self.ghost if e is None else e for e in elements]\\n elif None in elements:\\n raise ValueError(\\n f\\\"It seems that there is at least one ghost atom in these elements. Please use the ghost flag to specify a label for the ghost atoms.\\\"\\n )\\n atomcoords = self.ccdata.atomcoords[index]\\n atomnos = self.ccdata.atomnos\\n nos = range(self.ccdata.natom)\\n\\n lines = []\\n for element, no, atomno, coord in zip(elements, nos, atomnos,\\n atomcoords):\\n x, y, z = map(round_molden, coord)\\n lines.append(f\\\"{element:2s} {no + 1:5d} {atomno:2d} {x:12.6f} {y:12.6f} {z:12.6f}\\\")\\n\\n return lines\",\n \"def get_MultiPolyLists_xy(mpoly):\\n # Get the x or y coordinates\\n x = []\\n y = []\\n if isinstance(mpoly,Polygon):\\n mpoly = [mpoly]\\n for poly in mpoly: # the polygon objects return arrays, it's important they be lists or Bokeh fails\\n exterior_coords_x = poly.exterior.coords.xy[0].tolist();\\n interior_coords_x = []\\n exterior_coords_y = poly.exterior.coords.xy[1].tolist();\\n interior_coords_y = []\\n\\n for interior in poly.interiors:\\n if isinstance(interior.coords.xy[0],list):\\n interior_coords_x += [interior.coords.xy[0]];\\n interior_coords_y += [interior.coords.xy[1]];\\n else:\\n interior_coords_x += [interior.coords.xy[0].tolist()];\\n interior_coords_y += [interior.coords.xy[1].tolist()];\\n x.append([exterior_coords_x, *interior_coords_x])\\n y.append([exterior_coords_y, *interior_coords_y])\\n return (x,y)\",\n \"def get_indices_from_cell_list(polydata, num_cells):\\n cells_list = []\\n\\n polys = polydata.GetPolys() # get connectivity of polygon cells (polygon : {triangles, tetra, hexa, ..etc.})\\n polys.InitTraversal() # initialize traversal so getnextcell starts at 0\\n\\n temp_list = []\\n\\n for i in range(num_cells):\\n ptIds = vtk.vtkIdList()\\n polys.GetNextCell(ptIds)\\n num_pts = ptIds.GetNumberOfIds()\\n cellids = []\\n\\n for j in range(num_pts):\\n current_ptid = ptIds.GetId(j)\\n if current_ptid in temp_list:\\n continue\\n else:\\n cellids.append(current_ptid)\\n\\n temp_list.append(current_ptid)\\n\\n cells_list.append(cellids)\\n\\n\\n return cells_list\",\n \"def calculate_contours_fit(L_x, L_y, e, leaflet, ts, Plots, side):\\n \\n n = np.load(input_dir + 'directors_'+leaflet+'_tail_'+ str(ts) + '.npy') \\n\\n pos = np.load(input_dir + 'coordinates_'+leaflet+'_tail_' + str(ts) + '.npy') \\n\\n resid = np.load(input_dir + 'residues_'+leaflet+'_tail_' + str(ts) + '.npy')\\n box = np.load(input_dir + 'box' + str(ts) + '.npy')\\n\\n \\n chl = np.load(input_dir + 'cholesterol_'+leaflet+'_tail_' + str(ts) + '.npy')\\n dlipc = np.load(input_dir + 'dlipc_'+leaflet+'_tail_' + str(ts) + '.npy') \\n dspc = np.load(input_dir + 'dspc_'+leaflet+'_tail_' + str(ts) + '.npy')\\n ssm = np.load(input_dir + 'ssm_'+leaflet+'_tail_' + str(ts) + '.npy')\\n \\n #n= np.ones(len(pos))\\n \\\"\\\"\\\" END: read the input data \\\"\\\"\\\"\\n\\n\\n field = order_vector_field(L_x, L_y, pos, n, e, box)\\n\\n c = pd.DataFrame(data=field).mean(axis=0).rolling(50, center=True, min_periods=1).mean() #50\\n c.dropna(inplace=True)\\n middle = 0.5*(np.max(c) + np.min(c)) \\n #middle = 0.025\\n contours = measure.find_contours(field, middle) # Marching Cubes algorith\\n #save contours\\n fac_x = box[0] / L_x #to get the right dimensions (range_x)\\n fac_y = box[1] / L_y # (range_y)\\n \\n contours_x = []\\n contours_y = []\\n contours_x_y = []\\n \\n contours_all = []\\n for m, contour in enumerate(contours):\\n contours_x.append((contour[:, 1] * fac_x))\\n contours_y.append((contour[:, 0] * fac_y))\\n \\n \\n contours_x_y = np.column_stack((contours_x[m], contours_y[m]))\\n contours_all.append(contours_x_y)\\n np.save(output_contours + 'contours_'+leaflet+'.' + str(ts) + '.npy', contours_all)\\n \\n\\n#===================================================\\n#To assign resids to the different phases\\n phase_belonging = np.zeros((len(pos)))\\n ordered =[]\\n disordered = []\\n for i in np.arange(len(pos)):\\n \\n def apply_pbc(pos, box):\\n if pos >= box:\\n pos -= box\\n if pos < 0:\\n pos += box\\n return pos\\n \\n idx_x = int(apply_pbc(pos[i,0], box[0]) / fac_x - 1.e-5) #the - 1.e-5 is because accuracy issue in the /\\n idx_y = int(apply_pbc(pos[i,1], box[1]) / fac_y - 1.e-5) #this - 1.e-5 is because accuracy issue in the /\\n #print(idx_x, idx_y)\\n order= field[idx_y, idx_x]\\n if (order > middle):\\n ordered.append(order)\\n order = 1 #ordered lipids\\n \\n else :\\n disordered.append(order)\\n order =0 #disordered lipids\\n phase_belonging[i] = order\\n \\n\\n resid_phases = np.column_stack((resid[:,0], phase_belonging))\\n np.save(output_dir + 'resid_phases'+leaflet+'.'+ str(j) + '.npy', resid_phases)\\n\\n if Plots == True:\\n plt.figure(figsize=(15,10)) \\n \\n contours_sorted = sorted(contours, key=len, reverse=True)\\n \\n for i in range(2):\\n plt.plot(contours_sorted[i][:,1]* fac_x+0.5*fac_x, contours_sorted[i][:,0]* fac_y+0.5*fac_y, linewidth=3, color='#0000FF' ) ##00CC00\\n \\n #for m, contour in enumerate(contours_sorted):\\n # print(contour[:,0])\\n # for contour in contours: \\n \\n # plt.plot((contour[:, 1] * fac_x+0.5*fac_x),\\n # (contour[:, 0] * fac_y+0.5*fac_y),\\n # linewidth=4, color='#00CC00')\\n \\n plt.imshow(field, interpolation='nearest', \\n cmap=plt.cm.gray_r,\\n extent=[0, box[0], 0, box[1]], origin='lower', alpha=0.7) \\n \\n plt.axis('off')\\n plot_scatter_order_field(pos, resid, dlipc, dspc, chl,ssm, n , box, ts, side) #phase_belonging.reshape(-1,1)\\n plt.savefig(output_dir + 'contours-'+ leaflet + str(ts) + '.png', dpi=300) \\n plt.close() \\n \\n return resid_phases #, ordered, disordered \",\n \"def plot_individual(xdict, ydict, xprop, yprop, documents, spline):\\n figure_array = {}\\n for item in documents:\\n xlabel = \\\"\\\\\\\\textbf{\\\" + label_dict[xprop] + \\\"}\\\"\\n ylabel = \\\"\\\\\\\\textbf{\\\" + label_dict[yprop] + \\\"}\\\"\\n x = xdict[item[\\\"path_id\\\"]]\\n y = ydict[item[\\\"path_id\\\"]]\\n # fig_title = item[\\\"path_id\\\"] + \\\"(\\\" + item[\\\"pretty_formula\\\"] + \\\")\\\" # Individual traces\\n # fig_title = yprop + item[\\\"cation_type\\\"] # Plot by cation\\n fig_title = yprop # All together\\n figure_array[item[\\\"path_id\\\"]] = plt.figure(fig_title, figsize=(6,6), dpi=plotting_dpi)\\n ax = figure_array[item[\\\"path_id\\\"]].add_subplot(111) \\n ax.scatter(x,y, s=70, zorder=2, color=color_dict[item[\\\"cation_type\\\"]], linewidths=2.5, edgecolors='black')\\n if spline:\\n tck = interpolate.splrep(x, y, s=0)\\n xnew = np.arange(0, 100, 0.1)\\n splfit = interpolate.splev(xnew, tck, der=0)\\n x = xnew\\n y = splfit\\n if item[\\\"path_id\\\"][-3:] == \\\"002\\\":\\n ax.plot(x,y, linewidth=2.5, zorder=1, color=color_dict[item[\\\"cation_type\\\"]], linestyle='dashed')\\n elif item[\\\"path_id\\\"][-3:] == \\\"003\\\":\\n ax.plot(x,y, linewidth=2.5, zorder=1, color=color_dict[item[\\\"cation_type\\\"]], linestyle='dotted')\\n else:\\n ax.plot(x,y, linewidth=2.5, zorder=1, color=color_dict[item[\\\"cation_type\\\"]])\\n ax.set_xlabel(xlabel, fontsize=24)\\n # ax.set_ylim([0,1200])\\n # ax.set_xlim([0,100])\\n ax.set_ylabel(ylabel, fontsize=24)\\n ax.tick_params(axis='x', labelsize=22)\\n ax.tick_params(axis='y', labelsize=22)\\n border_width = 2\\n [i.set_linewidth(border_width) for i in ax.spines.itervalues()]\\n plt.tight_layout()\\n plt.legend(loc='best', prop={'size': 14})\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='sans-serif')\\n plt.tight_layout()\\n plt.show()\",\n \"def plotVoronoiCell(self, cells):\\n for i in cells:\\n #i indexes volumes\\n i = self.nonBI[i] #now i indexes vor.point_region\\n\\n vI = self.vor.regions[self.vor.point_region[i]]\\n v = self.vor.vertices[vI, :]\\n r = v\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Voronoi Cell of Particle ' + str(i))\\n ax.set_xlabel('x [m]')\\n ax.set_ylabel('y [m]')\\n ax.set_zlabel('z [m]')\\n ax.scatter(r[:, 0], r[:, 1], r[:, 2], s=5, alpha=0.5, label='Cell Boundaries')\\n ax.scatter(self.data[i, 0], self.data[i, 1], self.data[i, 2], s=25, label='Cell Center')\\n ax.set_xlim3d(np.min(self.data[:, 0]), np.max(self.data[:, 0]))\\n ax.set_ylim3d(np.min(self.data[:, 1]), np.max(self.data[:, 1]))\\n ax.set_zlim3d(np.min(self.data[:, 2]), np.max(self.data[:, 2]))\\n # limits = np.vstack((np.array([np.max(self.data[:, 0]), np.max(self.data[:, 1]), np.max(self.data[:, 2])]), np.array([np.min(self.data[:, 0]), np.min(self.data[:, 1]), np.min(self.data[:, 2])])))\\n # ax.scatter(limits[:, 0], limits[:, 1], limits[:, 2], s=1)\\n ax.legend()\",\n \"def add_poly_mesh_arrays_data_to_gl(self, key, fv_indices, points, face_normals, cstype, c, face_colors, vertex_colors):\\n n_vertices_max = len(fv_indices[0])\\n\\n data_mesh_points_list = np.array([])\\n data_mesh_normals_list = np.array([])\\n data_mesh_colors_list = np.array([])\\n n_all_vertices = 0\\n\\n max_iter = n_vertices_max - 1\\n\\n for corner_idx in range(1, max_iter):\\n if n_vertices_max > 3:\\n existing_triangles = fv_indices[:, corner_idx + 1] != -1\\n\\n if True not in existing_triangles:\\n continue\\n\\n fv_indices_to_draw_all_vertices = fv_indices[existing_triangles]\\n fv_indices_to_draw = fv_indices_to_draw_all_vertices[:, [0, corner_idx, corner_idx + 1]]\\n face_normals_to_draw = face_normals[existing_triangles]\\n else:\\n fv_indices_to_draw = fv_indices\\n face_normals_to_draw = face_normals\\n\\n fv_indices_flattened = fv_indices_to_draw.flatten()\\n n_all_vertices += len(fv_indices_flattened)\\n\\n n_faces = len(fv_indices_to_draw)\\n\\n vertexData = self.createVertexData(fv_indices_flattened, points)\\n\\n normalData = self.createNormaldata(face_normals_to_draw)\\n\\n if cstype == 0:\\n colorData = self.createConstantColorData(c, n_faces)\\n elif cstype == 1:\\n colorData = self.createFaceColorData(face_colors)\\n elif cstype == 2:\\n colorData = self.createVertexColorData(vertex_colors, fv_indices_flattened)\\n\\n if self._showBack:\\n fv_indices_flattened_reversed = fv_indices_flattened[::-1]\\n n_all_vertices += len(fv_indices_flattened_reversed)\\n\\n reversed_mesh_points = self.createVertexData(fv_indices_flattened_reversed, points)\\n\\n reversed_normals = self.createNormaldata(-face_normals_to_draw[::-1])\\n\\n if cstype == 0:\\n reversed_colors = colorData\\n elif cstype == 1:\\n reversed_colors = self.createFaceColorData(face_colors[::-1])\\n elif cstype == 2:\\n reversed_colors = self.createVertexColorData(vertex_colors, fv_indices_flattened_reversed)\\n\\n data_mesh_points_list = np.concatenate([data_mesh_points_list, vertexData, reversed_mesh_points])\\n data_mesh_normals_list = np.concatenate([data_mesh_normals_list, normalData, reversed_normals])\\n data_mesh_colors_list = np.concatenate([data_mesh_colors_list, colorData, reversed_colors])\\n else:\\n data_mesh_points_list = np.concatenate([data_mesh_points_list, vertexData])\\n data_mesh_normals_list = np.concatenate([data_mesh_normals_list, normalData])\\n data_mesh_colors_list = np.concatenate([data_mesh_colors_list, colorData])\\n\\n vertex_data = np.array(data_mesh_points_list, dtype=GLHelpFun.numpydatatype(GLDataType.FLOAT))\\n normal_data = np.array(data_mesh_normals_list, dtype=GLHelpFun.numpydatatype(GLDataType.FLOAT))\\n color_data = np.array(data_mesh_colors_list, dtype=GLHelpFun.numpydatatype(GLDataType.FLOAT))\\n\\n self.setlistdata_f3xyzf3nf4rgba(key, vertex_data, normal_data, color_data)\\n self.setVertexCounter_byNum(key, n_all_vertices)\\n return\",\n \"def _get_voronoi_poly_points(vert_index_list, voronoi_vertices,\\n voronoi_centroid):\\n voronoi_poly_points = []\\n if -1 not in vert_index_list and len(vert_index_list) > 3:\\n voronoi_poly_points = voronoi_vertices[vert_index_list]\\n elif vert_index_list.size > 0:\\n # ASSUME RECTANGLE\\n vert_index_list = vert_index_list[vert_index_list >= 0]\\n voronoi_poly_points = voronoi_vertices[vert_index_list]\\n # CASE 1: 2 valid voronoi vertices\\n if vert_index_list.size == 2:\\n center_lon = voronoi_centroid[0]\\n center_lat = voronoi_centroid[1]\\n corner_lon1 = voronoi_poly_points[0][0]\\n corner_lat1 = voronoi_poly_points[0][1]\\n corner_lon2 = voronoi_poly_points[1][0]\\n corner_lat2 = voronoi_poly_points[1][1]\\n\\n # check if need to add points in lon or lat\\n if abs(corner_lon1-corner_lon2) > abs(corner_lat1-corner_lat2):\\n dLat = center_lat - corner_lat1\\n # append the corners in order\\n voronoi_poly_points = np.array([\\n [corner_lon1, corner_lat1],\\n [corner_lon2, corner_lat2],\\n [corner_lon2, center_lat + dLat],\\n [corner_lon1, center_lat + dLat]\\n ])\\n else:\\n dLon = center_lon - corner_lon1\\n # append the corners in order\\n voronoi_poly_points = np.array([\\n [corner_lon1, corner_lat1],\\n [corner_lon2, corner_lat2],\\n [center_lon + dLon, corner_lat2],\\n [center_lon + dLon, corner_lat1]\\n ])\\n # CASE 2: 1 valid voronoi vertex\\n elif vert_index_list.size == 1:\\n center_lon = voronoi_centroid[0]\\n center_lat = voronoi_centroid[1]\\n corner_lon = voronoi_poly_points[0][0]\\n corner_lat = voronoi_poly_points[0][1]\\n dLat = center_lat - corner_lat\\n dLon = center_lon - corner_lon\\n # append the corners in order\\n voronoi_poly_points = np.array([\\n [corner_lon, corner_lat],\\n [center_lon + dLon, corner_lat],\\n [center_lon + dLon, center_lat + dLat],\\n [corner_lon, center_lat + dLat]\\n ])\\n\\n return voronoi_poly_points\",\n \"def make_plot(\\n X: np.ndarray, Y: np.ndarray, Z: np.ndarray, \\n int_coords: List[np.ndarray], levels: np.ndarray, \\n color_range: List[str], inter_color: List[Union[str, float]], \\n SAVE: bool, SAVE_NAME: str):\\n color1 = Color(color_range[0])\\n color2 = Color(color_range[1])\\n \\n # List of Color objects, need to convert for matplotlib\\n color_list = list(color1.range_to(color2, len(levels)))\\n \\n contour_colors = []\\n for color in color_list:\\n contour_colors.append(color.hex)\\n\\n fig = plt.figure(figsize = [8, 6])\\n ax1 = fig.add_subplot(111)\\n\\n # Set title\\n fig.suptitle('Quartz Deformation Mechanism Map')\\n \\n CS = ax1.contour(X, Y, Z, levels, colors = contour_colors) \\n \\n # Add intersection lines to plot\\n for coord_arr in int_coords:\\n # Get x indices and y indices\\n x, y = coord_arr.T\\n \\n # Get actual points to plot\\n points_x = X[x, y]\\n points_y = Y[x, y]\\n\\n ax1.plot(points_x, points_y, \\n color = inter_color[0], alpha = inter_color[1])\\n\\n # Labels... hardcoded. May find a way to make this generic\\n sr_labels = [\\n r'$10^{-15}$', r'$10^{-14}$', r'$10^{-13}$', \\n r'$10^{-12}$', r'$10^{-11}$', r'$10^{-10}$', \\n r'$10^{-9}$', r'$10^{-8}$', r'$10^{-7}$', \\n r'$10^{-6}$']\\n\\n # Make legend equal to contour values from sr_labels\\n for i in range(len(sr_labels)):\\n CS.collections[i].set_label(sr_labels[i])\\n\\n # Reverse legend order, set location and title\\n handles, labels = ax1.get_legend_handles_labels()\\n ax1.legend(reversed(handles), reversed(labels), \\n loc = 'upper right', title = r'$\\\\.\\\\epsilon$')\\n\\n # Set log scale and ylim\\n ax1.set_yscale('log')\\n ax1.set_ylim([10 ** -6, 1])\\n \\n # Set labels... could be done better in Illustrator...\\n ax1.set_ylabel(\\n r'Shear Stress $log\\\\left( \\\\frac{\\\\sigma}{\\\\mu}\\\\right)$'\\n )\\n ax1.set_xlabel(\\n r'Homologous Temperature $\\\\left( \\\\frac{T}{T_m} \\\\right)$'\\n )\\n\\n # Plot tick marks\\n ax1.grid()\\n\\n if SAVE:\\n fig.savefig(SAVE_NAME)\\n else:\\n plt.show()\",\n \"def drawContour(xlist, ylist, zmatrix, level):\\n dislin.contur(xlist, len(xlist), ylist, len(ylist), zmatrix, level)\",\n \"def transform_xy_coords(xy_coords, sc_plot):\\r\\n sorted_keys = xy_coords.keys()\\r\\n all_cids = []\\r\\n all_xcoords = []\\r\\n all_ycoords = []\\r\\n sc_plot.set_transform(sc_plot.axes.transData)\\r\\n trans = sc_plot.get_transform()\\r\\n\\r\\n for s_label in sorted_keys:\\r\\n s_data = xy_coords[s_label]\\r\\n if s_data[0] == []:\\r\\n pass\\r\\n else:\\r\\n icoords = trans.transform(zip(s_data[0], s_data[1]))\\r\\n xcoords, ycoords = zip(*icoords)\\r\\n all_cids.extend(s_data[2])\\r\\n all_xcoords.extend(xcoords)\\r\\n all_ycoords.extend(ycoords)\\r\\n\\r\\n return all_cids, all_xcoords, all_ycoords\",\n \"def CII_vs_CO(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[1])\\n fig,ax1 = plt.subplots()\\n L_CII = getattr(GR,'L_[CII]158_sun')\\n L_CO = getattr(GR,'L_CO(1-0)_sun')\\n Zsfr = getattr(GR,'Zsfr')\\n lL_CO, lL_CII = np.log10(L_CO), np.log10(L_CII) \\n lL_CO, lL_CII = lL_CO[(L_CO > 0) & (L_CII > 0)], lL_CII[(L_CO > 0) & (L_CII > 0)]\\n sc = ax1.scatter(np.log10(L_CO)-10, np.log10(L_CII)-10, marker='o', c=np.log10(Zsfr), cmap='viridis', zorder=10,\\\\\\n vmin=np.log10(0.05), vmax=np.log10(3.1), \\\\\\n s=10, alpha=0.8)#, label='SIGAME 100Mpc_arepoPDF')\\n # print('Min Zsfr in Simba sample: ',np.min(Zsfr))\\n # print('indices with L_CO < 1e0:')\\n nbins = 100\\n k = kde.gaussian_kde(np.column_stack([lL_CO,lL_CII]).T)\\n x, y = np.mgrid[lL_CO.min():lL_CO.max():nbins*1j, \\\\\\n 4:lL_CII.max():nbins*1j]\\n z = k(np.vstack([x.flatten(), y.flatten()]))\\n CS = ax1.contour(x, y, z.reshape(x.shape),colors='forestgreen',levels=8,zorder=10)\\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF')\\n\\n GR = glo.global_results(sim_run=p.sim_runs[0],nGal=p.nGals[0],grid_ext=p.grid_exts[1])\\n L_CII = getattr(GR,'L_[CII]158_sun')\\n L_CO = getattr(GR,'L_CO(1-0)_sun')\\n Zsfr = getattr(GR,'Zsfr')\\n lL_CO, lL_CII = np.log10(L_CO), np.log10(L_CII) \\n lL_CO, lL_CII = lL_CO[(L_CO > 0) & (L_CII > 0)], lL_CII[(L_CO > 0) & (L_CII > 0)]\\n lL_CO = np.append(lL_CO,np.array([6.1,5]))\\n lL_CII = np.append(lL_CII,np.array([8.9,9.7]))\\n # ax1.scatter(np.log10(L_CO), np.log10(L_CII), marker='^', c=np.log10(Zsfr), cmap='viridis', zorder=10,\\\\\\n # vmin=np.log10(0.05), vmax=np.log10(3.1), \\\\\\n # s=10, alpha=0.8, label='SIGAME 25Mpc_arepoPDF')\\n nbins = 100\\n k = kde.gaussian_kde(np.column_stack([lL_CO,lL_CII]).T)\\n x, y = np.mgrid[lL_CO.min():lL_CO.max():nbins*1j, \\\\\\n 4:lL_CII.max():nbins*1j]\\n z = k(np.vstack([x.flatten(), y.flatten()]))\\n CS = ax1.contour(x, y, z.reshape(x.shape),colors='deepskyblue',linestyles='dotted',levels=6)\\n CS.collections[0].set_label('SIGAME 25Mpc_arepoPDF')\\n\\n GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[0])\\n L_CII = getattr(GR,'L_[CII]158_sun')\\n L_CO = getattr(GR,'L_CO(1-0)_sun')\\n Zsfr = getattr(GR,'Zsfr')\\n lL_CO, lL_CII = np.log10(L_CO), np.log10(L_CII) \\n lL_CO, lL_CII = lL_CO[(L_CO > 0) & (L_CII > 0)], lL_CII[(L_CO > 0) & (L_CII > 0)]\\n lL_CO = np.append(lL_CO,np.array([-2.2,4.7]))\\n lL_CII = np.append(lL_CII,np.array([8,9.3]))\\n # ax1.scatter(np.log10(L_CO), np.log10(L_CII), marker='^', c=np.log10(Zsfr), cmap='viridis', zorder=10,\\\\\\n # vmin=np.log10(0.05), vmax=np.log10(3.1), \\\\\\n # s=10, alpha=0.8, label='SIGAME v3 Simba-%s' % (p.sim_runs[0].replace('_','').replace('Mpc','')))\\n nbins = 100\\n k = kde.gaussian_kde(np.column_stack([lL_CO,lL_CII]).T)\\n x, y = np.mgrid[lL_CO.min():lL_CO.max():nbins*1j, \\\\\\n 4:lL_CII.max():nbins*1j]\\n z = k(np.vstack([x.flatten(), y.flatten()]))\\n CS = ax1.contour(x, y, z.reshape(x.shape),colors='brown',levels=8,zorder=5,linestyles='dashed')\\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF_no_ext')\\n\\n # Observations\\n K16 = pd.read_pickle('data/observations/AHIMSA_sample_lit')\\n K16_LCII = K16['[CII]158_Lsun']\\n K16_LCO = K16['CO(1-0)_Lsun']\\n ax1.plot(np.log10(K16_LCO), np.log10(K16_LCII), '>', color='grey', ms=6, fillstyle='none',alpha=0.8, mew=1,zorder=0,\\\\\\n label='Mixed type galaxies [Kamenetzky+16]')\\n\\n C15 = pd.read_pickle('data/observations/DGS_Cormier_2015')\\n C15_LCII = C15['L_[CII]158']\\n C15_LCO = C15['L_CO(1-0)']\\n C15_Z = C15['Z']\\n # L_ul = C15['L_[CII]158'][(C15['L_[CII]158'] < 0) & (C15['L_CO(1-0)'] > 0)]\\n # if len(L_ul) > 0:\\n # ax1.plot(np.log10(C15['L_CO(1-0)'][C15['L_[CII]158'] < 0]),np.log10(-1.*L_ul),'s',ms=5,mew=0,color='grey',alpha=0.8)\\n # ax1.errorbar(np.log10(C15['L_CO(1-0)'][C15['L_[CII]158'] < 0]),np.log10(-1.*L_ul), elinewidth=1,\\\\\\n # uplims=np.ones(len(L_ul)),yerr=np.ones(len(L_ul))*1,color='grey',alpha=0.8,lw=0)\\n ax1.scatter(np.log10(C15_LCO), np.log10(C15_LCII), marker='+', c=np.log10(C15_Z), cmap='viridis', zorder=0,\\\\\\n vmin=np.log10(0.05), vmax=np.log10(3.1),\\\\\\n s=100, lw=3, alpha=0.8, label='Dwarf galaxies [Cormier+15]')\\n\\n A17 = pd.read_pickle('data/observations/xCOLD_GASS_Accurso_2017')\\n A17 = A17.loc[np.argwhere(A17['L_CO(1-0)'].values > 0).flatten()]\\n ax1.scatter(A17['L_CO(1-0)'],A17['L_[CII]158'], marker='d', c=np.log10(A17['Z']), cmap='viridis', zorder=0,\\\\\\n vmin=np.log10(0.05), vmax=np.log10(3.1),\\\\\\n s=50, lw=0, alpha=0.8, label='COLD GASS [Accurso+17]') #c=np.log10(A17['Z']), \\n\\n CII_obs = np.log10(np.append(K16_LCII.values,C15_LCII.values))\\n CO_obs = np.log10(np.append(K16_LCO.values,C15_LCO.values))\\n CII_obs = np.append(CII_obs,A17['L_[CII]158'].values)\\n CO_obs = np.append(CO_obs,A17['L_CO(1-0)'].values)\\n index = np.argwhere((CII_obs > 0) & (CO_obs > 0)).flatten()\\n CII_obs = CII_obs[index]\\n CO_obs = CO_obs[index]\\n\\n x = np.linspace(0, 7, 100)\\n fit = LinearRegression().fit(CO_obs.reshape(-1, 1),\\\\\\n CII_obs.reshape(-1, 1))\\n L_fit = fit.predict(x.reshape(-1, 1))\\n ax1.plot(x, L_fit, color='black', linestyle='--', label='Log-linear fit to observations')\\n\\n ax1.set_ylabel('log ' + getlabel('[CII]158'))\\n ax1.set_xlabel('log ' + getlabel('CO(1-0)'))\\n plt.colorbar(sc,label=r'log $\\\\langle$Z$\\\\rangle_{\\\\rm SFR}$ [Z$_{\\\\rm \\\\odot}$]')\\n\\n handles, labels = ax1.get_legend_handles_labels()\\n print(labels) # labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))\\n # handles = [handles[_] for _ in [2,4,3,5,0,6,7,1]]\\n # labels = [labels[_] for _ in [2,4,3,5,0,6,7,1]]\\n handles = [handles[_] for _ in [2,4,3,5,6,0,1]]\\n labels = [labels[_] for _ in [2,4,3,5,6,0,1]]\\n plt.legend(handles,labels,loc='lower left',fontsize=10.,frameon=True)\\n\\n ax1.set_xlim([-3,6.2])\\n ax1.set_ylim([4,10])\\n\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/CO_vs_CII%s%s.png' % (p.grid_ext,p.table_ext), dpi=300)\",\n \"def get_MultiPolyLists(mpoly,coord_type='x'):\\n if coord_type == 'x':\\n i=0\\n elif coord_type == 'y':\\n i=1\\n\\n # Get the x or y coordinates\\n c = []\\n if isinstance(mpoly,Polygon):\\n mpoly = [mpoly]\\n for poly in mpoly: # the polygon objects return arrays, it's important they be lists or Bokeh fails\\n exterior_coords = poly.exterior.coords.xy[i].tolist();\\n interior_coords = []\\n for interior in poly.interiors:\\n if isinstance(interior.coords.xy[i],list):\\n interior_coords += [interior.coords.xy[i]];\\n else:\\n interior_coords += [interior.coords.xy[i].tolist()];\\n c.append([exterior_coords, *interior_coords])\\n return c\",\n \"def get_contours_points(found, contours):\\n contours_points = []\\n for i in found:\\n c = contours[i]\\n for sublist in c:\\n for p in sublist:\\n contours_points.append(p)\\n return contours_points\",\n \"def p2p_xyz(start_point, end_point, top_left_cor, cellsize, dem):\\n start_cell = (int((start_point[0] - top_left_cor[0]) / cellsize[0]),\\n int((start_point[1] - top_left_cor[1]) / cellsize[1]))\\n end_cell = (int((end_point[0] - top_left_cor[0]) / cellsize[0]),\\n int((end_point[1] - top_left_cor[1]) / cellsize[1]))\\n cells = misc.get_line(start_cell, end_cell) \\n pnts = []\\n elev = []\\n \\n dem_elv = dem[:,1]\\n dem_indx = dem[:,2:4]\\n\\n for cell in cells:\\n x = top_left_cor[0] + cell[0] * cellsize[0] + cellsize[0] / 2\\n y = top_left_cor[1] + cell[1] * cellsize[1] + cellsize[1] / 2\\n #xy_indx=[str(cell[0]),str(cell[1])]\\n z_indx=np.logical_and(np.equal(dem_indx[:,0],cell[0]),np.equal(dem_indx[:,1],cell[1]))\\n try:\\n z=dem_elv[z_indx][0]\\n except (np.sum(z_indx)>1):\\n print(\\\"Oops! That was more than one indices in dem matching the query index (in getCellValue)\\\")\\n #z_indx = [i for i,j in enumerate(dem_indx) if j == xy_indx]\\n z = float(dem_elv[z_indx])\\n pnts.append((x, y))\\n elev.append(z)\\n return pnts, elev\",\n \"def printPolyCoeffs(lam) :\\n ell = len(lam)\\n useFormat = \\\"2.6e\\\"\\n count = 0\\n def printLine(s, count) :\\n if lam[count] < 0 :\\n s = s + 3 * \\\" \\\"\\n else :\\n s = s + 4 * \\\" \\\"\\n s = s + \\\"{0:\\\" + useFormat + \\\"}\\\"\\n print(s . format(lam[count]))\\n count = count + 1\\n return count\\n if ell >= 1 :\\n count = printLine(\\\"x0y0\\\", count)\\n if ell >= 3 :\\n count = printLine(\\\"x1y0\\\", count)\\n count = printLine(\\\"x0y1\\\", count)\\n if ell >= 6 :\\n count = printLine(\\\"x2y0\\\", count)\\n count = printLine(\\\"x1y1\\\", count)\\n count = printLine(\\\"x0y2\\\", count)\\n if ell >= 10 :\\n count = printLine(\\\"x3y0\\\", count)\\n count = printLine(\\\"x2y1\\\", count)\\n count = printLine(\\\"x1y2\\\", count)\\n count = printLine(\\\"x0y3\\\", count)\\n if ell >= 15 :\\n count = printLine(\\\"x4y0\\\", count)\\n count = printLine(\\\"x3y1\\\", count)\\n count = printLine(\\\"x2y2\\\", count)\\n count = printLine(\\\"x1y3\\\", count)\\n count = printLine(\\\"x0y4\\\", count)\\n if ell >= 21 :\\n count = printLine(\\\"x5y0\\\", count)\\n count = printLine(\\\"x4y1\\\", count)\\n count = printLine(\\\"x3y2\\\", count)\\n count = printLine(\\\"x2y3\\\", count)\\n count = printLine(\\\"x1y4\\\", count)\\n count = printLine(\\\"x0y5\\\", count)\\n if ell >= 28 :\\n count = printLine(\\\"x6y0\\\", count)\\n count = printLine(\\\"x5y1\\\", count)\\n count = printLine(\\\"x4y2\\\", count)\\n count = printLine(\\\"x3y3\\\", count)\\n count = printLine(\\\"x2y4\\\", count)\\n count = printLine(\\\"x1y5\\\", count)\\n count = printLine(\\\"x0y6\\\", count)\\n if ell >= 36 :\\n count = printLine(\\\"x7y0\\\", count)\\n count = printLine(\\\"x6y1\\\", count)\\n count = printLine(\\\"x5y2\\\", count)\\n count = printLine(\\\"x4y3\\\", count)\\n count = printLine(\\\"x3y4\\\", count)\\n count = printLine(\\\"x2y5\\\", count)\\n count = printLine(\\\"x1y6\\\", count)\\n count = printLine(\\\"x0y7\\\", count)\\n if (ell > 36) or (ell < 1) :\\n raise ValueError(\\\"Polynomial degree less than or equal to 7, please.\\\")\",\n \"def outputholepos(dictlist,origindict): #dictlist-一行中所有图层的字典的列表，其中字典为(key：图层名，value：一个outline中的该图层多段线列表) origindict-原始的未进行操作的字典\\r\\n \\r\\n layernamelist=list(origindict.keys())\\r\\n \\r\\n hole_list=[]\\r\\n holepolylinedict={}\\r\\n \\r\\n for layername in layernamelist: #得到通孔层的名称列表\\r\\n if layername[0]=='V' or layername[0]=='v':\\r\\n hole_list.append(layername)\\r\\n \\r\\n for holelayer in hole_list: #已经阵列好的第一行中每一层通孔多段线存入新的“通孔名称”-“一行中所有通孔多段线”的字典\\r\\n holepolylinelist=[] \\r\\n for d in dictlist: \\r\\n holepolylinelist.extend(d[holelayer])\\r\\n holepolylinedict[holelayer]=holepolylinelist\\r\\n \\r\\n holepolylinearraydict=holepolylinedictarraycopy(holepolylinedict) #对以上生成的字典进行操作，生成新的字典。字典中对应的值“一行中所有通孔多段线”向上阵列布满整个菲林区域\\r\\n \\r\\n \\r\\n holenotefile=open('通孔模式说明'+'.txt','w') #输出通孔模式说明\\r\\n holenotefile.write(\\\"各通孔文件通孔数一览表(不包括5H):\\\\n\\\")\\r\\n for e in holepolylinearraydict:\\r\\n holeposfile=open(e+'.txt','w')\\r\\n centerposlist=calculatecenterpos(holepolylinearraydict[e])\\r\\n centerposlist.sort()\\r\\n holenotefile.write(\\\"通孔层 \\\"+e+\\\" 一共有通孔 \\\"+'{:d}'.format(len(centerposlist))+\\\" 个\\\\n\\\") #输出每一通孔层的中心点数。即对应通孔数量\\r\\n for pos in centerposlist:\\r\\n holeposfile.write('X{:.0f}Y{:.0f}\\\\n'.format(pos[0]*1000,pos[1]*1000)) #要格式化输出，所以先要乘以1000，然后输出小数点前的部分 \\r\\n holeposfile.close()\",\n \"def transform(pts, ncfs, wo=2 * math.pi):\\n npts = len(pts)\\n h = ncfs // 2\\n cfs = {}\\n # Compute all coefficients\\n for n in range(-h, h + 1):\\n # Compute each coefficient\\n cn = 0\\n for iw in range(npts):\\n w = iw / npts # w is not a frequency but the variable of a parametric equation\\n fw = complex(*pts[iw])\\n cn += fw * cmath.exp(-1j * n * w * wo)\\n cn /= npts\\n cfs[n] = cn\\n return cfs\",\n \"def dict_format(x_temp):\\r\\n\\r\\n shown_indexes = rangelist.range_find([Index(a_temp)\\r\\n for a_temp in x_temp[1]])\\r\\n if len(shown_indexes) < 20:\\r\\n return (abridge(x_temp[0],maxlength=30)\\r\\n +VERTLINE\\r\\n +shown_indexes)\\r\\n\\r\\n returnlist = []\\r\\n sp_temp = rangelist.split_up_range(shown_indexes,seg_length=3)\\r\\n\\r\\n\\r\\n returnlist.append(abridge(x_temp[0],maxlength=20)\\r\\n +VERTLINE+sp_temp[0])\\r\\n for s_temp in sp_temp[1:]:\\r\\n returnlist.append(VERTLINE+s_temp)\\r\\n\\r\\n return returnlist\",\n \"def integrate(coords,data,fault_pts,dshape_hex8,gll_weights,elmt):\\n norm=0.0\\n normx=0.0\\n normy=0.0\\n normz=0.0\\n div=0.0 #normalizing factor to divide by\\n divx=0.\\n divy=0.\\n divz=0.\\n\\n eps=1.0*g.mesh_spacing/(g.ngllx-1.)\\n print 'eps=', eps\\n f=open('eliminated_coords.vtk','w')\\n\\n #create integer versions of arrays to use in pulling out gll pts for each element\\n data_round=np.rint(data)\\n dati=data_round.astype(int)\\n coord_round=np.rint(coords)\\n coordi=coord_round.astype(int)\\n\\n #remove duplicates from data array\\n dat_struc=np.ascontiguousarray(dati).view(np.dtype((np.void,dati.dtype.itemsize *dati.shape[1])))\\n _,idx=np.unique(dat_struc,return_index=True)\\n datu=dati[idx]\\n data_unique=data[idx]\\n\\n for i_elmt in range(g.nelmt):\\n #pull out geometric coordinates for this element\\n elmt_coord_id=[j-1 for j in elmt[i_elmt]]\\n elmt_coord=coordi[elmt_coord_id]\\n\\n #find corresponding gll pts for this element\\n xmin=min(elmt_coord[:,0]);xmax=max(elmt_coord[:,0])\\n ymin=min(elmt_coord[:,1]);ymax=max(elmt_coord[:,1])\\n zmin=min(elmt_coord[:,2]);zmax=max(elmt_coord[:,2])\\n gll_coord_id=np.nonzero((datu[:,0]>=xmin) & (datu[:,0]<=xmax) & (datu[:,1]>=ymin) & (datu[:,1]<=ymax) & (datu[:,2]>=zmin) & (datu[:,2]<=zmax))\\n elmt_data=data_unique[gll_coord_id]\\n if len(gll_coord_id[0]) != g.ngll:\\n print \\\"elmt=\\\", elmt_coord_id\\n print xmin,xmax,ymin,ymax,zmin,zmax\\n print 'elmt_data=', elmt_data\\n print \\\"gll pts found=\\\", len(gll_coord_id[0])\\n raise ValueError(\\\"incorrect number of gll points found in element!\\\")\\n exit\\n\\n #sort the gll coords so they correspond the order of the arrays giving the weights and shape function\\n dat_sorted=elmt_data[npi.argsort((elmt_data[:,0], elmt_data[:,1],elmt_data[:,2]))]\\n func=dat_sorted[:,3:]\\n\\n #if any gll pt is too close to fault, remove the element from the integration\\n dist=distance.cdist(fault_pts,dat_sorted[:,0:3],'euclidean')\\n if (dist<eps).any():\\n print \\\"eliminated element #\\\", i_elmt\\n np.savetxt(f,dat_sorted[:,0:3],fmt='%3.3f')\\n continue\\n\\n for i_gll in range(g.ngll):\\n\\n #compute jacobian, its derivative and inverse\\n jac=np.matmul(dshape_hex8[:,:,i_gll],elmt_coord)\\n det_jac=np.linalg.det(jac)\\n\\n #perform the integration\\n norm=norm+det_jac*gll_weights[i_gll]*np.dot((func[i_gll,3:6]-func[i_gll,0:3]),(func[i_gll,3:6]-func[i_gll,0:3]))\\n div=div+det_jac*gll_weights[i_gll]*np.dot(func[i_gll,3:6],func[i_gll,3:6])\\n normx=normx+det_jac*gll_weights[i_gll]*(func[i_gll,3]-func[i_gll,0])**2\\n divx=divx+det_jac*gll_weights[i_gll]*(func[i_gll,3])**2\\n normy=normy+det_jac*gll_weights[i_gll]*(func[i_gll,4]-func[i_gll,1])**2\\n divy=divy+det_jac*gll_weights[i_gll]*(func[i_gll,4])**2\\n normz=normz+det_jac*gll_weights[i_gll]*(func[i_gll,5]-func[i_gll,2])**2\\n divz=divz+det_jac*gll_weights[i_gll]*(func[i_gll,5])**2\\n\\n norm_finalx=sqrt(normx/divx)\\n norm_finaly=sqrt(normy/divy)\\n norm_finalz=sqrt(normz/divz)\\n norm_final=sqrt(norm/div)\\n\\n f.close()\\n\\n return norm_finalx, norm_finaly, norm_finalz,norm_final\",\n \"def draw(self, **kwargs):\\n\\n Lons = numpy.ones(self.data.shape)*0.5\\n Lats = numpy.ones(self.data.shape)*0.5\\n for ix in range(self.ncols):\\n for iy in range(self.nrows):\\n Lons[iy,ix] = self.xllcorner+float(ix)*self.cellsize\\n Lats[iy,ix] = self.yllcorner+float(iy)*self.cellsize\\n ContourMin = numpy.min(numpy.where(self.data != self.nodata,self.data, 1000000))\\n ContourMax = numpy.max(numpy.where(self.data != self.nodata,self.data, -1000000))*1.10\\n if kwargs.has_key('contours'):\\n if type( kwargs['contours'] ) == type( 1 ):\\n Contours = numpy.arange(ContourMin, ContourMax, (ContourMax-ContourMin)/float( kwargs['contours']+1))\\n else:\\n Contours = kwargs['contours']\\n else:\\n Contours = numpy.arange(ContourMin, ContourMax, (ContourMax-ContourMin)/11.)\\n if kwargs.has_key('cmap'):\\n mycmap = kwargs['cmap']\\n else:\\n mycmap = 'jet'\\n if kwargs.has_key('dmap'):\\n dmap = max(0,min(4,kwargs['dmap']))\\n else:\\n dmap = 4\\n # Lambert Conformal Conic map.\\n if kwargs.has_key('res'):\\n if kwargs['res']=='med':\\n mapres='i'\\n elif kwargs['res']=='hi':\\n mapres='h'\\n else:\\n mapres = 'l'\\n else:\\n mapres = 'l'\\n if mapres not in ('c','l','i','h'):\\n mapres = 'l'\\n m = Basemap(llcrnrlon=Lons[0,0], llcrnrlat=Lats[0,0], urcrnrlon=Lons[self.nrows-1,self.ncols-1], urcrnrlat=Lats[self.nrows-1,self.ncols-1],\\n projection='lcc',lat_1=30.,lat_2=60.,lon_0=(Lons[0,0]+Lons[self.nrows-1,self.ncols-1])/2.,\\n resolution =mapres,area_thresh=1000.)\\n # create figure, add axes.\\n fig=p.figure()\\n ax = fig.add_axes([0.1,0.1,0.7,0.7])\\n #make a filled contour plot.\\n x, y = m( Lons , Lats)\\n CS = m.contourf(x,y,self.data, Contours, cmap=p.get_cmap(mycmap))\\n\\tpos = ax.get_position()\\n\\tl, b, w, h = getattr(pos, 'bounds', pos)\\n #l,b,w,h=ax.get_position()\\n cax = p.axes([l+w+0.075, b, 0.05, h]) # setup colorbar axes\\n p.colorbar(drawedges=True, cax=cax) # draw colorbar\\n p.axes(ax) # make the original axes current again\\n\\n if kwargs.has_key('shapefiles'):\\n for s in kwargs['shapefiles']:\\n try:\\n lw = s[3]\\n except:\\n lw = 0.5\\n try:\\n clr = s[4]\\n except:\\n clr='k'\\n shp_info = apply(m.readshapefile, (s[0],s[1]),{'drawbounds':s[2], 'linewidth':lw, 'color':clr} )\\n # draw coastlines, meridians and parallels.\\n if dmap > 1:\\n m.drawcoastlines()\\n if dmap > 2:\\n m.drawcountries()\\n if dmap > 3:\\n m.drawstates()\\n if dmap > 0:\\n m.drawparallels(p.arange(10,70,10),labels=[1,1,0,0])\\n m.drawmeridians(p.arange(-100,0,10),labels=[0,0,0,1])\\n if kwargs.has_key('title'):\\n p.title(kwargs['title'])\\n else:\\n p.title(self.name.title())\\n if kwargs.has_key('format'):\\n fn = self.name+'.'+kwargs['format']\\n if kwargs.has_key('dpi'):\\n dots = kwargs['dpi']\\n else:\\n dots = 100\\n try:\\n p.savefig(fn,dpi=dots)\\n except:\\n print 'Error saving to format : ', kwargs['format']\\n else:\\n p.show()\",\n \"def compute_contour(ptr_array):\\n hull = ConvexHull(ptr_array)\\n contour_index = hull.vertices.tolist() # indices are ordered\\n # contour_index = hull.simplices.flatten()\\n # contour_index = list(set(contour_index))\\n return contour_index\",\n \"def load_drawings(self, contours, append=False):\\n\\n CONTOUR_IS_INTERPOLATED = 1\\n\\n if not append:\\n self.drawings = defaultdict(list)\\n\\n endorser_contour_lookup = defaultdict(set)\\n for cnt_id, contour in contours.iterrows():\\n for editor in set([edit['username'] for edit in contour['edits']]):\\n endorser_contour_lookup[editor].add(cnt_id)\\n endorser_contour_lookup[contour['creator']].add(cnt_id)\\n\\n grouped = contours.groupby('section')\\n\\n for i_or_sec, group in grouped:\\n # if i_or_sec not in self.data_feeder.sections: continue ## IS TIHS NECESSARY ?\\n for contour_id, contour in group.iterrows():\\n vertices = contour['vertices']\\n contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\\n self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\\n linecolor='r', section=i_or_sec, type=contour_type,\\n side=contour['side'],\\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else False,\\n side_manually_assigned=contour['side_manually_assigned'],\\n edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'],\\n contour_id=contour_id)\\n\\n # grouped = contours.groupby('position')\\n #\\n # for i_or_sec, group in grouped:\\n # for contour_id, contour in group.iterrows():\\n # vertices = contour['vertices']\\n # contour_type = 'interpolated' if contour['flags'] & CONTOUR_IS_INTERPOLATED else None\\n # endorsers = set([edit['username'] for edit in contour['edits']] + [contour['creator']])\\n # self.add_polygon_with_circles_and_label(path=vertices_to_path(vertices), label=contour['name'], label_pos=contour['label_position'],\\n # linecolor='r', index=i_or_sec, type=contour_type,\\n # side=contour['side'],\\n # side_manually_assigned=contour['side_manually_assigned'] if 'side_manually_assigned' in contour else True,\\n # edit_history=[{'username': contour['creator'], 'timestamp': contour['time_created']}] + contour['edits'])\",\n \"def add_rois_of_selected(self):\\r\\n \\r\\n for selected_index in self.selected_ML_Index:\\r\\n\\r\\n contours = self.selected_cells_infor_dict['cell{}_verts'.format(str(selected_index))]\\r\\n# contours = find_contours(self.Mask[:,:,selected_index], 0.5) # Find iso-valued contours in a 2D array for a given level value.\\r\\n \\r\\n for n, contour in enumerate(contours):\\r\\n contour_coord_array = contours[n]\\r\\n #Swap columns\\r\\n contour_coord_array[:, 0], contour_coord_array[:, 1] = contour_coord_array[:, 1], contour_coord_array[:, 0].copy()\\r\\n \\r\\n #Down sample the coordinates otherwise it will be too dense.\\r\\n contour_coord_array_del = np.delete(contour_coord_array, np.arange(2, contour_coord_array.shape[0]-3, 2), 0)\\r\\n \\r\\n self.selected_cells_infor_dict['cell{}_ROIitem'.format(str(selected_index))] = \\\\\\r\\n pg.PolyLineROI(positions=contour_coord_array_del, closed=True)\\r\\n \\r\\n self.Mask_edit_view.getView().addItem(self.selected_cells_infor_dict['cell{}_ROIitem'.format(str(selected_index))])\",\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 make_cspad_pix_coordinate_arrays (sp, xc_um, yc_um, orient_deg, tilt_deg) : # All lists of [4,8] \\n sp.make_maps_of_2x1_pix_coordinates()\\n\\n sp.x_pix_um = np.zeros((sp.quads,sp.sects,sp.rows,sp.cols), dtype=np.float32)\\n sp.y_pix_um = np.zeros((sp.quads,sp.sects,sp.rows,sp.cols), dtype=np.float32)\\n\\n angle_deg = orient_deg + tilt_deg\\n \\n for quad in range(sp.quads) :\\n for sect in range(sp.sects) :\\n\\n angle_rad = math.radians(angle_deg[quad][sect]) \\n S,C = math.sin(angle_rad), math.cos(angle_rad)\\n Xrot, Yrot = rotation(sp.x_map2x1, sp.y_map2x1, C, S)\\n\\n sp.x_pix_um[quad][sect][:] = Xrot + xc_um[quad][sect]\\n sp.y_pix_um[quad][sect][:] = Yrot + yc_um[quad][sect]\\n\\n sp.x_pix_um -= sp.x_pix_um.min() + 5 # add offset in um to get rid of \\\"rounding\\\" strips...\\n sp.y_pix_um -= sp.y_pix_um.min() + 5\",\n \"def polyhedra_from_xyz(xyz_file: str,\\n try_convex_hull: bool = True)\\\\\\n -> Tuple[List[Polyhedron],\\\\\\n List[VertexCollection],\\\\\\n List[Union[Polyhedron,VertexCollection]]]:\\n\\n object_coordinates_dict: Dict[str, List[List[float]]] = {}\\n polyhedron_list: List[Polyhedron] = []\\n vertex_collection_list: List[VertexCollection] = []\\n object_list: List[Union[Polyhedron,VertexCollection]] = []\\n type_order: List[str] = []\\n with open(xyz_file, 'r') as f:\\n lines = f.readlines()\\n for i in range(len(lines)):\\n line = lines[i].strip()\\n if i == 0:\\n l = re.search(\\\"\\\\d+$\\\", line)\\n assert l is not None\\n n_points = int(l.group())\\n elif i == 1:\\n l = re.search(\\\"\\\\d+$\\\", line)\\n assert l is not None\\n dim = int(l.group())\\n assert dim <= 3, 'We cannot visualise the fourth dimension and\\\\\\n above.'\\n else:\\n if line == '':\\n continue\\n l = re.search(\\\"([A-Za-z]+[0-9]*)[\\\\s\\\\t]+\\\", line)\\n assert l is not None\\n point_type = l.group(1)\\n l2 = re.findall(\\\"[+-]?\\\\d+\\\\.\\\\d*\\\", line)\\n point_coordinates = []\\n for coordinate in l2:\\n point_coordinates.append(float(coordinate))\\n assert len(point_coordinates) == dim\\n if point_type not in object_coordinates_dict:\\n object_coordinates_dict[point_type] = []\\n object_coordinates_dict[point_type].append(point_coordinates)\\n if point_type not in type_order:\\n type_order.append(point_type)\\n\\n for point_type in type_order:\\n object_coordinates = np.array(object_coordinates_dict[point_type])\\n if try_convex_hull:\\n try:\\n print(\\\"Attempting to construct a convex hull for {}...\\\"\\\\\\n .format(point_type))\\n polyhedron = construct_convex_hull_from_coords\\\\\\n (object_coordinates)\\n polyhedron_list.append(polyhedron)\\n object_list.append(polyhedron) \\n except:\\n print(\\\"Failed to construct a convex hull for {}.\\\"\\\\\\n .format(point_type))\\n print(\\\"Falling back to vertex collection for {}...\\\"\\\\\\n .format(point_type))\\n vertex_collection = construct_vertex_collection_from_coords\\\\\\n (object_coordinates, 2)\\n vertex_collection_list.append(vertex_collection)\\n object_list.append(vertex_collection) \\n else:\\n print(\\\"Constructing a vertex collection for {}...\\\"\\\\\\n .format(point_type))\\n vertex_collection = construct_vertex_collection_from_coords\\\\\\n (object_coordinates, 2)\\n vertex_collection_list.append(vertex_collection)\\n object_list.append(vertex_collection) \\n\\n return polyhedron_list,vertex_collection_list,object_list\",\n \"def sort_cutpoly_by_angle(self, polydata, cells_list, num_cells, numPoints):\\n # 1: get numpy array of points from vtk polydata object\\n points = polydata.GetPoints()\\n pts = np.zeros((numPoints, 3), dtype=float)\\n\\n index = 0\\n for cell in cells_list:\\n for id in cell:\\n pts[index] = np.asarray(points.GetPoint(id))\\n index += 1\\n\\n # 2: convert them to 2d points and obtain the R rotation matrix\\n pts_2d = project_onto_xy_plane(pts)\\n\\n # 3: compute center (average of all points)\\n center_pt = np.mean(pts_2d, axis=0)\\n\\n # 4: find top points by pointdata label\\n\\n # 4: compute angles from center to average cell pts:nt vertical_dir = vert_pt_2d - center_pt # get vertical direction vector (from center pt to tp1)\\n signed_angles = np.zeros((numPoints,), dtype=float)\\n\\n for i in range(numPoints):\\n current_vec = pts_2d[i] - center_pt\\n signed_angles[i] = compute_angle_between(vertical_dir, current_vec)\\n self.pers_var = 1\\n if self.pers_var: # ctrl-w for exit window key\\n plt.figure()\\n plt.scatter(center_pt[0], center_pt[1], color='r', s=2)\\n plt.scatter(pts_2d[:,0], pts_2d[:,1], color='b', s=0.5)\\n plt.scatter(vert_pt_2d[0], vert_pt_2d[1], color='g', s=10)\\n plt.scatter(pts_2d[i][0], pts_2d[i][1], color='k', s=7)\\n plt.xlabel('angle = ' + str(signed_angles[i]))\\n figManager = plt.get_current_fig_manager()\\n figManager.window.showMaximized()\\n plt.show()\\n\\n # 5: sort angles (no matter ascending or descending)\\n sorted_idxs = np.argsort(signed_angles)\\n\\n # 6: sorted points\\n sorted_pts = pts[sorted_idxs]\\n\\n return sorted_pts, sorted_idxs\",\n \"def _pco_list(self, hdr, name, pos):\\n if name not in ('poly', 'champs', 'offset'):\\n raise TypeError('Name must be one of \\\"poly\\\", \\\"champs\\\", or \\\"offset\\\".')\\n\\n hdr.seek(pos + 16)\\n length = unpack(self._bo + 'i', hdr.read(4))[0]\\n d = []\\n for p in range(length):\\n if name == 'poly':\\n d.append(self._species(hdr))\\n else:\\n raise NotImplementedError(\\n '{}List is non-null, don\\\\'t know how to read.'\\n ''.format(name.capitalize()))\\n hdr.seek(4, 1)\\n return d\",\n \"def output_grid_information():\\n # translate = [-74.26, 40.50]\\n # scale = [0.02, 0.02]\\n # step = 1\\n\\n translate = [0, 0]\\n scale = [1, 1]\\n step = 0.02\\n\\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\\n\\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\\n\\n all_json = {\\n \\\"type\\\": \\\"FeatureCollection\\\"\\n }\\n\\n gr_id = 0\\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\\n features = []\\n\\n for lat in lats:\\n for lon in lons:\\n w_lon = lon\\n e_lon = lon + step\\n s_lat = lat\\n n_lat = lat + step\\n\\n c_lon = lon + step / 2\\n c_lat = lat + step / 2\\n\\n grid_df = grid_df.append(pd.DataFrame({\\\"gr_id\\\": [gr_id],\\n \\\"c_lon\\\": [c_lon], \\\"c_lat\\\": [c_lat],\\n \\\"w_lon\\\": [w_lon], \\\"s_lat\\\": [s_lat],\\n \\\"e_lon\\\": [e_lon], \\\"n_lat\\\": [n_lat]}))\\n\\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\\n [s_lat, e_lon], [s_lat, w_lon]]]\\n\\n feature = {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"Polygon\\\",\\n \\\"coordinates\\\": coor\\n },\\n \\\"properties\\\": {\\n \\\"id\\\": str(gr_id)\\n }\\n }\\n\\n features.append(feature)\\n\\n gr_id += 1\\n\\n all_json['features'] = features\\n\\n with open(BaseDir + '/grid.geojson', 'w') as f:\\n json.dump(all_json, f)\\n\\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)\",\n \"def plotConic(L, R, points_x, points_y, xBounds=[-50,50], yBounds=[-50,50]): \\n \\n x = np.linspace(xBounds[0],xBounds[1],5000)\\n y = np.linspace(yBounds[0],yBounds[1],5000)\\n x, y = np.meshgrid(x, y)\\n #assert B**2 - 4*A*C == 0 \\n A = L[0,0]\\n B = 2*L[0,1]\\n C = L[1,1]\\n D = 2*L[0,2]\\n E = 2*L[1,2]\\n F = L[2,2] \\n plt.contour(x, y,(A*x**2 + B*x*y + C*y**2 + D*x + E*y + F), [0], colors='g')\\n A = R[0,0]\\n B = 2*R[0,1]\\n C = R[1,1]\\n D = 2*R[0,2]\\n E = 2*R[1,2]\\n F = R[2,2] \\n plt.contour(x, y,(A*x**2 + B*x*y + C*y**2 + D*x + E*y + F), [0], colors='r')\\n plt.scatter(points_x, points_y, marker='o', color='k')\\n plt.show()\",\n \"def contours_to_patient_coord_sys_and_points_to_skull_axial_axis(datasets, series_arr):\\n mean_points_real = [0, 0, 0] # to storage points on the skull axis line (healthy slices)\\n contours_list = [None] * series_arr.shape[2] # list of all contours of all slices\\n contours_mean_point_list = [None] * series_arr.shape[2] # list of all mean points of contours of interest\\n rotation_info_list = [] # to storage rotation info found by the icp\\n # Converts all contours for patient coordinate space based on DICOM tag information\\n for i in range(series_arr.shape[2]):\\n img = series_arr[:, :, i]\\n # Collecting image information\\n img_orient_pat = [float(x) for x in list(datasets[i].ImageOrientationPatient)]\\n img_position_pat = [float(x) for x in list(datasets[i].ImagePositionPatient)]\\n pixel_spacing = [float(x) for x in list(datasets[i].PixelSpacing)]\\n iop1 = np.array(img_orient_pat[0:3])\\n iop2 = np.array(img_orient_pat[3:6])\\n # Finding contours\\n [cw, pma] = select_contours(img)\\n # Setting which one is the internal / external contour (internal=[0], external=[1]) when needed\\n if len(pma) == 2:\\n contour_0_len = len(cw[0])\\n contour_1_len = len(cw[1])\\n if contour_0_len >= contour_1_len:\\n cw[0], cw[1] = cw[1], cw[0]\\n cw_real = copy.copy(cw)\\n # Coordinate system conversion for all contours\\n for contour in cw_real:\\n for k in range(len(contour)):\\n contour[k] = img_position_pat \\\\\\n + iop1 * pixel_spacing[1] * contour[k][0] \\\\\\n + iop2 * pixel_spacing[0] * contour[k][1]\\n contours_list[i] = cw_real\\n # Collecting points to skull axial axis and lateral symmetry calculation\\n if len(pma) == 2: # healthy skull slice has outside and inside contours (pixel_mean_array has 2 points)\\n # uses the mean point of the external contour (contours are approx. concentric)\\n pixel_mean_real = img_position_pat \\\\\\n + iop1 * pixel_spacing[1] * pma[1][0] \\\\\\n + iop2 * pixel_spacing[0] * pma[1][1]\\n contours_mean_point_list[i] = pixel_mean_real\\n mean_points_real = np.vstack([mean_points_real, pixel_mean_real])\\n # Lateral symmetry\\n # external_contour_mirrored = mirror_contour_point(cw_real[1][:, 0:2], pixel_mean_real[0:2])\\n # T = icp_wrap(cw_real[1][:, 0:2], external_contour_mirrored, debug=True)\\n # rotation_info_list.append(T)\\n\\n return contours_list\",\n \"def cfdProcessElementTopology(self):\\r\\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \\r\\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\\r\\n\\r\\n ## (list of lists) list of face indices forming each element\\r\\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n #populates self.elementNeighbours\\r\\n for iFace in range(self.numberOfInteriorFaces):\\r\\n own=self.owners[iFace]\\r\\n nei=self.neighbours[iFace]\\r\\n \\r\\n #adds indices of neighbour cells\\r\\n self.elementNeighbours[own].append(nei)\\r\\n self.elementNeighbours[nei].append(own)\\r\\n \\r\\n #adds interior faces\\r\\n self.elementFaces[own].append(iFace)\\r\\n self.elementFaces[nei].append(iFace)\\r\\n \\r\\n #adds boundary faces ('patches')\\r\\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\\r\\n own=self.owners[iFace]\\r\\n self.elementFaces[own].append(iFace)\\r\\n \\r\\n ## List of lists containing points forming each element\\r\\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n \\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\\r\\n \\r\\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\\r\\n \\r\\n ## Upper coefficient indices (owners)\\r\\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n ## Lower coefficient indices (owners)\\r\\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n ## Element number from 1 to numberOfElements + 1\\r\\n iNb=1\\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n \\r\\n #skip if it is a boundary face\\r\\n if faceIndex > self.numberOfInteriorFaces-1:\\r\\n continue\\r\\n \\r\\n own = self.owners[faceIndex]\\r\\n nei = self.neighbours[faceIndex]\\r\\n \\r\\n if iElement == own:\\r\\n self.upperAnbCoeffIndex[faceIndex] = iNb\\r\\n elif iElement == nei:\\r\\n self.lowerAnbCoeffIndex[faceIndex] = iNb\\r\\n \\r\\n iNb = iNb +1\",\n \"def generatePolygons():\",\n \"def collect_lines(xy, BL, bs, climv):\\n lines = [zip(xy[BL[i, :], 0], xy[BL[i, :], 1]) for i in range(len(BL))]\\n line_segments = LineCollection(lines, # Make a sequence of x,y pairs\\n linewidths=1., # could iterate over list\\n linestyles='solid',\\n cmap='coolwarm',\\n norm=plt.Normalize(vmin=-climv, vmax=climv))\\n line_segments.set_array(bs)\\n print(lines)\\n return line_segments\",\n \"def buildxy(self):\\n\\n x_dim = float(self.metadata['XPTS'])\\n xmin = float(self.metadata['XMIN'])\\n xrange = float(self.metadata['XWID'])\\n\\n d_x = xrange/(x_dim-1)\\n x_axis = (np.arange(xmin, xmin+x_dim*d_x, d_x))\\n\\n # y_dim = float(\\\"\\\".join(ProcessSpectra.get_from_dict('YPTS')))\\n # ymin = list(map(float, get_from_dict('YMIN')))\\n # yrange = float(\\\"\\\".join(ProcessSpectra.get_from_dict('YWID')))\\n\\n frwidth = 1000/(x_axis[0])\\n frinc = frwidth/(len(self.zdata))\\n freq = np.arange(-frwidth, frwidth, frinc*2)\\n xdata = freq\\n ydata = freq\\n\\n return xdata, ydata\",\n \"def bezierPoly(ctrlP):\\n n = len(ctrlP) - 1 #degree of the polynomial\\n first = True\\n for t in np.linspace(0.0, 1.0, 5 * n):\\n point = bezierFunc(ctrlP, t)\\n if first: # Initialize list of points in the polynomial\\n bezierPointsList = np.copy(point)\\n first = False\\n else:\\n bezierPointsList = np.append(bezierPointsList, point, axis=0)\\n return bezierPointsList\",\n \"def cell_verts(self, idx):\\r\\n coords = []\\r\\n xyz = [0, 0, 0]\\r\\n cell = self.grid.GetCell(idx[0] - 1, idx[1] - 1, idx[2] - 1)\\r\\n p_ids = cell.GetPointIds()\\r\\n n_ids = pointIds.GetNumberOfIds()\\r\\n for n in range(n_ids):\\r\\n p = p_ids.GetId(n)\\r\\n self.grid.GetPoint(p, xyz)\\r\\n coords.append(copy.deepcopy(xyz))\\r\\n return coords\",\n \"def collisionFromLoops(mesh):\\n polys = list()\\n for f in mesh.polygons:\\n for lID in f.loop_indices:\\n loop = mesh.loops[lID]\\n #vIndex = IDTransl[loop.vertex_index]\\n\\n #creating a polyVert with only the poly index, since we only need that for collisions\\n polys.append(PolyVert(loop.vertex_index))\\n \\n return [ polys ]\",\n \"def GetCVLSWithLimitedPointsBetweenNodes(\\n cVLS, allValsByFrame, splitLength=1, fixedNumInteriorPoints=None, interpolate=True\\n):\\n allValues = list(set(tuple(flatten(allValsByFrame))))\\n allPairs = sorted(\\n list(set([tuple(c[0]) for cVLSByFrame in cVLS for c in cVLSByFrame]))\\n ) # Value pairs...\\n\\n if fixedNumInteriorPoints:\\n numInteriorPoints = {p: fixedNumInteriorPoints for p in allPairs}\\n else:\\n minLength = {}\\n for p in allPairs:\\n # minLength is the number of points of the shortest subcountour between cells p[0] and p[1] from all frames\\n minLength[p] = min(\\n [\\n len(c[2])\\n for cVLSByFrame in cVLS\\n for c in cVLSByFrame\\n if tuple(c[0]) == p\\n ]\\n )\\n # length of subcontour\\n numInteriorPoints = {}\\n for p in allPairs:\\n numInteriorPoints[p] = minLength[p] // splitLength\\n\\n cVLS2 = deepcopy(\\n cVLS\\n ) # otherwise, we'd also change the input argument cVLS in the outside world!\\n limIntPtsFunc = (\\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\\n )\\n\\n for cvlsByFrame in cVLS2:\\n for c in cvlsByFrame:\\n c[2] = limIntPtsFunc(c[2], numInteriorPoints[tuple(c[0])])\\n\\n return cVLS2\",\n \"def calc_positions(zpoints, dsq_list):\\n\\n pos_map = {}\\n points_map = {}\\n\\n for z, p in zpoints.items():\\n if z in dsq_list:\\n p = -1\\n if p not in points_map:\\n points_map[p] = set()\\n points_map[p].add(z)\\n\\n i = 1\\n for p in sorted(list(points_map.keys()), reverse = True):\\n pos_map[i] = points_map[p]\\n i += len(points_map[p])\\n\\n return pos_map\",\n \"def extract_data(data_file):\\n\\n data_points = set()\\n points_to_coordinates = {}\\n x_coor_dict = {}\\n # need this since we need to iterate through the first point indices in a fixed order\\n first_point_indices = []\\n\\n with open(data_file) as input_file:\\n # consume the first line, it only tells us how many points there are\\n input_file.readline()\\n point_number = 0\\n current_x_coor = inf\\n # point that's used as the indexing point for a list of points with the same x coordinates\\n first_point_index = 1\\n\\n for line in input_file:\\n point_number += 1\\n line = line.strip('\\\\n')\\n split_line = line.split(\\\" \\\")\\n print(split_line)\\n x_coor = float(split_line[1])\\n # if we're seeing this x coordinate for the first time\\n if current_x_coor != x_coor:\\n first_point_index = point_number\\n first_point_indices.append(first_point_index)\\n x_coor_dict[first_point_index] = []\\n current_x_coor = x_coor\\n x_coor_dict[first_point_index].append(point_number)\\n new_point = Point(x_coor, float(split_line[2]))\\n points_to_coordinates[point_number] = new_point\\n data_points.add(point_number)\\n\\n return data_points, points_to_coordinates, x_coor_dict, first_point_indices\",\n \"def update_ptable(self):\\n from bokeh.sampledata.periodic_table import elements\\n romans = [\\\"I\\\", \\\"II\\\", \\\"III\\\", \\\"IV\\\", \\\"V\\\", \\\"VI\\\", \\\"VII\\\"]\\n\\n elements[\\\"atomic mass\\\"] = elements[\\\"atomic mass\\\"].astype(str)\\n\\n elements[\\\"period\\\"] = [x for x in elements.period]\\n elements = elements[elements.group != \\\"-\\\"]\\n\\n group_range = [str(x) for x in range(1, 19)]\\n print ('reaches colormap def')\\n colormap = {\\n \\\"c\\\" : \\\"#ffa07a\\\",\\n \\\"nc\\\" : \\\"#A9A9A9\\\"\\n }\\n elems_colorpair = {}\\n\\n fcc_B_extrapol_props = {}\\n fcc_dB_extrapol_props = {}\\n fcc_V0_extrapol_props = {}\\n fcc_E0_extrapol_props = {}\\n\\n bcc_B_extrapol_props = {}\\n bcc_dB_extrapol_props = {}\\n bcc_V0_extrapol_props = {}\\n bcc_E0_extrapol_props = {}\\n\\n hcp_B_extrapol_props = {}\\n hcp_dB_extrapol_props = {}\\n hcp_V0_extrapol_props = {}\\n hcp_E0_extrapol_props = {}\\n\\n available_elems = []\\n\\n for e in elements[\\\"symbol\\\"]:\\n if e in np.unique(list(self.plot_data['element'])):\\n available_elems.append(e)\\n for s in np.unique(list(self.plot_data['structure'])):\\n plot_struct = self.plot_data[self.plot_data['structure']==s]\\n plot_struct_elem = plot_struct[plot_struct['element']==e]\\n if s=='fcc':\\n try:\\n fcc_B_extrapol_props.update({e:list(plot_struct_elem['B'])[0]})\\n\\n fcc_dB_extrapol_props.update({e:list(plot_struct_elem['BP'])[0]})\\n\\n fcc_V0_extrapol_props.update({e:list(plot_struct_elem['V0'])[0]})\\n\\n fcc_E0_extrapol_props.update({e:list(plot_struct_elem['E0'])[0]})\\n except:\\n pass\\n elif s=='bcc':\\n try:\\n bcc_B_extrapol_props.update({e:list(plot_struct_elem['B'])[0]})\\n\\n bcc_dB_extrapol_props.update({e:list(plot_struct_elem['BP'])[0]})\\n\\n bcc_V0_extrapol_props.update({e:list(plot_struct_elem['V0'])[0]})\\n\\n bcc_E0_extrapol_props.update({e:list(plot_struct_elem['E0'])[0]})\\n except:\\n pass\\n elif s=='hcp':\\n try:\\n hcp_B_extrapol_props.update({e:list(plot_struct_elem['B'])[0]})\\n\\n hcp_dB_extrapol_props.update({e:list(plot_struct_elem['BP'])[0]})\\n\\n hcp_V0_extrapol_props.update({e:list(plot_struct_elem['V0'])[0]})\\n\\n hcp_E0_extrapol_props.update({e:list(plot_struct_elem['E0'])[0]})\\n except:\\n pass\\n fcc_E0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_E0_extrapol_props})\\n fcc_V0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_V0_extrapol_props})\\n fcc_B_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_B_extrapol_props})\\n fcc_dB_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in fcc_dB_extrapol_props})\\n\\n bcc_E0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_E0_extrapol_props})\\n bcc_V0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_V0_extrapol_props})\\n bcc_B_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_B_extrapol_props})\\n bcc_dB_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in bcc_dB_extrapol_props})\\n\\n hcp_E0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_E0_extrapol_props})\\n hcp_V0_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_V0_extrapol_props})\\n hcp_B_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_B_extrapol_props})\\n hcp_dB_extrapol_props.update({k:'xxx' for k in elements['symbol'] if k not in hcp_dB_extrapol_props})\\n\\n elems_colorpair.update( { key:'c' for key in np.unique(available_elems) } )\\n elems_colorpair.update( { key:'nc' for key in list(elements['symbol']) if key not in list(elems_colorpair.keys()) } )\\n\\n\\n print ([ colormap[elems_colorpair[x]] for x in elements['symbol'] ])\\n\\n source = ColumnDataSource(\\n data=dict(\\n group=[str(x) for x in elements[\\\"group\\\"]],\\n period=[str(y) for y in elements[\\\"period\\\"]],\\n symx=[str(x)+\\\":0.1\\\" for x in elements[\\\"group\\\"]],\\n numbery=[str(x)+\\\":0.8\\\" for x in elements[\\\"period\\\"]],\\n massy=[str(x)+\\\":0.15\\\" for x in elements[\\\"period\\\"]],\\n namey=[str(x)+\\\":0.3\\\" for x in elements[\\\"period\\\"]],\\n sym=elements[\\\"symbol\\\"],\\n name=elements[\\\"name\\\"],\\n# cpk=elements[\\\"CPK\\\"],\\n atomic_number=elements[\\\"atomic number\\\"],\\n# electronic=elements[\\\"electronic configuration\\\"],\\n fcc_B=[fcc_B_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n fcc_dB=[fcc_dB_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n fcc_V0=[fcc_V0_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n fcc_E0=[fcc_E0_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n bcc_B=[bcc_B_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n bcc_dB=[bcc_dB_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n bcc_V0=[bcc_V0_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n bcc_E0=[bcc_E0_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n hcp_B=[hcp_B_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n hcp_dB=[hcp_dB_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n hcp_V0=[hcp_V0_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n hcp_E0=[hcp_E0_extrapol_props[x] for x in elements[\\\"symbol\\\"]],\\n type=elements[\\\"metal\\\"],\\n type_color=[ colormap[elems_colorpair[x]] for x in elements['symbol'] ],\\n )\\n )\\n\\n # plot the periodic layout\\n #name = source.data[\\\"name\\\"]\\n #B = source.data[\\\"B\\\"]\\n\\n ptable = figure(title=\\\"Periodic Table\\\", tools=\\\"hover\\\",\\n x_range=group_range, y_range=list(reversed(romans)))\\n ptable.background_fill_color='white'\\n ptable.plot_width = 1500\\n ptable.toolbar_location = None\\n ptable.outline_line_color = None\\n\\n ptable.rect(\\\"group\\\", \\\"period\\\", 0.9, 0.9, source=source,\\n fill_alpha=0.3, color='type_color')\\n\\n text_props = {\\n \\\"source\\\": source,\\n \\\"angle\\\": 0,\\n \\\"color\\\": \\\"black\\\",\\n \\\"text_align\\\": \\\"left\\\",\\n \\\"text_baseline\\\": \\\"middle\\\"\\n }\\n\\n ptable.text(x=\\\"symx\\\", y=\\\"period\\\", text=\\\"sym\\\",\\n text_font_style=\\\"bold\\\", text_font_size=\\\"22pt\\\", **text_props)\\n\\n ptable.text(x=\\\"symx\\\", y=\\\"numbery\\\", text=\\\"atomic_number\\\",\\n text_font_size=\\\"9pt\\\", **text_props)\\n\\n# ptable.text(x=\\\"symx\\\", y=\\\"namey\\\", text=\\\"name\\\",\\n# text_font_size=\\\"6pt\\\", **text_props)\\n\\n# ptable.text(x=\\\"symx\\\", y=\\\"massy\\\", text=\\\"mass\\\",\\n# text_font_size=\\\"5pt\\\", **text_props)\\n\\n ptable.grid.grid_line_color = None\\n\\n\\n ptable.select_one(HoverTool).tooltips = [\\n (\\\"name\\\", \\\"@name\\\"),\\n (\\\"fcc, V0 (A^3 per atom)\\\", \\\"@fcc_V0\\\"),\\n (\\\"fcc, B (GPa)\\\", \\\"@fcc_B\\\"),\\n (\\\"fcc, dB/dP\\\", \\\"@fcc_dB\\\"),\\n (\\\"bcc, V0 (A^3 per atom)\\\", \\\"@bcc_V0\\\"),\\n (\\\"bcc, B (GPa)\\\", \\\"@bcc_B\\\"),\\n (\\\"bcc, dB/dP\\\", \\\"@bcc_dB\\\"),\\n (\\\"hcp, V0 (A^3 per atom)\\\", \\\"@hcp_V0\\\"),\\n (\\\"hcp, B (GPa)\\\", \\\"@hcp_B\\\"),\\n (\\\"hcp, dB/dP\\\", \\\"@hcp_dB\\\")]\\n return ptable\",\n \"def _store_2D_coefficients(hdr, poly_model, coeff_prefix, keeplinear=False):\\n mindeg = int(not keeplinear)\\n degree = poly_model.degree\\n for i in range(0, degree + 1):\\n for j in range(0, degree + 1):\\n if (i + j) > mindeg and (i + j < degree + 1):\\n hdr[f'{coeff_prefix}_{i}_{j}'] = getattr(poly_model, f'c{i}_{j}').value\",\n \"def drawContourLine(xlist, ylist, level):\\n dislin.concrv(xlist, ylist, len(xlist), level)\",\n \"def _get_unstructured_collection(vlon, vlat, xm, vmin, vmax, basemap_object=None):\\n\\n #init\\n Path = mpath.Path\\n patches = []\\n pdata = xm[0, :] * 1. # full list of data\\n vmsk = np.ones_like(pdata).astype('bool') # mask to indicate which cells contain valid data\\n\\n for i in xrange(x.ncell):\\n if np.any(vlon[i, :]) > 180.: # todo fix this properly !!!\\n vmsk[i] = False\\n continue\\n if basemap_object is None:\\n xv = vlon[i, :]\\n yv = vlat[i, :]\\n else:\\n xv, yv = basemap_object(vlon[i, :], vlat[i, :]) # todo: how to properly deal with boundary problem ????\\n if (vlon[i, :].min() < -100.) & (vlon[i, :].max() > 100.): # todo\\n #... triangles across the boundaries of the projection are a problem\\n # ... solution: generate two triangles ! TODO\\n vmsk[i] = False\\n continue\\n\\n verts = np.asarray([xv, yv]).T\\n\\n #--- specify how vertices are interconnected (here simple connection by lines)\\n codes = [Path.MOVETO, Path.LINETO, Path.LINETO]\\n\\n #--- construct object and append to library of objects ---\\n path = mpath.Path(verts, codes, closed=True)\\n patches.append(mpatches.PathPatch(path))\\n\\n pdata = np.asarray(pdata)\\n\\n if vmin is None:\\n vmin = pdata.min()\\n if vmax is None:\\n vmax = pdata.max()\\n\\n norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)\\n collection = PatchCollection(patches, cmap=cmap, norm=norm, alpha=1., match_original=False, edgecolors='grey') # construct library of all objects\\n collection.set_array(pdata[vmsk]) # assign data values here\\n\\n return collection\",\n \"def plot_vor_boundary(self,x,ax,tri=False):\\n\\n x = x[~np.isnan(x[:,0])]\\n c_types_print = np.ones(x.shape[0],dtype=np.int32)*-1\\n c_types_print[:self.n_C] = self.c_types\\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(x))\\n\\n\\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\\n if type(self.c_types) is list:\\n # ax.scatter(x[:, 0], x[:, 1],color=\\\"grey\\\",zorder=1000)\\n for region in regions:\\n polygon = vertices[region]\\n plt.fill(*zip(*polygon), alpha=0.4, color=\\\"grey\\\")\\n\\n else:\\n cols = self.cols\\n patches = []\\n if self.plot_scatter is True:\\n ax.scatter(x[:self.n_C, 0], x[:self.n_C, 1], color=\\\"black\\\", zorder=1000)\\n ax.scatter(x[self.n_C:, 0], x[self.n_C:, 1], color=\\\"grey\\\", zorder=1000)\\n\\n for i, region in enumerate(regions):\\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],edgecolor=\\\"white\\\",alpha=0.5))\\n\\n p = PatchCollection(patches, match_original=True)\\n # p.set_array(c_types_print)\\n ax.add_collection(p)\\n if tri is not False:\\n for TRI in tri:\\n for j in range(3):\\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\\n if (a >= 0) and (b >= 0):\\n X = np.stack((x[a], x[b])).T\\n ax.plot(X[0], X[1], color=\\\"black\\\")\",\n \"def distance_from_boundaries(xy, boundaries, PVxydict, interp_n=None, check=False):\\n jj = 0\\n dists = []\\n # print 'dists = ', dists\\n # print 'boundaries = ', boundaries\\n null = np.array([0., 0.])\\n if not isinstance(boundaries, tuple):\\n if len(np.shape(boundaries)) > 1:\\n print 'boundaries = ', boundaries\\n print 'np.shape(boundaries) = ', np.shape(boundaries)\\n raise RuntimeError('assuming boundary has been stored as M x #boundaries array, where each boundary has '\\n + 'M elements, but it should be given as tuple or single array')\\n else:\\n boundary = tuple([boundaries])\\n\\n # If there is no periodicity, then make PVxydict an empty dict\\n if PVxydict is None:\\n PVxydict = {}\\n\\n for boundary in boundaries:\\n if interp_n is None:\\n boundarypts = xy[boundary]\\n else:\\n xb = []\\n yb = []\\n nn = len(boundary)\\n for ii in range(nn):\\n # Get periodic vector by which\\n if (ii, nn) in PVxydict:\\n pvii = PVxydict[(ii, nn)]\\n elif (nn, ii) in PVxydict:\\n pvii = - PVxydict[(nn, ii)]\\n else:\\n pvii = null\\n xb.append(np.linspace(xy[boundary[ii], 0],\\n xy[boundary[(ii + 1) % nn], 0] + pvii[0], interp_n + 2).tolist())\\n yb.append(np.linspace(xy[boundary[ii], 1],\\n xy[boundary[(ii + 1) % nn], 1] + pvii[1], interp_n + 2).tolist())\\n\\n xb = np.array(xb).ravel()\\n yb = np.array(yb).ravel()\\n if check:\\n print 'xnew = ', xb\\n print 'ynew = ', yb\\n plt.scatter(xb, yb, alpha=0.3, c='r')\\n plt.plot(xy[:, 0], xy[:, 1])\\n plt.show()\\n\\n boundarypts = np.dstack((xb, yb))[0]\\n\\n d_all = dh.dist_pts(xy, boundarypts)\\n # print 'd_all = ', d_all\\n dists.append(np.min(d_all, axis=1))\\n jj += 1\\n\\n return tuple(dists)\",\n \"def plot_figure11():\\n height_ceilings = [200., 300., 400.]\\n height_ceiling_ids = [list(height_range_ceilings).index(height_ceiling) for height_ceiling in height_ceilings]\\n\\n baseline_height_ceiling = 500.\\n baseline_height_ceiling_id = list(height_range_ceilings).index(baseline_height_ceiling)\\n\\n plot_item00 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[0], :, :],\\n 'contour_fill_levels': np.linspace(50, 100, 21),\\n 'contour_line_levels': [70., 80., 90., 95.],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(50, 100, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n 'extend': 'min',\\n }\\n plot_item01 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[1], :, :],\\n 'contour_fill_levels': np.linspace(70, 100, 21),\\n 'contour_line_levels': [70., 80., 90., 95.],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(70, 100, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n 'extend': 'min',\\n }\\n plot_item02 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[2], :, :],\\n 'contour_fill_levels': np.linspace(80, 100, 21),\\n 'contour_line_levels': [70., 80., 90., 95.],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(80, 100, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n 'extend': 'min',\\n }\\n\\n column_titles = [\\\"200 m\\\", \\\"300 m\\\", \\\"400 m\\\"]\\n plot_items = [plot_item00, plot_item01, plot_item02]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\\n\\n linspace10 = np.linspace(0., 11., 21)\\n plot_item10 = {\\n 'data': -(100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[0], :, :])+\\n (100.-nc.variables[\\\"p_ceiling_rank40\\\"][baseline_height_ceiling_id, :, :]),\\n 'contour_fill_levels': linspace10,\\n 'contour_line_levels': sorted([1.1]+list(linspace10[::4])),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': linspace10[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability decrease [%]',\\n }\\n linspace11 = np.linspace(0., 23., 21)\\n plot_item11 = {\\n 'data': (100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[1], :, :])-\\n (100.-nc.variables[\\\"p_ceiling_rank40\\\"][baseline_height_ceiling_id, :, :]),\\n 'contour_fill_levels': linspace11,\\n 'contour_line_levels': sorted([2.3]+list(linspace11[::4])),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': linspace11[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability increase [%]',\\n }\\n linspace12 = np.linspace(0., 38., 21)\\n plot_item12 = {\\n 'data': (100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[2], :, :])-\\n (100.-nc.variables[\\\"p_ceiling_rank40\\\"][baseline_height_ceiling_id, :, :]),\\n 'contour_fill_levels': linspace12,\\n 'contour_line_levels': sorted([3.8]+list(linspace12[::4])),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': linspace12[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability increase [%]',\\n }\\n\\n column_titles = None\\n plot_items = [plot_item10, plot_item11, plot_item12]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\",\n \"def fun_contours(self, params):\\n shape_coeffs = params[:self.num_shape_params]\\n blendshape_end = self.num_shape_params + self.numObservations * self.num_blendshape_params\\n blendshape_coeffs = params[self.num_shape_params:blendshape_end].reshape((self.numObservations, self.num_blendshape_params))\\n trans_mats = params[blendshape_end:].reshape((self.numObservations, 7))\\n\\n vertices3d = self.vertices3d\\n vertices3d_from_mesh = np.zeros_like(vertices3d)\\n vertices3d_inner, vertices3d_right, vertices3d_left = self.transform_meshes(shape_coeffs, blendshape_coeffs, trans_mats)\\n\\n inner_idx = 0\\n for idx in range(vertices3d.shape[0]):\\n lm_idx = idx % 66\\n obs_num = int(np.floor(idx/66))\\n\\n if lm_idx in self.contour_lms_list[0]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_right[obs_num])\\n elif lm_idx in self.contour_lms_list[1]:\\n vertices3d_from_mesh[idx] = self.find_closest_vertex3D(vertices3d[idx],\\n vertices3d_left[obs_num])\\n else:\\n vertices3d_from_mesh[idx] = vertices3d_inner[obs_num][inner_idx]\\n inner_idx += 1\\n if inner_idx == 50:\\n inner_idx = 0\\n\\n return (vertices3d_from_mesh - vertices3d).ravel()\",\n \"def PVxydict2PV(PVxydict, check=False, periodic_strip=False):\\n # Make a flattened list of periodic vectors so that all elements are 2 x 1\\n pvlist = []\\n for key in PVxydict:\\n tmp = PVxydict[key]\\n if len(np.shape(tmp)) == 1:\\n pvlist.append(tmp)\\n else:\\n for row in tmp:\\n pvlist.append(row)\\n\\n if check:\\n print 'le: pvlist = ', pvlist\\n pvarr = np.array(pvlist)\\n pvs = dh.unique_rows(pvarr)\\n if check:\\n print 'le: pvs = ', pvs\\n if len(pvs) > 0:\\n print 'le: pvs = ', pvs\\n if (pvs[:, 1] < 0).all():\\n pvs[:, 1] = -pvs[:, 1]\\n\\n minax = np.argmin(np.abs(pvs[:, 0]))\\n minay = np.argmin(np.abs(pvs[:, 1]))\\n # Order the vectors by x-dominant, y-dominant, with both dominant vector components > 0, ie\\n # PV -> [[+Lx, small], [small, +Ly]]\\n if (pvs[:, 1] == pvs[0, 1]).all() and not periodic_strip:\\n print 'le.PVxydict2PV: two lattice vecs have the same Y value, adding them together...'\\n maxx = np.argmax(pvs[:, 0])\\n other = np.setdiff1d([0, 1], [maxx])\\n pvnew = pvs[maxx] - pvs[other]\\n PV = np.vstack((pvnew, pvs[maxx]))\\n print 'le.PVxydict2PV: PV = ', PV\\n elif not periodic_strip:\\n if minax != minay:\\n PV = np.vstack((pvs[minax], pvs[minay]))\\n else:\\n if minay == 0:\\n other = 1\\n else:\\n other = 0\\n PV = np.vstack((pvs[minay], pvs[other]))\\n else:\\n print 'le.PVxydict2PV: since periodic_strip, returning single 1 x 2 PV array'\\n PV = pvs\\n\\n if check:\\n print 'le.PVxydict2PV: PV = ', PV\\n else:\\n print 'le: No periodic vectors found, returning empty PV array'\\n PV = pvs\\n\\n print 'le: PVxydict2PV: returning PV'\\n return PV\",\n \"def surface_contacts(struc,SASA):\\n\\tplot_single = False\\n\\n\\tcmap_cutoff = 5.0 # nm\\n\\tsasa_cutoff = 0.5\\n\\t# identify surface residues\\n\\tS = []\\n\\tN = np.array(range(struc.n_residues))\\n\\tfor r in N:\\n\\t\\tind = struc.topology.select('resid '+str(r))\\n\\t\\tSASA_per_res = np.sum(SASA[0][ind[0]:ind[-1]],axis=0)\\n\\t\\tif SASA_per_res > sasa_cutoff:\\n\\t\\t\\tS.append(SASA_per_res)\\n\\t\\telse:\\n\\t\\t\\tS.append(0.0)\\n\\t#import ipdb; ipdb.set_trace()\\n\\tsurf_res = N[np.where(np.array(S) > 0)]\\n\\tcmap = contact_maps(struc.atom_slice(struc.topology.select('name CA'))[0].xyz[0])\\n\\tfor n in N:\\n\\t\\tfor m in N:\\n\\t\\t\\tif (n not in surf_res or m not in surf_res) or n < m:\\n\\t\\t\\t\\tcmap[n][m] = 0\\n\\t\\t\\telif cmap[n][m] < cmap_cutoff:\\n\\t\\t\\t\\tcmap[n][m] = 1\\n\\tif plot_single == True:\\n\\t\\tfor it,rn in enumerate(resnames):\\n\\t\\t\\tif rn in hydrophobic:\\n\\t\\t\\t\\tplt.axhline(y=it,c='grey',linewidth=2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='grey',linewidth=2)\\n\\t\\t\\telif rn in hydrophilic:\\n\\t\\t\\t\\tplt.axhline(y=it,c='g',linewidth= 2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='g',linewidth= 2)\\n\\t\\t\\telif rn in poscharge:\\n\\t\\t\\t\\tplt.axhline(y=it,c='b',linewidth= 2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='b',linewidth= 2)\\n\\t\\t\\telif rn in negcharge:\\n\\t\\t\\t\\tplt.axhline(y=it,c='r',linewidth= 2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='r',linewidth= 2)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"unknown restype:\\\", rn\\n\\t\\tscat = np.array(zip(np.where(np.array(cmap) > 0)[0], np.where(np.array(cmap) > 0)[1])).T\\n\\t\\tplt.scatter(scat[0], scat[1],marker='s',c='k',s=90)\\n\\t\\t#plt.imshow(cmap,cmap='Greys')\\n\\t\\tplt.show()\\n\\treturn cmap\",\n \"def get_ptsByCntByRoi(rts, sopuids, p2c=False):\\n \\n # Get the ContourSequence-to-slice indices by ROI:\\n c2sIndsByRoi, c2sInds = get_c2sIndsByRoi(rts, sopuids)\\n \\n numRois = len(c2sIndsByRoi)\\n \\n if p2c:\\n print('\\\\n\\\\n', '-'*120)\\n print('Running of get_ptsByCntByRoi():')\\n print('\\\\n\\\\n', '-'*120)\\n #print(f' c2sIndsByRoi = {c2sIndsByRoi}')\\n print_indsByRoi(c2sIndsByRoi)\\n print(f'numRois = {numRois}')\\n \\n ptsByCntByRoi = []\\n \\n for r in range(numRois):\\n # Number of contours in this ROI:\\n numCnts = len(c2sIndsByRoi[r])\\n \\n # Get a list of the ContourSequences in this ROI:\\n #sequences = deepcopy(rts.ROIContourSequence[r].ContourSequence)\\n sequences = list(rts.ROIContourSequence[r].ContourSequence)\\n \\n # Get a list of all ReferencedSOPInstanceUIDs from ContourSequences:\\n #RefSopUids = [sequence.ContourImageSequence[0]\\\\\\n # .ReferencedSOPInstanceUID for sequence in ContourSequences]\\n \\n if False:#p2c:\\n print(f' r = {r}')\\n print(f' numCnts = {numCnts}')\\n print(f' number of Contour Sequences = {len(sequences)}')\\n \\n ptsByCnt = []\\n \\n # Loop through each contour sequence:\\n for c in range(len(sequences)):\\n # Get the indices of all matching RefSopUids:\\n #ind = RefSopUids.index(SopUid) # this will only find the first \\n # match, and there may be more than one!\\n #inds = [i for i, e in enumerate(RefSopUids) if e==SopUid]\\n \\n # Iterate for each index in inds:\\n #for ind in inds:\\n \\n #ContourSequence = deepcopy(ContourSequences[c])\\n \\n #ContourData = [float(item) for item in ContourSequence.ContourData]\\n \\n #cntData = deepcopy(sequence.ContourData)\\n cntData = list(sequences[c].ContourData)\\n \\n pts = cntdata_to_pts(cntData)\\n \\n ptsByCnt.append(pts)\\n \\n if False:#p2c:\\n print(f' c = {c}')\\n print(f' len(pts) = {len(pts)}')\\n \\n ptsByCntByRoi.append(ptsByCnt)\\n \\n cntdataByCntByRoi = ptsByCntByRoi_to_cntdataByCntByRoi(\\n ptsByCntByRoi\\n )\\n \\n if p2c:\\n #R = len(ptsByCntByRoi)\\n #print(f'\\\\n len(ptsByCntByRoi) = {R}')\\n #for r in range(R):\\n # print(f' len(ptsByCntByRoi[{r}]) = {len(ptsByCntByRoi[r])}')\\n print_ptsByCntByRoi(ptsByCntByRoi)\\n print('-'*120)\\n\\n return ptsByCntByRoi, cntdataByCntByRoi, c2sIndsByRoi, c2sInds\",\n \"def loess(xvals, yvals, alpha, poly_degree=1):\\r\\n # Sort dataset by xvals.\\r\\n all_data = sorted(zip(xvals, yvals), key=lambda x: x[0])\\r\\n xvals, yvals = zip(*all_data)\\r\\n\\r\\n locsDF = pd.DataFrame(\\r\\n columns=[\\r\\n 'loc','x','weights','v','y','raw_dists',\\r\\n 'scale_factor','scaled_dists'\\r\\n ])\\r\\n evalDF = pd.DataFrame(\\r\\n columns=[\\r\\n 'loc','est','b','v','g'\\r\\n ])\\r\\n\\r\\n n = len(xvals)\\r\\n m = n + 1\\r\\n q = int(np.floor(n * alpha) if alpha <= 1.0 else n)\\r\\n avg_interval = ((max(xvals)-min(xvals))/len(xvals))\\r\\n v_lb = max(0,min(xvals)-(.5*avg_interval))\\r\\n v_ub = (max(xvals)+(.5*avg_interval))\\r\\n v = enumerate(np.linspace(start=v_lb, stop=v_ub, num=m), start=1)\\r\\n #print('liste v=', list(v))\\r\\n # Generate design matrix based on poly_degree.\\r\\n xcols = [np.ones_like(xvals)]\\r\\n for j in range(1, (poly_degree + 1)):\\r\\n xcols.append([i ** j for i in xvals])\\r\\n X = np.vstack(xcols).T\\r\\n\\r\\n\\r\\n for i in v:\\r\\n\\r\\n print('i=', i) #pour voir à quelle vitesse cela défile.\\r\\n iterpos = i[0]\\r\\n iterval = i[1]\\r\\n\\r\\n # Determine q-nearest xvals to iterval.\\r\\n iterdists = sorted([(j, np.abs(j-iterval)) \\\\\\r\\n for j in xvals], key=lambda x: x[1])\\r\\n\\r\\n _, raw_dists = zip(*iterdists)\\r\\n\\r\\n # Scale local observations by qth-nearest raw_dist.\\r\\n scale_fact = raw_dists[q-1]\\r\\n scaled_dists = [(j[0],(j[1]/scale_fact)) for j in iterdists]\\r\\n weights = [(j[0],((1-np.abs(j[1]**3))**3 \\\\\\r\\n if j[1]<=1 else 0)) for j in scaled_dists]\\r\\n\\r\\n # Remove xvals from each tuple:\\r\\n _, weights = zip(*sorted(weights, key=lambda x: x[0]))\\r\\n _, raw_dists = zip(*sorted(iterdists, key=lambda x: x[0]))\\r\\n _, scaled_dists = zip(*sorted(scaled_dists,key=lambda x: x[0]))\\r\\n\\r\\n iterDF1 = pd.DataFrame({\\r\\n 'loc' :iterpos,\\r\\n 'x' :xvals,\\r\\n 'v' :iterval,\\r\\n 'weights' :weights,\\r\\n 'y' :yvals,\\r\\n 'raw_dists' :raw_dists,\\r\\n 'scale_fact' :scale_fact,\\r\\n 'scaled_dists':scaled_dists\\r\\n })\\r\\n\\r\\n locsDF = pd.concat([locsDF, iterDF1])\\r\\n W = np.diag(weights)\\r\\n y = yvals\\r\\n b = np.linalg.inv(X.T @ W @ X) @ (X.T @ W @ y)\\r\\n local_est = loc_eval(iterval, b)\\r\\n iterDF2 = pd.DataFrame({\\r\\n 'loc':[iterpos],\\r\\n 'b' :[b],\\r\\n 'v' :[iterval],\\r\\n 'g' :[local_est]\\r\\n })\\r\\n\\r\\n evalDF = pd.concat([evalDF, iterDF2])\\r\\n\\r\\n # Reset indicies for returned DataFrames.\\r\\n locsDF.reset_index(inplace=True)\\r\\n locsDF.drop('index', axis=1, inplace=True)\\r\\n locsDF['est'] = 0; evalDF['est'] = 0\\r\\n locsDF = locsDF[['loc','est','v','x','y','raw_dists',\\r\\n 'scale_fact','scaled_dists','weights']]\\r\\n\\r\\n # Reset index for evalDF.\\r\\n evalDF.reset_index(inplace=True)\\r\\n evalDF.drop('index', axis=1, inplace=True)\\r\\n evalDF = evalDF[['loc','est', 'v', 'b', 'g']]\\r\\n\\r\\n return(locsDF, evalDF)\",\n \"def trackCells(self): \\n # variable initialization\\n self.t_appearance = []\\n self.id_seq = []\\n self._n_cell = 0\\n self.division = []\\n self.dict_track = {}\\n\\n t_ini = self.configs[self.TIME_INI_KEY]\\n\\n # Initialize points with first frame\\n self.dict_track[0] = {}\\n for id_num in self.pos[0][4]:\\n self._addTrack(0, id_num)\\n\\n # From frame=1 on...\\n for t, data_t in enumerate(self.pos[1:]):\\n self.dict_track[t+1] = {}\\n # check all the cells in this frame\\n for cell, id_num in enumerate(data_t[4]):\\n parent = data_t[5][cell]\\n if parent == -1:\\n # new track\\n self._addTrack(t+1, id_num)\\n elif parent in self.dict_track[t]:\\n # check if parent is in the previous list\\n index = self.dict_track[t][parent]\\n if index in self.dict_track[t+1].values():\\n # then we have cell division, and we monitor the child separarely\\n self._addDivision(t+1, id_num, index)\\n else:\\n # cell continues in the same track\\n self.id_seq[index].append(id_num)\\n self.dict_track[t+1][id_num] = index\\n else:\\n # weird things happened!\\n print(\\\"Warning! Time %s, Cell ID %s lost track\\\"%(str(t+t_ini), str(id_num)))\\n\\n\\n # all track indexes are included, no filter (yet)\\n self.index_filter = list(range(len(self.id_seq)))\\n\\n return self.id_seq, self.t_appearance\",\n \"def contours(subject, colour='gray'):\\n for row in data.get_contours(subject)['contours']:\\n for col in row:\\n xs = []\\n ys = []\\n for pair in col['arr']:\\n xs.append(pair['x'])\\n ys.append(pair['y'])\\n ys = config['surveys']['atlas']['fits_height'] - numpy.array(ys)\\n matplotlib.pyplot.plot(xs, ys, c=colour)\",\n \"def _calc_coords(self, X, Y, Z):\\r\\n def _write_coords(coord):\\r\\n XX.append(X[coord])\\r\\n YY.append(Y[coord])\\r\\n ZZ.append(Z[coord])\\r\\n\\r\\n def _build_layer():\\r\\n for j in range(self.size[1]):\\r\\n for i in range(self.size[0]):\\r\\n # write NW corner\\r\\n if i == 0:\\r\\n nwCoord = 2 * i + 4 * self.size[0] * j + const\\r\\n _write_coords(nwCoord)\\r\\n # write NE corner\\r\\n neCoord = 2 * i + 4 * self.size[0] * j + const + 1\\r\\n _write_coords(neCoord)\\r\\n if j == self.size[1] - 1:\\r\\n for i in range(self.size[0]):\\r\\n # write SW corner\\r\\n if i == 0:\\r\\n swCoord = 2 * i + 4 * self.size[0] * j + 2 * self.size[0] + const\\r\\n _write_coords(swCoord)\\r\\n # write SE corner\\r\\n seCoord = 2 * i + 4 * self.size[0] * j + 2 * self.size[0] + const + 1\\r\\n _write_coords(seCoord)\\r\\n\\r\\n # At this point, we have all points needed for unstructured grid in X,Y,Z\\r\\n # However, they must be re-arranged so we can define Hexahedrons\\r\\n # TODO: REFINE CELLS\\r\\n # PSUEDO:\\r\\n # find cell to be refined\\r\\n # add new cells (as easy as pie)\\r\\n\\r\\n XX, YY, ZZ = ([] for i in range(3))\\r\\n const = 0\\r\\n for k in range(self.size[2]):\\r\\n _build_layer()\\r\\n if k == self.size[2] - 1:\\r\\n const += self.size[0] * self.size[1] * 4\\r\\n _build_layer()\\r\\n break\\r\\n else:\\r\\n const += self.size[0] * self.size[1] * 8\\r\\n return XX, YY, ZZ\",\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 trapezoid_decomposition_linear(polygons):\\n # Enumerate all the edges and iteratively build up the set of trapezoids\\n # Add a vertical line for each point in the polygon\\n all_polygons = np.concatenate(polygons, axis=0)\\n vertical_lines = SortedDict({x[0]: [x[1], 1000000, 0] for x in all_polygons})\\n\\n # Loop over Polygons to determine end-points\\n for polygon in polygons:\\n start_vertex = polygon[0]\\n for vertex in polygon[1:]:\\n # find the lines in front of the smaller \\n x_start = start_vertex[0]\\n x_curr = vertex[0]\\n start_idx = vertical_lines.bisect_right(min(x_start, x_curr))\\n end_idx = vertical_lines.bisect_left(max(x_start, x_curr))\\n x_vals = vertical_lines.keys()\\n for i in range(start_idx, end_idx):\\n x = x_vals[i]\\n if x < min(x_start, x_curr) or x > max(x_start, x_curr):\\n continue\\n y, top, bottom = vertical_lines[x]\\n y_val = linear_interpolation(start_vertex, vertex, x)\\n if y_val > y and y_val < top:\\n vertical_lines[x][1] = y_val\\n elif y_val < y and y_val > bottom:\\n vertical_lines[x][2] = y_val\\n start_vertex = vertex\\n return vertical_lines\",\n \"def RegularPolygonPoints(n,c):\\n coord = []\\n for i in range(n):\\n x = m.cos(2*m.pi*i/n)+c[0]\\n y = m.sin(2*m.pi*i/n)+c[1]\\n coord.append([x,y])\\n return(coord)\",\n \"def plot2Ddata(\\n xyz,\\n data,\\n vec=False,\\n nx=100,\\n ny=100,\\n ax=None,\\n mask=None,\\n level=False,\\n figname=None,\\n ncontour=10,\\n dataloc=False,\\n contourOpts={},\\n levelOpts={},\\n streamplotOpts={},\\n scale=\\\"linear\\\",\\n clim=None,\\n method=\\\"linear\\\",\\n shade=False,\\n shade_ncontour=100,\\n shade_azimuth=-45.0,\\n shade_angle_altitude=45.0,\\n shadeOpts={},\\n):\\n\\n # Error checking and set vmin, vmax\\n vlimits = [None, None]\\n\\n if clim is not None:\\n vlimits = [np.min(clim), np.max(clim)]\\n\\n for i, key in enumerate([\\\"vmin\\\", \\\"vmax\\\"]):\\n if key in contourOpts.keys():\\n if vlimits[i] is None:\\n vlimits[i] = contourOpts.pop(key)\\n else:\\n if not np.isclose(contourOpts[key], vlimits[i]):\\n raise Exception(\\n \\\"The values provided in the colorbar limit, clim {} \\\"\\n \\\"does not match the value of {} provided in the \\\"\\n \\\"contourOpts: {}. Only one value should be provided or \\\"\\n \\\"the two values must be equal.\\\".format(\\n vlimits[i], key, contourOpts[key]\\n )\\n )\\n contourOpts.pop(key)\\n vmin, vmax = vlimits[0], vlimits[1]\\n\\n # create a figure if it doesn't exist\\n if ax is None:\\n fig = plt.figure()\\n ax = plt.subplot(111)\\n\\n # interpolate data to grid locations\\n xmin, xmax = xyz[:, 0].min(), xyz[:, 0].max()\\n ymin, ymax = xyz[:, 1].min(), xyz[:, 1].max()\\n x = np.linspace(xmin, xmax, nx)\\n y = np.linspace(ymin, ymax, ny)\\n X, Y = np.meshgrid(x, y)\\n xy = np.c_[X.flatten(), Y.flatten()]\\n\\n if vec is False:\\n if method == \\\"nearest\\\":\\n F = NearestNDInterpolator(xyz[:, :2], data)\\n else:\\n F = LinearNDInterpolator(xyz[:, :2], data)\\n DATA = F(xy)\\n DATA = DATA.reshape(X.shape)\\n\\n # Levels definitions\\n dataselection = np.logical_and(~np.isnan(DATA), np.abs(DATA) != np.inf)\\n if scale == \\\"log\\\":\\n DATA = np.abs(DATA)\\n\\n # set vmin, vmax if they are not already set\\n vmin = DATA[dataselection].min() if vmin is None else vmin\\n vmax = DATA[dataselection].max() if vmax is None else vmax\\n\\n if scale == \\\"log\\\":\\n levels = np.logspace(np.log10(vmin), np.log10(vmax), ncontour + 1)\\n norm = colors.LogNorm(vmin=vmin, vmax=vmax)\\n else:\\n levels = np.linspace(vmin, vmax, ncontour + 1)\\n norm = colors.Normalize(vmin=vmin, vmax=vmax)\\n\\n if mask is not None:\\n Fmask = NearestNDInterpolator(xyz[:, :2], mask)\\n MASK = Fmask(xy)\\n MASK = MASK.reshape(X.shape)\\n DATA = np.ma.masked_array(DATA, mask=MASK)\\n\\n contourOpts = {\\\"levels\\\": levels, \\\"norm\\\": norm, \\\"zorder\\\": 1, **contourOpts}\\n cont = ax.contourf(X, Y, DATA, **contourOpts)\\n\\n if level:\\n levelOpts = {\\\"levels\\\": levels, \\\"zorder\\\": 3, **levelOpts}\\n CS = ax.contour(X, Y, DATA, **levelOpts)\\n\\n else:\\n # Assume size of data is (N,2)\\n datax = data[:, 0]\\n datay = data[:, 1]\\n if method == \\\"nearest\\\":\\n Fx = NearestNDInterpolator(xyz[:, :2], datax)\\n Fy = NearestNDInterpolator(xyz[:, :2], datay)\\n else:\\n Fx = LinearNDInterpolator(xyz[:, :2], datax)\\n Fy = LinearNDInterpolator(xyz[:, :2], datay)\\n DATAx = Fx(xy)\\n DATAy = Fy(xy)\\n DATA = np.sqrt(DATAx ** 2 + DATAy ** 2).reshape(X.shape)\\n DATAx = DATAx.reshape(X.shape)\\n DATAy = DATAy.reshape(X.shape)\\n if scale == \\\"log\\\":\\n DATA = np.abs(DATA)\\n\\n # Levels definitions\\n dataselection = np.logical_and(~np.isnan(DATA), np.abs(DATA) != np.inf)\\n\\n # set vmin, vmax\\n vmin = DATA[dataselection].min() if vmin is None else vmin\\n vmax = DATA[dataselection].max() if vmax is None else vmax\\n\\n if scale == \\\"log\\\":\\n levels = np.logspace(np.log10(vmin), np.log10(vmax), ncontour + 1)\\n norm = colors.LogNorm(vmin=vmin, vmax=vmax)\\n else:\\n levels = np.linspace(vmin, vmax, ncontour + 1)\\n norm = colors.Normalize(vmin=vmin, vmax=vmax)\\n\\n if mask is not None:\\n Fmask = NearestNDInterpolator(xyz[:, :2], mask)\\n MASK = Fmask(xy)\\n MASK = MASK.reshape(X.shape)\\n DATA = np.ma.masked_array(DATA, mask=MASK)\\n\\n contourOpts = {\\\"levels\\\": levels, \\\"norm\\\": norm, \\\"zorder\\\": 1, **contourOpts}\\n cont = ax.contourf(X, Y, DATA, **contourOpts)\\n\\n streamplotOpts = {\\\"zorder\\\": 4, \\\"color\\\": \\\"w\\\", **streamplotOpts}\\n ax.streamplot(X, Y, DATAx, DATAy, **streamplotOpts)\\n\\n if level:\\n levelOpts = {\\\"levels\\\": levels, \\\"zorder\\\": 3, **levelOpts}\\n CS = ax.contour(X, Y, DATA, levels=levels, zorder=3, **levelOpts)\\n\\n if shade:\\n\\n def hillshade(array, azimuth, angle_altitude):\\n \\\"\\\"\\\"\\n coded copied from https://www.neonscience.org/create-hillshade-py\\n \\\"\\\"\\\"\\n azimuth = 360.0 - azimuth\\n x, y = np.gradient(array)\\n slope = np.pi / 2.0 - np.arctan(np.sqrt(x * x + y * y))\\n aspect = np.arctan2(-x, y)\\n azimuthrad = azimuth * np.pi / 180.0\\n altituderad = angle_altitude * np.pi / 180.0\\n shaded = np.sin(altituderad) * np.sin(slope) + np.cos(altituderad) * np.cos(\\n slope\\n ) * np.cos((azimuthrad - np.pi / 2.0) - aspect)\\n return 255 * (shaded + 1) / 2\\n\\n shadeOpts = {\\n \\\"cmap\\\": \\\"Greys\\\",\\n \\\"alpha\\\": 0.35,\\n \\\"antialiased\\\": True,\\n \\\"zorder\\\": 2,\\n **shadeOpts,\\n }\\n\\n ax.contourf(\\n X,\\n Y,\\n hillshade(DATA, shade_azimuth, shade_angle_altitude),\\n shade_ncontour,\\n **shadeOpts\\n )\\n\\n if dataloc:\\n ax.plot(xyz[:, 0], xyz[:, 1], \\\"k.\\\", ms=2)\\n ax.set_aspect(\\\"equal\\\", adjustable=\\\"box\\\")\\n if figname:\\n plt.axis(\\\"off\\\")\\n fig.savefig(figname, dpi=200)\\n if level:\\n return cont, ax, CS\\n else:\\n return cont, ax\",\n \"def getContourListByDic(groupDic):\\n\\tcontourList = []\\n\\n\\tfor glyph in groupDic.keys():\\n\\t\\tfor idx in groupDic[glyph]:\\n\\t\\t\\tcontourList.append(glyph.contours[idx])\\n\\n\\treturn contourList\",\n \"def save_contour(fname, cs, fmt = 'matlab', simplify = 1e-3, **kwargs):\\n\\n\\tdef write_path_matlab(fout, x_vec, y_vec, z):\\n\\t\\t# Now dump this data back out\\n\\t\\t# Header is level followed by number of rows\\n\\t\\tfout.write('%15.15e\\\\t%15d\\\\n' % (z, len(x_vec)))\\n\\t\\tfor x, y in zip(x_vec, y_vec):\\n\\t\\t\\tfout.write(\\\"%15.15e\\\\t%15.15e\\\\n\\\" % (x,y))\\n\\n\\tdef write_path_prepared(fout, x_vec, y_vec, z):\\n\\t\\tfout.write(\\\"%15.15e\\\\t%15.15e\\\\t%15.15e\\\\n\\\" % (x0,y0,z))\\n\\t\\tfout.write(\\\"\\\\t\\\\t\\\\t\\\\n\\\")\\n\\n\\tif fmt == 'matlab':\\n\\t\\twrite_path = write_path_matlab\\n\\telif fmt == 'prepared':\\n\\t\\twrite_path = write_path_prepared\\n\\telse:\\n\\t\\traise NotImplementedError\\n\\n\\twith open(fname, 'w') as fout:\\n\\t\\tfor col, z in zip(cs.collections, cs.levels):\\n\\t\\t\\tfor path in col.get_paths():\\n\\t\\t\\t\\tpath.simplify_threshold = simplify\\n\\t\\t\\t\\tx_vec = []\\n\\t\\t\\t\\ty_vec = []\\n\\t\\t\\t\\tfor i, ((x,y), code) in enumerate(path.iter_segments(simplify = True)):\\n\\t\\t\\t\\t\\tif code == Path.MOVETO:\\n\\t\\t\\t\\t\\t\\tif len(x_vec) !=0:\\n\\t\\t\\t\\t\\t\\t\\twrite_path(fout, x_vec, y_vec, z)\\n\\t\\t\\t\\t\\t\\t\\tx_vec = []\\n\\t\\t\\t\\t\\t\\t\\ty_vec = []\\n\\t\\t\\t\\t\\t\\tx_vec.append(x)\\n\\t\\t\\t\\t\\t\\ty_vec.append(y)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\telif code == Path.LINETO:\\n\\t\\t\\t\\t\\t\\tx_vec.append(x)\\n\\t\\t\\t\\t\\t\\ty_vec.append(y)\\n\\n\\t\\t\\t\\t\\telif code == Path.CLOSEPOLY:\\n\\t\\t\\t\\t\\t\\tx_vec.append(x_vec[0])\\n\\t\\t\\t\\t\\t\\ty_vec.append(y_vec[0])\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tprint(\\\"received code\\\", code)\\n\\n\\t\\t\\t\\twrite_path(fout, x_vec, y_vec, z)\",\n \"def colorToBeads(clidx, filament_list, color, part_list_x, part_list_y, part_list_phi):\\n cl_beads_x = []\\n cl_beads_y = []\\n cl_beads_p = []\\n for i in filament_list:\\n for j in range(N):\\n ind = int(i*N+j)\\n clidx[ind] = color\\n cl_beads_x.append(part_list_x[ind])\\n cl_beads_y.append(part_list_y[ind])\\n cl_beads_p.append(part_list_phi[ind])\\n \\n xmin = min(cl_beads_x)\\n ymin = min(cl_beads_y)\\n xmax = max(cl_beads_x)\\n ymax = max(cl_beads_y)\\n \\n flag = False\\n x_span = xmax-xmin\\n y_span = ymax-ymin\\n if x_span > Lx/2:\\n flag = True\\n elif y_span > Ly/2:\\n flag = True\\n \\n return cl_beads_x, cl_beads_y, cl_beads_p, xmin, xmax, ymin, ymax, flag\",\n \"def get_interpolated_contours(contours_grouped_by_pos, len_interval, level_interval=1):\\n\\n contours_grouped_by_adjusted_pos = {}\\n for i, (pos, contour) in enumerate(sorted(contours_grouped_by_pos.iteritems())):\\n if i == 0:\\n contours_grouped_by_adjusted_pos[int(np.ceil(pos))] = contour\\n elif i == len(contours_grouped_by_pos)-1:\\n contours_grouped_by_adjusted_pos[int(np.floor(pos))] = contour\\n else:\\n contours_grouped_by_adjusted_pos[int(np.round(pos))] = contour\\n\\n zs = sorted(contours_grouped_by_adjusted_pos.keys())\\n n = len(zs)\\n\\n interpolated_contours = {}\\n\\n for i in range(n):\\n z0 = zs[i]\\n interpolated_contours[z0] = np.array(contours_grouped_by_adjusted_pos[z0])\\n if i + 1 < n:\\n z1 = zs[i+1]\\n interp_cnts = interpolate_contours(contours_grouped_by_adjusted_pos[z0], contours_grouped_by_adjusted_pos[z1], nlevels=z1-z0+1, len_interval_0=len_interval)\\n for zi, z in enumerate(range(z0+1, z1)):\\n interpolated_contours[z] = interp_cnts[zi+1]\\n\\n return interpolated_contours\",\n \"def build_coeff_dict(l):\\n coeff_dict = {}\\n for triplet in l:\\n coeff_dict[triplet[0]] = triplet[2]\\n return coeff_dict\",\n \"def add_other_contours(self, xlabel, ylabel):\\n import matplotlib.pyplot as plt\\n plt.rcParams['text.usetex'] = True\\n for contour_dict in self.contour_dicts:\\n if (xlabel in contour_dict['vars']) and \\\\\\n (ylabel in contour_dict['vars']):\\n if isinstance(contour_dict['contour'], dict):\\n for i, ckey in enumerate(contour_dict['contour'].keys()):\\n self.make_other_contour(\\n contour_vals=contour_dict['contour'][ckey],\\n xlabel=xlabel,\\n ylabel=ylabel,\\n contour_dict=contour_dict,\\n do_label=i\\n )\\n else:\\n self.make_other_contour(\\n contour_vals=contour_dict['contour'],\\n xlabel=xlabel,\\n ylabel=ylabel,\\n contour_dict=contour_dict,\\n do_label=1\\n )\",\n \"def m1_make_lower_shape_points_list(tx, ty, m1_info, SEN_info):\\n \\\"\\\"\\\"\\n 1 Get information from m1_info & SEN_info\\n \\\"\\\"\\\"\\n x_m1 = m1_info[0]\\n y_m1 = m1_info[1]\\n z_m = m1_info[2]\\n\\n m1_points = m1_info[3]\\n\\n m1_p0 = m1_points[0]\\n m1_p1 = m1_points[1]\\n m1_p2 = m1_points[2]\\n m1_p3 = m1_points[3]\\n\\n w_sen = SEN_info[0]\\n n_w_sen = SEN_info[1]\\n h_sen = SEN_info[2]\\n t_sen = SEN_info[3]\\n u_n = SEN_info[4]\\n l_n = SEN_info[5]\\n set = SEN_info[6]\\n u_offset = SEN_info[7]\\n l_offset = SEN_info[8]\\n\\n \\\"\\\"\\\"\\n 2 Make lists.\\n lower_shape_upper_left_row list\\n lower_shape_upper_right_row list\\n\\n lower_shape_lower_left_row list\\n lower_shape_lower_right_row list\\n \\\"\\\"\\\"\\n # upper side\\n lower_shape_upper_left_row = []\\n lower_shape_upper_right_row = []\\n\\n for i in range(u_n):\\n # left row\\n ix = tx + t_sen\\n iy = ty + (i * u_offset + set) + 10\\n\\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n left_points = [p4, p3, p2, p1, p8, p7, p6, p5]\\n lower_shape_upper_left_row.extend((left_points))\\n\\n for i in range(u_n - 1, -1, -1):\\n # right row\\n ix = tx + (x_m1 - t_sen)\\n iy = ty + (i * u_offset + set) + 10\\n\\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n right_points = [p8, p7, p6, p5, p4, p3, p2, p1]\\n lower_shape_upper_right_row.extend(right_points)\\n\\n # lower side\\n lower_shape_lower_left_row = []\\n lower_shape_lower_right_row = []\\n\\n for i in range(l_n - 1, -1, -1):\\n # left row\\n ix = tx + t_sen\\n iy = ty - (i * l_offset + set) - 10\\n\\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n left_points = [p4, p3, p2, p1, p8, p7, p6, p5]\\n lower_shape_lower_left_row.extend((left_points))\\n\\n for i in range(l_n):\\n # right row\\n ix = tx + (x_m1 - t_sen)\\n iy = ty - (i * l_offset + set) - 10\\n\\n p0, p1, p2, p3, p4, p5, p6, p7, p8 = Y_lower_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n right_points = [p8, p7, p6, p5, p4, p3, p2, p1]\\n lower_shape_lower_right_row.extend(right_points)\\n\\n lower_shape_upper = [lower_shape_upper_left_row, lower_shape_upper_right_row]\\n lower_shape_lower = [lower_shape_lower_left_row, lower_shape_lower_right_row]\\n\\n return lower_shape_upper, lower_shape_lower\",\n \"def get_interpolated_contours(contours_grouped_by_pos, len_interval):\\n\\n contours_grouped_by_adjusted_pos = {}\\n for i, (pos, contour) in enumerate(sorted(contours_grouped_by_pos.iteritems())):\\n if i == 0:\\n contours_grouped_by_adjusted_pos[int(np.ceil(pos))] = contour\\n elif i == len(contours_grouped_by_pos)-1:\\n contours_grouped_by_adjusted_pos[int(np.floor(pos))] = contour\\n else:\\n contours_grouped_by_adjusted_pos[int(np.round(pos))] = contour\\n\\n zs = sorted(contours_grouped_by_adjusted_pos.keys())\\n n = len(zs)\\n\\n interpolated_contours = {}\\n\\n for i in range(n):\\n z0 = zs[i]\\n interpolated_contours[z0] = np.array(contours_grouped_by_adjusted_pos[z0])\\n if i + 1 < n:\\n z1 = zs[i+1]\\n interp_cnts = interpolate_contours(contours_grouped_by_adjusted_pos[z0], contours_grouped_by_adjusted_pos[z1], nlevels=z1-z0+1, len_interval_0=len_interval)\\n for zi, z in enumerate(range(z0+1, z1)):\\n interpolated_contours[z] = interp_cnts[zi+1]\\n\\n return interpolated_contours\",\n \"def periodic_polygon_indices2xy(poly, xy, BLdbl, PVxydict):\\n periodicpoly = False\\n tups = pairwise(poly)\\n xypoly = []\\n pervec = np.array([0., 0.])\\n # Add first point to coordinate list\\n xypoly.append((xy[tups[0][0], :] + pervec).tolist())\\n for tup in tups:\\n # Check if the matching row of BL is all positive --> if so, then not periodic bond\\n # NOTE: If tup is positive, and bond is periodic, then will not register a match!\\n match = (BLdbl[:, 0] == tup[0]) & (BLdbl[:, 1] == tup[1])\\n if match.any() and (BLdbl[match, :] > -0.5).all():\\n xypoly.append((xy[tup[1], :] + pervec).tolist())\\n else:\\n # # Check if the matching row of BL flippedlr is all positive --> if so, then not periodic bond\\n # match2 = (BL[:, 0] == tup[1]) & (BL[:, 1] == tup[0])\\n # if match2.any() and (BL[match2, :] > -0.5).all():\\n # xypoly.append((xy[tup[0], :] + pervec).tolist())\\n # xypoly.append((xy[tup[1], :] + pervec).tolist())\\n # else:\\n\\n # Declare that this polygon exists on at least two sides\\n periodicpoly = True\\n # Add periodic vector (PVx, PVy) to forming polygon\\n try:\\n pervec += PVxydict[tup]\\n except KeyError:\\n pervec += -PVxydict[(tup[1], tup[0])]\\n xypoly.append((xy[tup[1], :] + pervec).tolist())\\n\\n return xypoly, periodicpoly\",\n \"def points2contour(points):\\n return points.reshape(-1, 1, 2)\",\n \"def get_positions_by_slits(slits):\\r\\n xy = []\\r\\n for i, slit in enumerate(slits):\\r\\n index = canvas.slits.ids.index(slit)\\r\\n xy.append([canvas.slits.x[index], canvas.slits.y[index]])\\r\\n return np.array(xy)\",\n \"def _dense_point_array(self, geoms, distance, index):\\n # interpolate lines to represent them as points for Voronoi\\n points = []\\n ids = []\\n\\n if pygeos.get_type_id(geoms[0]) not in [1, 2, 5]:\\n lines = pygeos.boundary(geoms)\\n else:\\n lines = geoms\\n lengths = pygeos.length(lines)\\n for ix, line, length in zip(index, lines, lengths):\\n if length > distance: # some polygons might have collapsed\\n pts = pygeos.line_interpolate_point(\\n line,\\n np.linspace(0.1, length - 0.1, num=int((length - 0.1) // distance)),\\n ) # .1 offset to keep a gap between two segments\\n points.append(pygeos.get_coordinates(pts))\\n ids += [ix] * len(pts)\\n\\n points = np.vstack(points)\\n\\n return points, ids\\n\\n # here we might also want to append original coordinates of each line\\n # to get a higher precision on the corners\",\n \"def trapezoid_decomposition_pl(polygons, bounds):\\n polygons = Polygons(polygons)\\n # print(bounds)\\n point_locator = PointLocator(bounds)\\n for edge in polygons.random_edge_sampler():\\n point_locator.add_line(edge)\\n return point_locator\",\n \"def get_positions(specs):\\r\\n xy = []\\r\\n for i, spec in enumerate(specs):\\r\\n slit = spec.split(\\\"n3311\\\", 1)[1].replace(\\\".fits\\\", \\\"\\\")\\r\\n # slit = spec.split(\\\".\\\")[0].split(\\\"_\\\", 1)[1][5:]\\r\\n index = canvas.slits.ids.index(slit)\\r\\n xy.append([canvas.slits.x[index], canvas.slits.y[index]])\\r\\n return np.array(xy)\",\n \"def make_3d_plots_invue(data, groups_and_colors, intp_pts, polyh_pts, offset):\\n data3d = data['coord'][1][:,:3]\\n centroid = np.average(data3d,axis=0)\\n for i in range(polyh_pts):\\n idx = np.sqrt(np.sum(np.square(data3d-centroid),axis=1)).argmax()\\n if i==0:\\n polypts = [data3d[idx]]\\n centroid = polypts\\n elif i==1:\\n polypts = np.append(polypts,[data3d[idx]],axis=0)\\n centroid = np.average(polypts[:i+1],axis=0)\\n elif i==2:\\n polypts = np.append(polypts,[data3d[idx]],axis=0)\\n polypts = np.append(polypts,[polypts[0]],axis=0)\\n centroid = np.average(polypts[:i+1],axis=0)\\n lastpts = polypts[:-1]\\n elif i==3:\\n polypts = np.append(polypts,[data3d[idx]],axis=0)\\n polypts = np.append(polypts,polypts[i-2:i],axis=0)\\n lastpts = np.append(lastpts,[data3d[idx]],axis=0)\\n centroid = np.average(lastpts[:-3],axis=0)\\n else:\\n polypts = np.append(polypts,[data3d[idx]],axis=0)\\n polypts = np.append(polypts,polypts[i-2:i-1],axis=0)\\n polypts = np.append(polypts,[data3d[idx]],axis=0)\\n lastpts = np.append(lastpts,[data3d[idx]],axis=0)\\n centroid = np.average(lastpts[:-3],axis=0)\\n \\n smp_lbl = {}\\n smp_lbl_grp = {}\\n for i in range(len(groups_and_colors)):\\n labelname=groups_and_colors[i][0]\\n groups=groups_and_colors[i][1]\\n colors=groups_and_colors[i][2]\\n data_colors=groups_and_colors[i][3]\\n \\n # Binning data per metadata info\\n smp_lbl[labelname] = {'coords': [], 'headrs': []}\\n smp_lbl_grp[labelname] = {}\\n for gr in groups:\\n smp_lbl_grp[labelname][gr] = {'coords':[], 'headrs':[]}\\n \\n for elm in groups[gr]:\\n try:\\n idx = data['coord'][0].index(elm)\\n except (ValueError):\\n continue\\n #raise ValueError, 'ValueError: list.index(x): %s not in list' % elm\\n \\n # Creating interpolation points\\n if intp_pts==0:\\n smp_lbl_grp[labelname][gr]['coords'].append(data['coord'][1][idx][:3])\\n smp_lbl_grp[labelname][gr]['headrs'].append(elm)\\n else:\\n if len(smp_lbl_grp[labelname][gr]['coords'])==0:\\n smp_lbl_grp[labelname][gr]['coords'].append(data['coord'][1][idx][:3])\\n smp_lbl_grp[labelname][gr]['headrs'].append(elm)\\n pass\\n else:\\n new_pts = linear_gradient(prev_pts,data['coord'][1][idx][:3],intp_pts+2)\\n for j,tmp in enumerate(new_pts[1:]):\\n smp_lbl_grp[labelname][gr]['headrs'].append(\\\"%s.%d\\\" % (elm,j))\\n smp_lbl_grp[labelname][gr]['coords'].append(array(tmp))\\n \\n prev_pts=data['coord'][1][idx][:3]\\n \\n # Saving the coords\\n smp_lbl[labelname]['coords'].append(np.append(data['coord'][1][idx][:3],\\\\\\n [data_colors[colors[gr]].toInt()]))\\n smp_lbl[labelname]['headrs'].append(elm)\\n \\n return smp_lbl, smp_lbl_grp, polypts*offset\",\n \"def plotContour(verts, data, comp=2):\\n z = data[:,:,comp].flatten()\\n x = verts[:,0]\\n y = verts[:,1]\\n\\n xi = np.linspace(x.min(), x.max(), x.size)\\n yi = np.linspace(y.min(), y.max(), y.size)\\n zi = griddata(x,y,z, xi,yi, interp='nn') #'nn' #NOTE: for irregularly spaced data\\n\\n plt.figure()\\n #plt.gca().set_aspect('equal')\\n compDict = {0:'X',1:'Y',2:'Z'}\\n C = compDict[comp]\\n\\n CS = plt.contour(xi,yi,zi,15,linewidths=0.5,colors='k')\\n CS = plt.contourf(xi,yi,zi,15,cmap=plt.cm.jet)\\n plt.title( C + ' Displacement')\\n plt.xlabel('Distance [m]')\\n plt.ylabel('Distance [m]')\\n cb = plt.colorbar()\\n cb.set_label('[m]')\",\n \"def maplot_c(pdata, pdata1, title='', precip='no'):\\n from mpl_toolkits.basemap import Basemap, shiftgrid\\n import numpy as np\\n import matplotlib.pyplot as plt\\n from netcdfread import ncread\\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\\n plt.figure()\\n\\n pdata, lon1 = shiftgrid(180., pdata, lon, start=False)\\n pdata1, lon = shiftgrid(180., pdata1, lon, start=False)\\n meshlon, meshlat = np.meshgrid(lon, lat)\\n\\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\\n m.drawcoastlines()\\n m.drawmapboundary()\\n x, y = m(meshlon, meshlat)\\n plot = m.contour(x, y, pdata, [4, 5, 6], colors='k')\\n plt.clabel(plot, inline=1, fontsize=10)\\n plot1 = m.contour(x, y, pdata1, [4, 5, 6], colors='r', linestyles='--')\\n plt.clabel(plot, inline=1, fontsize=10)\\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\\n m.drawparallels(parallels, labels=[True, True, True, True])\\n m.drawmeridians(meridians, labels=[True, True, True, True])\\n plt.title(title, y=1.08)\\n plt.show()\",\n \"def source_positions(self, dist_cutoff=None):\\n \\n crds = {}\\n for fn in self.srclists:\\n \\n print(\\\"OM::source_positions -- checking: \\\",fn) \\n ff = pyfits.open(fn)\\n idf = fn[-20:-14]\\n obsid = ff[0].header[\\\"OBS_ID\\\"]\\n print(obsid, idf)\\n try:\\n ra, dec = ff[1].data[\\\"RA\\\"], ff[1].data[\\\"DEC\\\"]\\n except:\\n print(fn,\\\" does not contain RA, Dec coordinates.\\\")\\n continue\\n rate = ff[1].data[\\\"CORR_RATE\\\"]\\n coords = C.SkyCoord(ra, dec, unit=(\\\"deg\\\", \\\"deg\\\"), frame='icrs')\\n tc = []\\n ci = []\\n for i, c in enumerate(coords):\\n #print(c)\\n if len(tc) == 0: \\n tc.append(c.to_string(\\\"hmsdms\\\",sep=':', precision=2, pad=True))\\n ci.append(i)\\n continue\\n #print(c, tc, sc)\\n dist = c.separation(coords[ci]).arcsec\\n #print(\\\"dist: \\\",dist)\\n gi = np.where(dist>2)[0]\\n for j in gi:\\n tc.append(c.to_string(\\\"hmsdms\\\",sep=':', precision=2, pad=True))\\n #ci.append(j)\\n if len(tc)>0:\\n crds[idf] = tc\\n #else:\\n if len(crds) == 0:\\n return None\\n return {obsid:crds}\",\n \"def build_xy_data(params, dimension, fold, sub_list):\\n XZ = get_x_data(params, dimension, fold, subject_list=sub_list)\\n Y = []\\n if params[\\\"data_source\\\"] == \\\"ABIDE\\\":\\n classified_file = open(\\n \\\"/scratch/mmahaut/scripts/INT_fMRI_processing/url_preparation/subs_list_asd_classified.json\\\"\\n ) # Hardwriten non-modifiable paths in script is bad practice. modify later !\\n classified_dict = json.load(classified_file)\\n # no normalisation step (which kind of seems legit for classification)\\n for key in classified_dict:\\n Y.append(1 if classified_dict[key] == \\\"asd\\\" else 0)\\n elif params[\\\"data_source\\\"] == \\\"interTVA\\\":\\n # Hardcoding this array is probably not the most reusable solution...\\n # Error 1 found on 30/07/2020 : bad correspondance between subject file and hardcoded Y,\\n # subjects in subject file were not in the same order\\n Y = [\\n 81.25,\\n 81.25,\\n 93.75,\\n 93.75,\\n 93.75,\\n 62.5,\\n 81.25,\\n 100,\\n 100,\\n 87.5,\\n 87.5,\\n 68.75,\\n 68.75,\\n 87.5,\\n 93.75,\\n 100,\\n 62.5,\\n 87.5,\\n 93.75,\\n 87.5,\\n 81.25,\\n 81.25,\\n 81.25,\\n 93.75,\\n 50,\\n 62.5,\\n 93.75,\\n 81.25,\\n 81.25,\\n 87.5,\\n 68.75,\\n 81.25,\\n 87.5,\\n 87.5,\\n 87.5,\\n 75,\\n 93.75,\\n 93.75,\\n 93.75,\\n ]\\n y = np.array(Y)\\n YZ = (y - min(y)) / (max(y) - min(y))\\n return XZ, YZ\",\n \"def rectpolyctl(xmin,xmax,ymin,ymax):\\n pc=[]\\n pc.append((xmin,ymin))\\n pc.append((xmin,ymax))\\n pc.append((xmax,ymax))\\n pc.append((xmax,ymin))\\n pc.append((xmin,ymin))\\n return pc\",\n \"def pointListForCurve(x, y, type):\\n\\n\\tif x < 10:\\n\\t\\txString = \\\"0%d\\\" % x\\n\\telse:\\n\\t\\txString = \\\"%d\\\" % x\\n\\n\\tif x < 11:\\n\\t\\txMString = \\\"0%d\\\" % (x - 1)\\n\\telse:\\n\\t\\txMString = \\\"%d\\\" % (x - 1)\\n\\n\\tif x < 9:\\n\\t\\txPString = \\\"0%d\\\" % (x + 1)\\n\\telse:\\n\\t\\txPString = \\\"%d\\\" % (x + 1)\\n\\n\\tif x < 8:\\n\\t\\txPPString = \\\"0%d\\\" % (x + 2)\\n\\telse:\\n\\t\\txPPString = \\\"%d\\\" % (x + 2)\\n\\n\\tif y < 11:\\n\\t\\tyMString = \\\"0%d\\\" % (y - 1)\\n\\telse:\\n\\t\\tyMString = \\\"%d\\\" % (y - 1)\\n\\n\\tif y < 9:\\n\\t\\tyPString = \\\"0%d\\\" % (y + 1)\\n\\telse:\\n\\t\\tyPString = \\\"%d\\\" % (y + 1)\\n\\n\\tif y < 8:\\n\\t\\tyPPString = \\\"0%d\\\" % (y + 2)\\n\\telse:\\n\\t\\tyPPString = \\\"%d\\\" % (y + 2)\\n\\n\\tif y < 10:\\n\\t\\tyString = \\\"0%d\\\" % y\\n\\telse:\\n\\t\\tyString = \\\"%d\\\" % y\\n\\n\\tinnerRadius = 54.0 / 64.0\\n\\touterRadius = 87.0 / 64.0\\n\\n\\tslices = 10\\n\\n\\t# Dots are numbered as xxyy[IO]z\\n\\t# The I means it is the inside trek, the O the outside\\n\\t# The z is which particular dot it is (0-9)\\n\\t# Note that all paths are marked as being inside the top-left square\\n\\t# Except for entrence and exit dots.\\n\\t# Curves are generated from star + 10 to end - 10\\n\\n\\tif type == 8:\\t\\t\\t# Bottom right\\n\\t\\tcenterX = 25.0 / 64.0\\n\\t\\tcenterY = 25.0 / 64.0\\n\\t\\tstart = 0.0\\n\\t\\tend = 90.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sTL\\\" % (xPString, yString), 0.25, 0.25, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sBL\\\" % (xString, yPString), 0.25, 0.75, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sTL\\\" % (xString, yPString), 0.25, 0.25, [\\\"%s%sTR\\\" % (xMString, yPString)]]\\n\\t\\texitOut =\\t[\\\"%s%sTR\\\" % (xPString, yString), 0.75, 0.25, [\\\"%s%sBR\\\" % (xPString, yMString)]]\\n\\n\\t\\tendIn = \\\"%s%sTL\\\" % (xString, yPString)\\n\\t\\tendOut = \\\"%s%sTR\\\" % (xPString, yString)\\n\\n\\telif type == 9:\\t\\t\\t# Bottom left\\n\\t\\tcenterX = 103.0 / 64.0\\n\\t\\tcenterY = 25.0 / 64.0\\n\\t\\tstart = 90.0\\n\\t\\tend = 180.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sTR\\\" % (xPString, yPString), 0.75, 0.25, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sTR\\\" % (xString, yString), 0.75, 0.25, [\\\"%s%sBR\\\" % (xString, yMString)]]\\n\\t\\texitOut =\\t[\\\"%s%sBR\\\" % (xPString, yPString), 0.75, 0.75, [\\\"%s%sBL\\\" % (xPPString, yPString)]]\\n\\n\\t\\tendIn = \\\"%s%sTR\\\" % (xString, yString)\\n\\t\\tendOut = \\\"%s%sBR\\\" % (xPString, yPString)\\n\\n\\telif type == 10:\\t\\t# Top left\\n\\t\\tcenterX = 103.0 / 64.0\\n\\t\\tcenterY = 103.0 / 64.0\\n\\t\\tstart = 180.0\\n\\t\\tend = 270.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sBR\\\" % (xString, yPString), 0.75, 0.75, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sTR\\\" % (xPString, yString), 0.75, 0.25, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sBR\\\" % (xPString, yString), 0.75, 0.75, [\\\"%s%sBL\\\" % (xPPString, yString)]]\\n\\t\\texitOut =\\t[\\\"%s%sBL\\\" % (xString, yPString), 0.25, 0.75, [\\\"%s%sTL\\\" % (xString, yPPString)]]\\n\\n\\t\\tendIn = \\\"%s%sBR\\\" % (xPString, yString)\\n\\t\\tendOut = \\\"%s%sBL\\\" % (xString, yPString)\\n\\n\\telse: # type == 11:\\t\\t# Top right\\n\\t\\tcenterX = 25.0 / 64.0\\n\\t\\tcenterY = 103.0 / 64.0\\n\\t\\tstart = 270.0\\n\\t\\tend = 360.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sBL\\\" % (xString, yString), 0.25, 0.75, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sBR\\\" % (xPString, yPString), 0.75, 0.75, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sBL\\\" % (xPString, yPString), 0.25, 0.75, [\\\"%s%sTL\\\" % (xPString, yPPString)]]\\n\\t\\texitOut =\\t[\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\\"%s%sTR\\\" % (xMString, yString)]]\\n\\n\\t\\tendIn = \\\"%s%sBL\\\" % (xPString, yPString)\\n\\t\\tendOut = \\\"%s%sTL\\\" % (xString, yString)\\n\\n\\tpointList = [enterIn, enterOut, exitIn, exitOut]\\n\\n\\tstring = \\\"%s%s\\\" % (xString, yString)\\n\\tstep = ((end - 1) - (start + 1)) / float(slices)\\n\\n\\tfor i in range(slices):\\n\\n\\t\\tangle = radians(start + step * i)\\n\\n\\t\\tif i < 9:\\n\\t\\t\\ttemp = [\\\"%sI%d\\\" % (string, i), centerX + cos(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[\\\"%sI%d\\\" % (string, i + 1)]]\\n\\t\\telse:\\n\\t\\t\\ttemp = [\\\"%sI%d\\\" % (string, i), centerX + cos(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[endIn]]\\n\\n\\t\\tpointList.append(temp)\\n\\n\\t\\tangle = radians(start + step * (10 - i))\\n\\n\\t\\tif i < 9:\\n\\t\\t\\ttemp = [\\\"%sO%d\\\" % (string, i), centerX + cos(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[\\\"%sO%d\\\" % (string, i + 1)]]\\n\\t\\telse:\\n\\t\\t\\ttemp = [\\\"%sO%d\\\" % (string, i), centerX + cos(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[endOut]]\\n\\n\\t\\tpointList.append(temp)\\n\\n\\treturn pointList\",\n \"def toArray(parsedList):\\n interpretCommand = {\\n 'C' : lambda x, prevL : x[-2:], # bezier curve. Ignore the curve.\\n 'L' : lambda x, prevL : x[0:2],\\n 'M' : lambda x, prevL : x[0:2],\\n 'Z' : lambda x, prevL : prevL[0],\\n }\\n\\n points =[]\\n for i,(c, arg) in enumerate(parsedList):\\n #debug('toArray ', i, c , arg)\\n newp = interpretCommand[c](arg, points)\\n points.append( newp)\\n a=numpy.array( points )\\n\\n # Some times we have points *very* close to each other\\n # these do not bring any meaning full info, so we remove them\\n #\\n x,y, w,h = computeBox(a)\\n sizeC = 0.5*(w+h)\\n #deltas = numpy.zeros((len(a),2) )\\n deltas = a[1:] - a[:-1] \\n #deltas[-1] = a[0] - a[-1]\\n deltaD = numpy.sqrt(numpy.sum( deltas**2, 1 ))\\n sortedDind = numpy.argsort(deltaD)\\n # expand longuest segments\\n nexp = int(len(deltaD)*0.9)\\n newpoints=[ None ]*len(a)\\n medDelta = deltaD[sortedDind[len(deltaD)/2] ]\\n for i,ind in enumerate(sortedDind):\\n if deltaD[ind]/sizeC<0.005: continue\\n if i>nexp:\\n np = int(deltaD[ind]/medDelta)\\n pL = [a[ind]]\\n #print i,'=',ind,'adding ', np,' _ ', deltaD[ind], a[ind], a[ind+1]\\n for j in range(np-1):\\n f = float(j+1)/np\\n #print '------> ', (1-f)*a[ind]+f*a[ind+1]\\n pL.append( (1-f)*a[ind]+f*a[ind+1] )\\n newpoints[ind] = pL\\n else:\\n newpoints[ind]=[a[ind]]\\n if(D(a[0],a[-1])/sizeC > 0.005 ) :\\n newpoints[-1]=[a[-1]]\\n\\n points = numpy.concatenate([p for p in newpoints if p!=None] )\\n ## print ' medDelta ', medDelta, deltaD[sortedDind[-1]]\\n ## print len(a) ,' ------> ', len(points)\\n\\n rel_norms = numpy.sqrt(numpy.sum( deltas**2, 1 )) / sizeC\\n keep = numpy.concatenate([numpy.where( rel_norms >0.005 )[0],numpy.array([len(a)-1])])\\n\\n #return a[keep] , [ parsedList[i] for i in keep]\\n #print len(a),' ',len(points)\\n return points , []\",\n \"def props_for_contours(contours, ary):\\n c_info = []\\n for c in contours:\\n x, y, w, h = cv2.boundingRect(c)\\n c_im = np.zeros(ary.shape)\\n cv2.drawContours(c_im, [c], 0, 255, -1)\\n c_info.append({\\n 'x1': x,\\n 'y1': y,\\n 'x2': x + w - 1,\\n 'y2': y + h - 1,\\n 'sum': np.sum(ary * (c_im > 0)) / 255\\n })\\n return c_info\",\n \"def _createMap(self,dimensions, density):\\n compMap = []\\n xmin, xmax = dimensions[0], dimensions[1]\\n imin, imax = dimensions[2], dimensions[3]\\n\\n #Ideally the hsteps and the vsteps are the same\\n hsteps = int((xmax - xmin)/density)\\n vsteps = int((imax - imin)/density)\\n\\n for im in range(vsteps):\\n compMap.append([])\\n for x in range(hsteps):\\n myComplexPair = complex(xmin + (density * x), imin + (density * im))\\n compMap[im].append(myComplexPair)\\n compMap.reverse()\\n return compMap\",\n \"def build_raw_xy_data(params, fold, sub_list):\\n # Some repeated code from load_data : not super smart\\n X = get_raw_x_data(params, fold, subject_list=sub_list)\\n XZ = np.array(X)\\n Y = []\\n if params[\\\"data_source\\\"] == \\\"ABIDE\\\":\\n classified_file = open(\\n \\\"/scratch/mmahaut/scripts/INT_fMRI_processing/url_preparation/subs_list_asd_classified.json\\\"\\n ) # Hardwriten non-modifiable paths in script is bad practice. modify later !\\n classified_dict = json.load(classified_file)\\n # no normalisation step (which kind of seems legit for classification)\\n for key in classified_dict:\\n Y.append(1 if classified_dict[key] == \\\"asd\\\" else 0)\\n elif params[\\\"data_source\\\"] == \\\"interTVA\\\":\\n # Hardcoding this array is probably not the most reusable solution...\\n # Error 1 found on 30/07/2020 : bad correspondance between subject file and hardcoded Y,\\n # subjects in subject file were not in the same order\\n Y = [\\n 81.25,\\n 81.25,\\n 93.75,\\n 93.75,\\n 93.75,\\n 62.5,\\n 81.25,\\n 100,\\n 100,\\n 87.5,\\n 87.5,\\n 68.75,\\n 68.75,\\n 87.5,\\n 93.75,\\n 100,\\n 62.5,\\n 87.5,\\n 93.75,\\n 87.5,\\n 81.25,\\n 81.25,\\n 81.25,\\n 93.75,\\n 50,\\n 62.5,\\n 93.75,\\n 81.25,\\n 81.25,\\n 87.5,\\n 68.75,\\n 81.25,\\n 87.5,\\n 87.5,\\n 87.5,\\n 75,\\n 93.75,\\n 93.75,\\n 93.75,\\n ]\\n x = np.array(Y)\\n YZ = (x - min(x)) / (max(x) - min(x))\\n return XZ, YZ\",\n \"def getDictCWells(self,itype):\\n #Method begins here\\n #nx=self.__grid['nx'] #From the geometry in grid\\n ny=self.__grid['ny']\\n nz=self.__grid['nz']\\n minx=self.__grid['ox']\\n miny=self.__grid['oy']\\n minz=self.__grid['oz']\\n rx=self.__grid['dx']\\n ry=self.__grid['dy']\\n rz=self.__grid['dz']\\n \\n # well package\\n # Remember to use zero-based layer, row, column indices!\\n lcoordw=np.zeros((self.__ncwells,3),dtype=np.int32)\\n for i in range (self.__ncwells):\\n lcoordw[i,0]=floor((self.__dfclst.iloc[i,3]-minx)/rx)\\n #In MODFLOW y ans z coordinates are inverted\\n lcoordw[i,1]=floor((miny+ry*ny-self.__dfclst.iloc[i,4])/ry)\\n lcoordw[i,2]=floor((minz+rz*nz-self.__dfclst.iloc[i,5])/rz)\\n \\n nper=self.__df.getForcPer()\\n ssm_data = {}\\n print('Number of conc periods='+str(nper)) \\n for i in range(nper):\\n lst=[]\\n for j in range(self.__ncwells):\\n conc_rate=self.__dfcwells.iloc[i+1,j+1]\\n lst.append( [ lcoordw[j,2], lcoordw[j,1], lcoordw[j,0], conc_rate, itype['WEL'] ] )\\n ssm_data[i]=lst\\n print(ssm_data)\\n \\n print('*--- Succesfull reading of concentration wells ---*')\\n \\n return ssm_data\",\n \"def get_p_polys(self, calc, rholabel, elabels, comm):\\n #Check if everything is computed already\\n if all([((rholabel, elabel) in self.p_polys) for elabel in elabels]):\\n return [self.p_polys[(rholabel, elabel)] for elabel in elabels]\\n\\n #Otherwise compute poly\\n polys = [calc.prs_as_compact_polys(rholabel, elabels, opstr, comm)\\n for opstr in self.generate_circuit_list(permute=False)]\\n\\n ret = []\\n for i, elabel in enumerate(elabels):\\n if (rholabel, elabel) not in self.p_polys:\\n tapes = [p[i] for p in polys]\\n vtape = _np.concatenate([t[0] for t in tapes])\\n ctape = _np.concatenate([t[1] for t in tapes])\\n self.p_polys[(rholabel, elabel)] = (vtape, _np.asarray(ctape, complex))\\n # create ctape *complex* so they're all the same type?\\n ret.append(self.p_polys[(rholabel, elabel)])\\n\\n #OLD - using raw polys via get_raw_polys\\n #ret = []\\n #polys = self.get_raw_polys(calc, rholabel, elabels, comm)\\n #for i,elabel in enumerate(elabels):\\n # if (rholabel,elabel) not in self.p_polys:\\n # tapes = [ poly.compact() for poly in polys[i] ]\\n # vtape = _np.concatenate( [ t[0] for t in tapes ] )\\n # ctape = _np.concatenate( [ t[1] for t in tapes ] )\\n # self.p_polys[ (rholabel,elabel) ] = (vtape, ctape)\\n # ret.append( self.p_polys[ (rholabel,elabel) ] )\\n\\n return ret\",\n \"def voxelize_single_contour(self, contour,res,llc,voxSlice, direction):\\n\\t\\t# prepare contour for the point check\\n\\t\\tverts = [ (P[(direction + 1) % 3],P[(direction + 2) % 3]) for P in contour ]\\n\\t\\tverts.append((contour[0][(direction + 1) % 3],contour[0][(direction + 2) % 3]))\\n\\t\\tcodes = [Path.MOVETO]\\n\\t\\t[codes.append(Path.LINETO) for i in range(len(verts)-2)]\\n\\t\\tcodes.append(Path.CLOSEPOLY)\\n\\t\\tpath = Path(verts, codes)\\n\\t\\t\\n\\t\\t# prepare the list of points to check\\n\\t\\tindices=numpy.transpose(numpy.array(numpy.nonzero(voxSlice==False)))\\n\\t\\tpositions=[(p[0],p[1]) for p in list(indices*res+numpy.array([llc[(direction + 1) % 3],llc[(direction + 2) % 3]]))]\\n\\t\\t\\n\\t\\t# do the check and reshape the result\\n\\t\\tresult=numpy.array(path.contains_points(positions),dtype='bool').reshape(voxSlice.shape)\\n\\t\\t\\n\\t\\treturn result\",\n \"def BL2PVxydict(BL, xy, PV):\\n # The ijth element of PVx is the xcomponent of the vector taking NL[i,j] to its image as seen by particle i.\\n PVxydict = {}\\n # check both directions along each periodic vector\\n PVtmp = np.vstack((PV, -PV))\\n\\n # For each bond that is a periodic bond, determine its periodic boundary vector (a row of the array PV)\\n pBs = np.unique(np.where(BL < 0)[0])\\n print 'le: BL[pBs] = ', BL[pBs]\\n print 'le: pBs = ', pBs\\n for ind in pBs:\\n # Find the PV (periodic vector) that brings the second particle (j) closest to the first (i).\\n # This will be PVxydict[(i,j)], since particle i sees j at xy[j]+PVxydict[(i,j)]\\n a1 = xy[np.abs(BL[ind, 0])]\\n a2 = xy[np.abs(BL[ind, 1])]\\n try:\\n distxy = a2 + PVtmp - a1\\n except ValueError:\\n print 'a1 = ', a1\\n print 'a2 = ', a2\\n print 'PVtmp = ', PVtmp\\n raise RuntimeError('dimensions do not match')\\n dist = distxy[:, 0] ** 2 + distxy[:, 1] ** 2\\n # print 'a1, a2 = ', a1, a2\\n # print 'distxy = ', distxy\\n # print 'PV = ', PV\\n # print 'dist = ', dist\\n if np.argmin(dist) > len(PV) - 1:\\n PVxydict[(np.abs(BL[ind, 0]), np.abs(BL[ind, 1]))] = -PV[np.argmin(dist) % len(PV)]\\n else:\\n PVxydict[(np.abs(BL[ind, 0]), np.abs(BL[ind, 1]))] = PV[np.argmin(dist) % len(PV)]\\n\\n print 'le: PVxydict = ', PVxydict\\n return PVxydict\",\n \"def define_ccd_pos(ccd_pos_dict, raft_name, slot_names, xpos, ypos):\\n ccd_pos_dict[raft_name] = {slot:[xpos[i],ypos[i]] for i,slot in enumerate(slot_names)}\",\n \"def plot_collective(xdict, ydict, xprop, yprop, documents):\\n x_ion = {\\\"Mg\\\": [], \\\"Ca\\\": [], \\\"Zn\\\": [], \\\"Li\\\": [], \\\"Na\\\": []}\\n y_ion = {\\\"Mg\\\": [], \\\"Ca\\\": [], \\\"Zn\\\": [], \\\"Li\\\": [], \\\"Na\\\": []}\\n for item in documents:\\n if item[\\\"path_id\\\"][-3:] == \\\"001\\\":\\n x_ion[item[\\\"cation_type\\\"]].append(xdict[item[\\\"path_id\\\"]])\\n y_ion[item[\\\"cation_type\\\"]].append(ydict[item[\\\"path_id\\\"]])\\n fig = plt.figure(figsize=(6,6), dpi=plotting_dpi)\\n ax = fig.add_subplot(111)\\n for ion in [\\\"Mg\\\", \\\"Ca\\\", \\\"Zn\\\", \\\"Li\\\", \\\"Na\\\"]:\\n ax.scatter(x_ion[ion], y_ion[ion], s=70, zorder=2, color=color_dict[ion], linewidths=2.5, edgecolors='black',\\n label=ion)\\n xlabel = \\\"\\\\\\\\textbf{\\\" + label_dict[xprop] + \\\"}\\\"\\n ylabel = \\\"\\\\\\\\textbf{\\\" + label_dict[yprop] + \\\"}\\\"\\n \\n # # Plot lines for fitting, if useful\\n # x2 = np.arange(-700, 3300, 1)\\n # ax.plot(x2, x2)\\n \\n # # For setting axis boundaries\\n # ax.set_xlim([-700, 3500])\\n # ax.set_ylim([0,100])\\n \\n # Plot display settings\\n ax.set_xlabel(xlabel, fontsize=24)\\n ax.set_ylabel(ylabel, fontsize=24)\\n ax.tick_params(axis='x', labelsize=22)\\n ax.tick_params(axis='y', labelsize=22)\\n border_width = 2\\n [i.set_linewidth(border_width) for i in ax.spines.itervalues()]\\n plt.tight_layout()\\n plt.legend(loc='best', prop={'size':10})\\n # plt.legend(loc='best')\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='sans-serif')\\n plt.show()\",\n \"def cfdReadPointsFile(self):\\r\\n\\r\\n with open(self.pointsFile,\\\"r\\\") as fpid:\\r\\n \\r\\n print('Reading points file ...')\\r\\n points_x=[]\\r\\n points_y=[]\\r\\n points_z=[]\\r\\n \\r\\n for linecount, tline in enumerate(fpid):\\r\\n \\r\\n if not io.cfdSkipEmptyLines(tline):\\r\\n continue\\r\\n \\r\\n if not io.cfdSkipMacroComments(tline):\\r\\n continue\\r\\n \\r\\n if \\\"FoamFile\\\" in tline:\\r\\n dictionary=io.cfdReadCfdDictionary(fpid)\\r\\n continue\\r\\n \\r\\n if len(tline.split()) ==1:\\r\\n if \\\"(\\\" in tline:\\r\\n continue\\r\\n if \\\")\\\" in tline:\\r\\n continue\\r\\n else:\\r\\n self.numberOfNodes = int(tline.split()[0])\\r\\n continue\\r\\n \\r\\n tline=tline.replace(\\\"(\\\",\\\"\\\")\\r\\n tline=tline.replace(\\\")\\\",\\\"\\\")\\r\\n tline=tline.split()\\r\\n \\r\\n points_x.append(float(tline[0]))\\r\\n points_y.append(float(tline[1]))\\r\\n points_z.append(float(tline[2]))\\r\\n \\r\\n ## (array) with the mesh point coordinates \\r\\n self.nodeCentroids = np.array((points_x, points_y, points_z), dtype=float).transpose()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57014245","0.5649377","0.56392044","0.55886257","0.5495664","0.54937655","0.5468166","0.54670477","0.54585874","0.5396782","0.5394453","0.5374216","0.53528965","0.5322514","0.53171647","0.5304197","0.5300245","0.52861774","0.52711666","0.526915","0.5230793","0.5226761","0.5226172","0.5224095","0.5195468","0.51912266","0.5187441","0.51873344","0.51716053","0.51504517","0.5139154","0.5136021","0.5133097","0.5132137","0.511894","0.5114833","0.5105922","0.5101012","0.50904936","0.50745064","0.5073197","0.50705075","0.50684017","0.5053974","0.5053435","0.5052244","0.50375885","0.50322175","0.5032155","0.5030386","0.5026181","0.502568","0.49996302","0.49902725","0.4989484","0.4988555","0.49794507","0.4977546","0.4975122","0.49740744","0.4970116","0.49640584","0.49637994","0.49584472","0.49582553","0.49500638","0.49470824","0.4942947","0.49394244","0.49339238","0.49330252","0.49327236","0.49325562","0.49324328","0.49301544","0.49237433","0.49208114","0.4919589","0.49190477","0.491488","0.4913291","0.490466","0.48985916","0.48977286","0.48877102","0.48834613","0.48834565","0.4880467","0.48790845","0.48754066","0.48752797","0.4871653","0.48713768","0.48657522","0.4860391","0.48595366","0.48572764","0.48556095","0.48533595","0.48521677"],"string":"[\n \"0.57014245\",\n \"0.5649377\",\n \"0.56392044\",\n \"0.55886257\",\n \"0.5495664\",\n \"0.54937655\",\n \"0.5468166\",\n \"0.54670477\",\n \"0.54585874\",\n \"0.5396782\",\n \"0.5394453\",\n \"0.5374216\",\n \"0.53528965\",\n \"0.5322514\",\n \"0.53171647\",\n \"0.5304197\",\n \"0.5300245\",\n \"0.52861774\",\n \"0.52711666\",\n \"0.526915\",\n \"0.5230793\",\n \"0.5226761\",\n \"0.5226172\",\n \"0.5224095\",\n \"0.5195468\",\n \"0.51912266\",\n \"0.5187441\",\n \"0.51873344\",\n \"0.51716053\",\n \"0.51504517\",\n \"0.5139154\",\n \"0.5136021\",\n \"0.5133097\",\n \"0.5132137\",\n \"0.511894\",\n \"0.5114833\",\n \"0.5105922\",\n \"0.5101012\",\n \"0.50904936\",\n \"0.50745064\",\n \"0.5073197\",\n \"0.50705075\",\n \"0.50684017\",\n \"0.5053974\",\n \"0.5053435\",\n \"0.5052244\",\n \"0.50375885\",\n \"0.50322175\",\n \"0.5032155\",\n \"0.5030386\",\n \"0.5026181\",\n \"0.502568\",\n \"0.49996302\",\n \"0.49902725\",\n \"0.4989484\",\n \"0.4988555\",\n \"0.49794507\",\n \"0.4977546\",\n \"0.4975122\",\n \"0.49740744\",\n \"0.4970116\",\n \"0.49640584\",\n \"0.49637994\",\n \"0.49584472\",\n \"0.49582553\",\n \"0.49500638\",\n \"0.49470824\",\n \"0.4942947\",\n \"0.49394244\",\n \"0.49339238\",\n \"0.49330252\",\n \"0.49327236\",\n \"0.49325562\",\n \"0.49324328\",\n \"0.49301544\",\n \"0.49237433\",\n \"0.49208114\",\n \"0.4919589\",\n \"0.49190477\",\n \"0.491488\",\n \"0.4913291\",\n \"0.490466\",\n \"0.48985916\",\n \"0.48977286\",\n \"0.48877102\",\n \"0.48834613\",\n \"0.48834565\",\n \"0.4880467\",\n \"0.48790845\",\n \"0.48754066\",\n \"0.48752797\",\n \"0.4871653\",\n \"0.48713768\",\n \"0.48657522\",\n \"0.4860391\",\n \"0.48595366\",\n \"0.48572764\",\n \"0.48556095\",\n \"0.48533595\",\n \"0.48521677\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6929526"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93477,"cells":{"query":{"kind":"string","value":"Operates INPLACE, so use cautiously..."},"document":{"kind":"string","value":"def LimitPointsBetweenSubContourNodes(scList, numInteriorPointsDict, interpolate=True):\n limIntPtsFunc = (\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\n )\n for sc in scList:\n sc.points = limIntPtsFunc(sc.points, numInteriorPointsDict[tuple(sc.values)])"},"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 mod_inplace(a, b):","def add_inplace(a, b):","def psi_inplace(a):","def second_inplace(a):","def mul_inplace(a, b):","def le_inplace(a,b):","def sub_inplace(a, b):","def or__inplace(a,b):","def inv_inplace(a):","def sgn_inplace(a):","def exp_inplace(a):","def ge_inplace(a,b):","def and__inplace(a,b):","def test_quad_flush_ind(self):","def _insert_op(self, op):","def lt_inplace(a,b):","def _perturbInPlaceHard(self):\n die","def neg_inplace(a):","def xor_inplace(a,b):","def exp2_inplace(a):","def cosh_inplace(a):","def gen_inplace_mutation(self, expr, op, pre):\n ir_a = self.gen_expr(expr.a, rvalue=False)\n assert expr.a.lvalue\n\n ir_typ = self.get_ir_type(expr.typ)\n loaded = self._load_value(ir_a, expr.typ)\n # for pointers, this is not one, but sizeof\n if expr.typ.is_pointer:\n one = self.sizeof(expr.typ.element_type)\n else:\n one = 1\n\n changed = self.builder.emit_binop(loaded, op, one, ir_typ)\n self._store_value(changed, ir_a)\n\n # Determine pre or post form:\n value = loaded if pre else changed\n return value","def invert_inplace(a):","def in_place_offset(self, offset):\n self.p += offset * self.cross_z.normalized()","def mem_update(ops, x, mem, spike):\n #print(ops(x).size())\n #print(spike.size())\n mem = mem * decay * (1. - spike) + ops(x)\n spike = act_fun(mem) # act_fun : approximation firing function\n return mem, spike","def mult_operation(self):\n arg1 = self.memory[self.memory[self._cursor + 1]]\n arg2 = self.memory[self.memory[self._cursor + 2]]\n arg3 = self.memory[self._cursor + 3]\n self.memory[arg3] = arg1 * arg2\n print(f'Cursor: {self._cursor}\\tAssigning position {arg3} with value {arg1 * arg2}')\n self._cursor += 4\n return","def test_prealloc_passthrough(op):\n x1 = np.arange(10)\n x2 = np.arange(10)\n scratch_space = np.zeros(x1.shape)\n _helper_prealloc_passthrough(op, x1, x2, scratch_space)","def test_inter_process_cache():\r\n\r\n x, y = theano.tensor.dvectors('xy')\r\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\r\n f(numpy.arange(60), numpy.arange(60))\r\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \"\":\r\n assert MyOp.nb_called == 0\r\n else:\r\n assert MyOp.nb_called == 1\r\n\r\n # What if we compile a new function with new variables?\r\n x, y = theano.tensor.dvectors('xy')\r\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\r\n f(numpy.arange(60), numpy.arange(60))\r\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \"\":\r\n assert MyOp.nb_called == 0\r\n else:\r\n assert MyOp.nb_called == 1","def eq_inplace(a,b):","def abs__inplace(a):","def asm_memory_access(op):","def assign(self, dst, req, src):\n if req == 'null':\n return\n if req in ('write', 'inplace'):\n dst[:] = src\n elif req == 'add':\n dst[:] += src","def test_inplace_set_value(self):\r\n dtype = self.dtype\r\n if dtype is None:\r\n dtype = theano.config.floatX\r\n\r\n shp = (100/4,1024)#100KB\r\n\r\n x = numpy.zeros(shp, dtype=dtype)\r\n x = self.cast_value(x)\r\n x_shared = self.shared_constructor(x, borrow=True)\r\n\r\n old_data = x_shared.container.storage[0]\r\n nd = numpy.ones(shp, dtype=dtype)\r\n\r\n if x.__class__.__name__ != 'csr_matrix':\r\n #sparse matrix don't support inplace affectation\r\n x_shared.container.value[:] = nd\r\n assert (numpy.asarray(x_shared.get_value(borrow=True))==nd).all()\r\n #This should always share value!\r\n assert may_share_memory(old_data, x_shared.container.storage[0])\r\n assert may_share_memory(old_data, x_shared.get_value(borrow=True, return_internal_type=True))\r\n\r\n nd[0]+=1\r\n x_shared.container.value[0] = nd[0]\r\n assert (numpy.asarray(x_shared.get_value(borrow=True)[0])==nd[0]).all()\r\n assert (numpy.asarray(x_shared.get_value(borrow=True)[1:])==nd[1:]).all()\r\n #This should always share value!\r\n assert may_share_memory(old_data, x_shared.container.storage[0])\r\n assert may_share_memory(old_data, x_shared.get_value(borrow=True, return_internal_type=True))\r\n\r\n if x.__class__.__name__ != 'csr_matrix':\r\n #sparse matrix don't support inplace affectation\r\n nd += 1\r\n #THIS DON't DO WHAT WE EXPECT the contain of a is not updated for CudaNdarray, but it is for ndarray\r\n x_shared.get_value(borrow=True)[:] = nd\r\n #assert (numpy.asarray(x_shared.get_value(borrow=True))!=nd).all()\r\n assert may_share_memory(old_data, x_shared.container.storage[0])\r\n x_shared.get_value(borrow=True)\r\n\r\n # Test by set_value with borrow=False\r\n nd += 1\r\n old_data = x_shared.container.storage[0]\r\n x_shared.set_value(nd, borrow=False)\r\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)),\r\n self.ref_fct(self.cast_value(nd)))\r\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_value_inplace\r\n\r\n # Test by set_value with borrow=False when new data cast.\r\n # specificaly useful for gpu data\r\n nd += 1\r\n old_data = x_shared.container.storage[0]\r\n x_shared.set_value(self.cast_value(nd), borrow=False)\r\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)),\r\n self.ref_fct(self.cast_value(nd)))\r\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_cast_value_inplace\r\n\r\n # Test by set_value with borrow=True\r\n nd += 1\r\n old_data = x_shared.container.storage[0]\r\n x_shared.set_value(nd.copy(), borrow=True)\r\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)),\r\n self.ref_fct(self.cast_value(nd)))\r\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_value_inplace\r\n\r\n # Test by set_value with borrow=True when new data cast.\r\n nd += 1\r\n old_data = x_shared.container.storage[0]\r\n x_shared.set_value(self.cast_value(nd.copy()), borrow=True)\r\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)), self.ref_fct(self.cast_value(nd)))\r\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_cast_value_inplace","def __iadd__(self,that):\n #return self.__opExpand1(that,np.add, out=self)\n return self.__opExpand2(that,np.add, out=self)","def mult_operation(self):\n n1 = self.memory[self.memory[self._cursor + 1]]\n n2 = self.memory[self.memory[self._cursor + 2]]\n position = self.memory[self._cursor + 3]\n self.memory[position] = n1 * n2\n # print(f'Cursor: {self._cursor}\\tAssigning position {position} with value {n1} * {n2} = {n1 * n2}')\n return","def gt_inplace(a,b):","def _optimise(self):\n pass","def replaceOp(image, op, box):\r\n\r\n small = op(image.crop(box))\r\n replace(image, small, box)","def __imul__(self,that):\n #return self.__opExpand1(that,np.multiply, out=self)\n return self.__opExpand2(that,np.multiply, out=self)","def compute_upd(self, move):","def test_unsized(self):\n cache = FIFOCache()\n for i in range(500):\n cache[i] = i\n for i in range(500):\n assert i in cache\n assert cache[i] == i","def minimum_inplace(a, b):","def tan_inplace(a):","def neq_inplace(a,b):","def _op_inplace(self, op: str, other: t.Any) -> te.Self:\n if hasattr(self.__members__, op):\n if isinstance(other, InspectableSet):\n other = other.__members__\n if getattr(self.__members__, op)(other) is NotImplemented:\n return NotImplemented\n return self\n return NotImplemented","def update_memory(self, result):\r\n if (len(self.memory) >= self.memory_capacity):\r\n self.memory.pop(0)\r\n self.memory.append(result)\r\n else:\r\n self.memory.append(result)","def _exch(self, ix_1, ix_2):\n tmp = self._vals[ix_1]\n self._vals[ix_1] = self._vals[ix_2]\n self._vals[ix_2] = tmp","def add_operation(self):\n arg1 = self.memory[self.memory[self._cursor + 1]]\n arg2 = self.memory[self.memory[self._cursor + 2]]\n arg3 = self.memory[self._cursor + 3]\n self.memory[arg3] = arg1 + arg2\n # print(f'Cursor: {self._cursor}\\tAssigning position {position} with value {n1 + n2}')\n self._cursor += 4\n return","def _precompute(self, A):\n return ()","def enqueue(tup):","def sinh_inplace(a):","def __radd__(self,that):\n return self.__opExpand2(that,np.add)","def composes_inplace_with(self):\n pass","def place(arr, mask, vals):\n return _insert(arr, mask, vals)","def rePop(self):\n nScan = 0\n pScan = self.num-1\n while not self.isFull():\n while self.genepool[0][pScan] == None:\n pScan = (pScan-1)%self.num\n while self.genepool[0][nScan] != None:\n nScan = (nScan+1)%self.num\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\n nScan = (nScan+1)%self.num\n pScan = (pScan-1)%self.num","def rePop(self):\n nScan = 0\n pScan = self.num-1\n while not self.isFull():\n while self.genepool[0][pScan] == None:\n pScan = (pScan-1)%self.num\n while self.genepool[0][nScan] != None:\n nScan = (nScan+1)%self.num\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\n nScan = (nScan+1)%self.num\n pScan = (pScan-1)%self.num","def apply(self) -> None:","def apply(self) -> None:","def victorylap(array):\n for i in range(0, array.len()):\n array.peek(i, False, True, 0.01) # Run it slower","def iadd(state: State) -> State:\n cell = state.array[state.index] or 0\n return state._replace(acc=state.acc + cell)","def sqr_inplace(a):","def floor_inplace(a):","def __call__(self):\n\n self.ndx+=self.delta\n if not 0<=self.ndx<len(self.seq):\n if self.ndx>len(self.seq):\n self.ndx=len(self.seq) # In case this sequence has shrunk.\n if self.yoyo:\n self.delta*=-1\n self.ndx+=self.delta*2\n else:\n self.ndx=0\n return self.seq[self.ndx]","def apply(self) -> Operation:\n op = self.popleft()\n op()\n return op","def __add__(self,that):\n return self.__opExpand2(that,np.add)","def _advance(self):\t\t# override inherited version\n self._current *= self._base","def apply(self):","def _on(self, qubits: iter[any]) -> None:\n\n self.on(qubits, inplace=True)","def inplace(block_size=20000):\n y = np.empty(len(x))\n for k in range(len(x) // block_size + 1):\n b, e = k * block_size, (k+1) * block_size\n y[b:e] = x[b:e]\n y[b:e] *= .25\n y[b:e] += .75\n y[b:e] *= x[b:e]\n y[b:e] -= 1.5\n y[b:e] *= x[b:e]\n y[b:e] -= 2\n\n return y","def evict_or_add (self, item):","def add_operation(self):\n n1 = self.memory[self.memory[self._cursor + 1]]\n n2 = self.memory[self.memory[self._cursor + 2]]\n position = self.memory[self._cursor + 3]\n self.memory[position] = n1 + n2\n # print(f'Cursor: {self._cursor}\\tAssigning position {position} with value {n1} + {n2} = {n1 + n2}')\n return","def inplace_elemwise_optimizer_op(OP):\r\n @gof.inplace_optimizer\r\n def inplace_elemwise_optimizer(fgraph):\r\n \"\"\"\r\n Usage: inplace_elemwise_optimizer.optimize(fgraph)\r\n\r\n Attempts to replace all Broadcast ops by versions of them\r\n that operate inplace. It operates greedily: for each Broadcast\r\n Op that is encountered, for each output, tries each input to\r\n see if it can operate inplace on that input. If so, makes the\r\n change and go to the next output or Broadcast Op.\r\n\r\n Examples:\r\n x + y + z -> x += y += z\r\n (x + y) * (x * y) -> (x += y) *= (x * y) or (x + y) *= (x *= y)\r\n \"\"\"\r\n # We should not validate too often as this takes too much time to\r\n # execute!\r\n # It is the _dfs_toposort() fct in theano/gof/destroyhandler.py\r\n # that takes so much time.\r\n # Should we try to use another lib that does toposort?\r\n # igraph: http://igraph.sourceforge.net/\r\n # networkx: https://networkx.lanl.gov/\r\n # Should we try to use cython?\r\n # Compiling only that fct is not enough, should we try to add the\r\n # deque class too?\r\n # And init the deque and other list to an upper bound number of\r\n # elements?\r\n # Maybe Theano should do online toposort as in\r\n # http://code.google.com/p/acyclic\r\n #\r\n # The next longest optimizer is the canonizer phase.\r\n # Then I think it is the [io_?]toposort (need to validate) so check if\r\n # the solution is also applicable there.\r\n\r\n # We execute `validate` after this number of change.\r\n check_each_change = config.tensor.insert_inplace_optimizer_validate_nb\r\n if check_each_change == -1:\r\n if len(fgraph.apply_nodes) > 500:\r\n check_each_change = 10\r\n else:\r\n check_each_change = 1\r\n\r\n nb_change_no_validate = 0\r\n chk = fgraph.checkpoint()\r\n\r\n for node in list(graph.io_toposort(fgraph.inputs, fgraph.outputs)):\r\n op = node.op\r\n if not isinstance(op, OP):\r\n continue\r\n baseline = op.inplace_pattern\r\n protected_inputs = [\r\n f.protected for f in node.fgraph._features if\r\n isinstance(f, theano.compile.function_module.Supervisor)]\r\n protected_inputs = sum(protected_inputs, []) # flatten the list\r\n protected_inputs.extend(fgraph.outputs)\r\n candidate_outputs = [i for i in xrange(len(node.outputs))\r\n if i not in baseline]\r\n # node inputs that are Constant, already destroyed,\r\n # fgraph protected inputs and fgraph outputs can't be used as inplace\r\n # target.\r\n # Remove here as faster.\r\n candidate_inputs = [i for i in xrange(len(node.inputs))\r\n if i not in baseline.values() \\\r\n and not isinstance(node.inputs[i],\r\n Constant)\\\r\n and not fgraph.destroyers(node.inputs[i])\\\r\n and node.inputs[i] not in protected_inputs]\r\n\r\n verbose = False\r\n\r\n raised_warning = not verbose\r\n\r\n for candidate_output in candidate_outputs:\r\n for candidate_input in candidate_inputs:\r\n #remove inputs that don't have the same dtype as the output\r\n if node.inputs[candidate_input].type != node.outputs[\r\n candidate_output].type:\r\n continue\r\n\r\n inplace_pattern = dict(baseline)\r\n inplace_pattern[candidate_output] = candidate_input\r\n try:\r\n if hasattr(op.scalar_op, \"make_new_inplace\"):\r\n new_scal = op.scalar_op.make_new_inplace(\r\n scalar.transfer_type(\r\n *[inplace_pattern.get(i, None) \\\r\n for i in xrange(len(node.outputs))]))\r\n else:\r\n new_scal = op.scalar_op.__class__(\r\n scalar.transfer_type(\r\n *[inplace_pattern.get(i, None) \\\r\n for i in xrange(len(node.outputs))]))\r\n new_outputs = OP(new_scal, inplace_pattern)(\r\n *node.inputs, **dict(return_list=True))\r\n new_node = new_outputs[0].owner\r\n\r\n for r, new_r in zip(node.outputs, new_outputs):\r\n fgraph.replace(r, new_r,\r\n reason=\"inplace_elemwise_optimizer\")\r\n nb_change_no_validate += 1\r\n if nb_change_no_validate >= check_each_change:\r\n fgraph.validate()\r\n chk = fgraph.checkpoint()\r\n nb_change_no_validate = 0\r\n except (ValueError, TypeError, InconsistencyError), e:\r\n if check_each_change != 1 and not raised_warning:\r\n print >> sys.stderr, (\r\n \"Some inplace optimization was not \"\r\n \"performed due to unexpected error:\")\r\n print >> sys.stderr, e\r\n raised_warning = True\r\n fgraph.revert(chk)\r\n continue\r\n candidate_inputs.remove(candidate_input)\r\n node = new_node\r\n baseline = inplace_pattern\r\n break\r\n\r\n if nb_change_no_validate > 0:\r\n try:\r\n fgraph.validate()\r\n except Exception:\r\n if not raised_warning:\r\n print >> sys.stderr, (\"Some inplace optimization was not \"\r\n \"performed due to unexpected error\")\r\n fgraph.revert(chk)\r\n return inplace_elemwise_optimizer","def my_original(x):\n return x + x * x","def assign_in_place_subblock(A, a, i, j):\n bi = 2*i\n bj = 2*j\n A[bi, bj] = a[0, 0]\n A[bi, bj+1] = a[0, 1]\n A[bi+1, bj] = a[1, 0]\n A[bi+1, bj+1] = a[1, 1]","def test_deepcopy(self):\n t = Reverse(Quantize())\n t.transform([2])\n copy.deepcopy(t)","def update(src):","def pow_inplace(a, b):","def replace(self, index, value):\n index += self.n\n self.data[index] = value\n index //= 2\n while index > 0:\n self.data[index] = self.func(self.data[2*index], self.data[2*index+1])\n index //= 2","def fL():\n for n in b.allNodes():\n n.autoplace()","def test_unsized(self):\n cache = LRUCache()\n for i in range(500):\n cache[i] = i\n for i in range(500):\n assert i in cache\n assert cache[i] == i","def __opExpand1(self,that,op, out=None):\n A = self\n B = that if isinstance(that,Factor) else Factor([],that)\n vall = A.v | B.v\n axA = list(map(lambda x:A.v.index(x) if x in A.v else -1 ,vall))\n axB = list(map(lambda x:B.v.index(x) if x in B.v else -1 ,vall))\n if ( (not (out is None)) and (out.v == vall) ):\n f = out\n else:\n f = Factor(vall) # TODO: should also change \"out\" if specified!\n it = np.nditer([A.t, B.t, f.t], \n op_axes = [ axA, axB, None ], \n op_flags=[['readonly'], ['readonly'], ['writeonly']])\n for (i,j,k) in it:\n op(i,j,out=k)\n return f","def test_byteps_push_pull_inplace(self):\n size = bps.size()\n dtypes = ['float16', 'float32', 'float64']\n dims = [1, 2, 3]\n count = 0\n ctx = self._current_context()\n shapes = [(), (17), (17, 17), (17, 17, 17)]\n for dtype, dim in itertools.product(dtypes, dims):\n mx.random.seed(1234, ctx=ctx)\n tensor = mx.nd.random.uniform(-100, 100, shape=shapes[dim],\n ctx=ctx)\n tensor = tensor.astype(dtype)\n multiplied = tensor.copy()\n bps.byteps_declare_tensor(\"tensor_\" + str(count))\n bps.byteps_push_pull(tensor, name=\"tensor_\" + str(count))\n max_difference = mx.nd.max(mx.nd.subtract(tensor, multiplied))\n count += 1\n\n # Threshold for floating point equality depends on number of\n # ranks, since we're comparing against precise multiplication.\n if size <= 3 or dtype in ['int32', 'int64']:\n threshold = 0\n elif size < 10:\n threshold = 1e-4\n elif size < 15:\n threshold = 5e-4\n else:\n break\n\n if max_difference > threshold:\n print(\"self\", count, dtype, dim, max_difference, threshold)\n print(\"tensor\", bps.rank(), tensor)\n print(\"multiplied\", bps.rank(), multiplied)\n assert max_difference <= threshold, 'bps.byteps_push_pull produces \\\n incorrect results for self'\n\n print('test_byteps_push_pull_inplace passed')","def local_inplace_incsubtensor1(node):\r\n if isinstance(node.op, AdvancedIncSubtensor1) and not node.op.inplace:\r\n new_op = node.op.__class__(\r\n inplace=True, set_instead_of_inc=node.op.set_instead_of_inc)\r\n new_node = new_op(*node.inputs)\r\n return [new_node]\r\n return False","def incr_operand(self):\n pass","def swish_(t: Tensor) -> Tensor:\n ctx = get_current_context()\n g = ctx.graph\n pb_g = g._pb_graph\n\n check_in_graph(g, t=t)\n\n settings = ctx._get_op_settings(\"swish_inplace\")\n op = pb_g.createConnectedOp_SwishInplaceOp(\n {0: t.id}, \n {\n 0: g._create_tensor_id(\"swish_inplace_out\")\n }, \n settings\n )\n\n return Tensor._from_pb_tensor(op.outTensor(0))","def heappop(heap):\n pass","def replace_op(self, op, replacement):\n self.replacement_list.append((op, replacement))","def insertion_optimized_alt(array):\n j = 0\n for i,val in enumerate(array):\n for j in range(i,-1,-1):\n if j>0 and val<array[j-1]:\n array[j] = array[j-1]\n else:\n break\n array[j] = val","def vectorized(self):\n return False","def JNZ():\n global pointer, memory, registers\n if registers[memory[pointer + 0x01]] != 0:\n pointer = memory[pointer + 0x02]\n return\n\n pointer += 0x03","def test_inplace_optimization(self):\r\n #inplace = False\r\n rf2 = RandomFunction(numpy.random.RandomState.uniform, tensor.dvector)\r\n rng_R = random_state_type()\r\n\r\n # If calling RandomFunction directly, all args have to be specified,\r\n # because shape will have to be moved to the end\r\n post_r2, out2 = rf2(rng_R, (4,), 0., 1.)\r\n\r\n f = compile.function(\r\n [compile.In(rng_R,\r\n value=numpy.random.RandomState(utt.fetch_seed()),\r\n update=post_r2,\r\n mutable=True)],\r\n out2,\r\n mode='FAST_RUN') # DEBUG_MODE can't pass the id-based\r\n # test below\r\n\r\n # test that the RandomState object stays the same from function call to\r\n # function call, but that the values returned change from call to call.\r\n\r\n id0 = id(f[rng_R])\r\n val0 = f()\r\n assert id0 == id(f[rng_R])\r\n val1 = f()\r\n assert id0 == id(f[rng_R])\r\n\r\n assert not numpy.allclose(val0, val1)","def arccosh_inplace(a):","def _make_soft_copy_op(tau, target, online):\n return target.assign_sub(tau * (target - online))","def _make_soft_copy_op(tau, target, online):\n return target.assign_sub(tau * (target - online))","def revise():","def update(self, action): \n self.memory.pop(-1) \n self.memory.insert(0, [self.last_state.cpu().numpy(), action.cpu().numpy()])\n\n self.last_action = action","def arctan2_inplace(a, b):","def _arg_swapper(op):\n\n def op_swapped(a, b, *args, **kwargs):\n return op(b, a, *args, **kwargs)\n\n return op_swapped","def __execute(self, instruction: Instruction) -> NoReturn:\n\n op, *args = instruction\n logging.debug(f\"Executing: {op}\")\n logging.debug(self.memory)\n function_map[op](*args, memory=self.memory)\n logging.debug(self.memory)","def _scal_inplace(symbol):\r\n symbolname = symbol.__name__\r\n inplace = symbolname.endswith('_inplace')\r\n\r\n if inplace:\r\n scalar_op = getattr(scal, symbolname[:-len('_inplace')])\r\n inplace_scalar_op = scalar_op.__class__(scal.transfer_type(0))\r\n rval = elemwise.Elemwise(inplace_scalar_op, {0: 0}, name=symbolname)\r\n else:\r\n scalar_op = getattr(scal, symbolname)\r\n rval = elemwise.Elemwise(scalar_op, name=symbolname)\r\n\r\n if getattr(symbol, '__doc__', False):\r\n rval.__doc__ = symbol.__doc__ + '\\n' + rval.__doc__\r\n\r\n #for the meaning of this see the ./epydoc script\r\n # it makes epydoc display rval as if it were a function, not an object\r\n rval.__epydoc_asRoutine = symbol\r\n rval.__module__ = 'theano.tensor.inplace'\r\n\r\n def chk(pstate, r):\r\n if not r.owner:\r\n return False\r\n op = r.owner.op\r\n# print op, rval, r.owner and op == rval\r\n# print op.inplace_pattern, rval.inplace_pattern, op.inplace_pattern == rval.inplace_pattern\r\n# print op.scalar_op, rval.scalar_op, op.scalar_op == rval.scalar_op\r\n return r.owner.op == rval\r\n\r\n pprint.assign(chk, printing.FunctionPrinter(symbolname.replace('_inplace', '=')))\r\n return rval","def pre_compute(self, e_list):\n\t\tpass"],"string":"[\n \"def mod_inplace(a, b):\",\n \"def add_inplace(a, b):\",\n \"def psi_inplace(a):\",\n \"def second_inplace(a):\",\n \"def mul_inplace(a, b):\",\n \"def le_inplace(a,b):\",\n \"def sub_inplace(a, b):\",\n \"def or__inplace(a,b):\",\n \"def inv_inplace(a):\",\n \"def sgn_inplace(a):\",\n \"def exp_inplace(a):\",\n \"def ge_inplace(a,b):\",\n \"def and__inplace(a,b):\",\n \"def test_quad_flush_ind(self):\",\n \"def _insert_op(self, op):\",\n \"def lt_inplace(a,b):\",\n \"def _perturbInPlaceHard(self):\\n die\",\n \"def neg_inplace(a):\",\n \"def xor_inplace(a,b):\",\n \"def exp2_inplace(a):\",\n \"def cosh_inplace(a):\",\n \"def gen_inplace_mutation(self, expr, op, pre):\\n ir_a = self.gen_expr(expr.a, rvalue=False)\\n assert expr.a.lvalue\\n\\n ir_typ = self.get_ir_type(expr.typ)\\n loaded = self._load_value(ir_a, expr.typ)\\n # for pointers, this is not one, but sizeof\\n if expr.typ.is_pointer:\\n one = self.sizeof(expr.typ.element_type)\\n else:\\n one = 1\\n\\n changed = self.builder.emit_binop(loaded, op, one, ir_typ)\\n self._store_value(changed, ir_a)\\n\\n # Determine pre or post form:\\n value = loaded if pre else changed\\n return value\",\n \"def invert_inplace(a):\",\n \"def in_place_offset(self, offset):\\n self.p += offset * self.cross_z.normalized()\",\n \"def mem_update(ops, x, mem, spike):\\n #print(ops(x).size())\\n #print(spike.size())\\n mem = mem * decay * (1. - spike) + ops(x)\\n spike = act_fun(mem) # act_fun : approximation firing function\\n return mem, spike\",\n \"def mult_operation(self):\\n arg1 = self.memory[self.memory[self._cursor + 1]]\\n arg2 = self.memory[self.memory[self._cursor + 2]]\\n arg3 = self.memory[self._cursor + 3]\\n self.memory[arg3] = arg1 * arg2\\n print(f'Cursor: {self._cursor}\\\\tAssigning position {arg3} with value {arg1 * arg2}')\\n self._cursor += 4\\n return\",\n \"def test_prealloc_passthrough(op):\\n x1 = np.arange(10)\\n x2 = np.arange(10)\\n scratch_space = np.zeros(x1.shape)\\n _helper_prealloc_passthrough(op, x1, x2, scratch_space)\",\n \"def test_inter_process_cache():\\r\\n\\r\\n x, y = theano.tensor.dvectors('xy')\\r\\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\\r\\n f(numpy.arange(60), numpy.arange(60))\\r\\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \\\"\\\":\\r\\n assert MyOp.nb_called == 0\\r\\n else:\\r\\n assert MyOp.nb_called == 1\\r\\n\\r\\n # What if we compile a new function with new variables?\\r\\n x, y = theano.tensor.dvectors('xy')\\r\\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\\r\\n f(numpy.arange(60), numpy.arange(60))\\r\\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \\\"\\\":\\r\\n assert MyOp.nb_called == 0\\r\\n else:\\r\\n assert MyOp.nb_called == 1\",\n \"def eq_inplace(a,b):\",\n \"def abs__inplace(a):\",\n \"def asm_memory_access(op):\",\n \"def assign(self, dst, req, src):\\n if req == 'null':\\n return\\n if req in ('write', 'inplace'):\\n dst[:] = src\\n elif req == 'add':\\n dst[:] += src\",\n \"def test_inplace_set_value(self):\\r\\n dtype = self.dtype\\r\\n if dtype is None:\\r\\n dtype = theano.config.floatX\\r\\n\\r\\n shp = (100/4,1024)#100KB\\r\\n\\r\\n x = numpy.zeros(shp, dtype=dtype)\\r\\n x = self.cast_value(x)\\r\\n x_shared = self.shared_constructor(x, borrow=True)\\r\\n\\r\\n old_data = x_shared.container.storage[0]\\r\\n nd = numpy.ones(shp, dtype=dtype)\\r\\n\\r\\n if x.__class__.__name__ != 'csr_matrix':\\r\\n #sparse matrix don't support inplace affectation\\r\\n x_shared.container.value[:] = nd\\r\\n assert (numpy.asarray(x_shared.get_value(borrow=True))==nd).all()\\r\\n #This should always share value!\\r\\n assert may_share_memory(old_data, x_shared.container.storage[0])\\r\\n assert may_share_memory(old_data, x_shared.get_value(borrow=True, return_internal_type=True))\\r\\n\\r\\n nd[0]+=1\\r\\n x_shared.container.value[0] = nd[0]\\r\\n assert (numpy.asarray(x_shared.get_value(borrow=True)[0])==nd[0]).all()\\r\\n assert (numpy.asarray(x_shared.get_value(borrow=True)[1:])==nd[1:]).all()\\r\\n #This should always share value!\\r\\n assert may_share_memory(old_data, x_shared.container.storage[0])\\r\\n assert may_share_memory(old_data, x_shared.get_value(borrow=True, return_internal_type=True))\\r\\n\\r\\n if x.__class__.__name__ != 'csr_matrix':\\r\\n #sparse matrix don't support inplace affectation\\r\\n nd += 1\\r\\n #THIS DON't DO WHAT WE EXPECT the contain of a is not updated for CudaNdarray, but it is for ndarray\\r\\n x_shared.get_value(borrow=True)[:] = nd\\r\\n #assert (numpy.asarray(x_shared.get_value(borrow=True))!=nd).all()\\r\\n assert may_share_memory(old_data, x_shared.container.storage[0])\\r\\n x_shared.get_value(borrow=True)\\r\\n\\r\\n # Test by set_value with borrow=False\\r\\n nd += 1\\r\\n old_data = x_shared.container.storage[0]\\r\\n x_shared.set_value(nd, borrow=False)\\r\\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)),\\r\\n self.ref_fct(self.cast_value(nd)))\\r\\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_value_inplace\\r\\n\\r\\n # Test by set_value with borrow=False when new data cast.\\r\\n # specificaly useful for gpu data\\r\\n nd += 1\\r\\n old_data = x_shared.container.storage[0]\\r\\n x_shared.set_value(self.cast_value(nd), borrow=False)\\r\\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)),\\r\\n self.ref_fct(self.cast_value(nd)))\\r\\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_cast_value_inplace\\r\\n\\r\\n # Test by set_value with borrow=True\\r\\n nd += 1\\r\\n old_data = x_shared.container.storage[0]\\r\\n x_shared.set_value(nd.copy(), borrow=True)\\r\\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)),\\r\\n self.ref_fct(self.cast_value(nd)))\\r\\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_value_inplace\\r\\n\\r\\n # Test by set_value with borrow=True when new data cast.\\r\\n nd += 1\\r\\n old_data = x_shared.container.storage[0]\\r\\n x_shared.set_value(self.cast_value(nd.copy()), borrow=True)\\r\\n assert numpy.allclose(self.ref_fct(x_shared.get_value(borrow=True)), self.ref_fct(self.cast_value(nd)))\\r\\n assert may_share_memory(old_data, x_shared.container.storage[0]) == self.set_cast_value_inplace\",\n \"def __iadd__(self,that):\\n #return self.__opExpand1(that,np.add, out=self)\\n return self.__opExpand2(that,np.add, out=self)\",\n \"def mult_operation(self):\\n n1 = self.memory[self.memory[self._cursor + 1]]\\n n2 = self.memory[self.memory[self._cursor + 2]]\\n position = self.memory[self._cursor + 3]\\n self.memory[position] = n1 * n2\\n # print(f'Cursor: {self._cursor}\\\\tAssigning position {position} with value {n1} * {n2} = {n1 * n2}')\\n return\",\n \"def gt_inplace(a,b):\",\n \"def _optimise(self):\\n pass\",\n \"def replaceOp(image, op, box):\\r\\n\\r\\n small = op(image.crop(box))\\r\\n replace(image, small, box)\",\n \"def __imul__(self,that):\\n #return self.__opExpand1(that,np.multiply, out=self)\\n return self.__opExpand2(that,np.multiply, out=self)\",\n \"def compute_upd(self, move):\",\n \"def test_unsized(self):\\n cache = FIFOCache()\\n for i in range(500):\\n cache[i] = i\\n for i in range(500):\\n assert i in cache\\n assert cache[i] == i\",\n \"def minimum_inplace(a, b):\",\n \"def tan_inplace(a):\",\n \"def neq_inplace(a,b):\",\n \"def _op_inplace(self, op: str, other: t.Any) -> te.Self:\\n if hasattr(self.__members__, op):\\n if isinstance(other, InspectableSet):\\n other = other.__members__\\n if getattr(self.__members__, op)(other) is NotImplemented:\\n return NotImplemented\\n return self\\n return NotImplemented\",\n \"def update_memory(self, result):\\r\\n if (len(self.memory) >= self.memory_capacity):\\r\\n self.memory.pop(0)\\r\\n self.memory.append(result)\\r\\n else:\\r\\n self.memory.append(result)\",\n \"def _exch(self, ix_1, ix_2):\\n tmp = self._vals[ix_1]\\n self._vals[ix_1] = self._vals[ix_2]\\n self._vals[ix_2] = tmp\",\n \"def add_operation(self):\\n arg1 = self.memory[self.memory[self._cursor + 1]]\\n arg2 = self.memory[self.memory[self._cursor + 2]]\\n arg3 = self.memory[self._cursor + 3]\\n self.memory[arg3] = arg1 + arg2\\n # print(f'Cursor: {self._cursor}\\\\tAssigning position {position} with value {n1 + n2}')\\n self._cursor += 4\\n return\",\n \"def _precompute(self, A):\\n return ()\",\n \"def enqueue(tup):\",\n \"def sinh_inplace(a):\",\n \"def __radd__(self,that):\\n return self.__opExpand2(that,np.add)\",\n \"def composes_inplace_with(self):\\n pass\",\n \"def place(arr, mask, vals):\\n return _insert(arr, mask, vals)\",\n \"def rePop(self):\\n nScan = 0\\n pScan = self.num-1\\n while not self.isFull():\\n while self.genepool[0][pScan] == None:\\n pScan = (pScan-1)%self.num\\n while self.genepool[0][nScan] != None:\\n nScan = (nScan+1)%self.num\\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\\n nScan = (nScan+1)%self.num\\n pScan = (pScan-1)%self.num\",\n \"def rePop(self):\\n nScan = 0\\n pScan = self.num-1\\n while not self.isFull():\\n while self.genepool[0][pScan] == None:\\n pScan = (pScan-1)%self.num\\n while self.genepool[0][nScan] != None:\\n nScan = (nScan+1)%self.num\\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\\n nScan = (nScan+1)%self.num\\n pScan = (pScan-1)%self.num\",\n \"def apply(self) -> None:\",\n \"def apply(self) -> None:\",\n \"def victorylap(array):\\n for i in range(0, array.len()):\\n array.peek(i, False, True, 0.01) # Run it slower\",\n \"def iadd(state: State) -> State:\\n cell = state.array[state.index] or 0\\n return state._replace(acc=state.acc + cell)\",\n \"def sqr_inplace(a):\",\n \"def floor_inplace(a):\",\n \"def __call__(self):\\n\\n self.ndx+=self.delta\\n if not 0<=self.ndx<len(self.seq):\\n if self.ndx>len(self.seq):\\n self.ndx=len(self.seq) # In case this sequence has shrunk.\\n if self.yoyo:\\n self.delta*=-1\\n self.ndx+=self.delta*2\\n else:\\n self.ndx=0\\n return self.seq[self.ndx]\",\n \"def apply(self) -> Operation:\\n op = self.popleft()\\n op()\\n return op\",\n \"def __add__(self,that):\\n return self.__opExpand2(that,np.add)\",\n \"def _advance(self):\\t\\t# override inherited version\\n self._current *= self._base\",\n \"def apply(self):\",\n \"def _on(self, qubits: iter[any]) -> None:\\n\\n self.on(qubits, inplace=True)\",\n \"def inplace(block_size=20000):\\n y = np.empty(len(x))\\n for k in range(len(x) // block_size + 1):\\n b, e = k * block_size, (k+1) * block_size\\n y[b:e] = x[b:e]\\n y[b:e] *= .25\\n y[b:e] += .75\\n y[b:e] *= x[b:e]\\n y[b:e] -= 1.5\\n y[b:e] *= x[b:e]\\n y[b:e] -= 2\\n\\n return y\",\n \"def evict_or_add (self, item):\",\n \"def add_operation(self):\\n n1 = self.memory[self.memory[self._cursor + 1]]\\n n2 = self.memory[self.memory[self._cursor + 2]]\\n position = self.memory[self._cursor + 3]\\n self.memory[position] = n1 + n2\\n # print(f'Cursor: {self._cursor}\\\\tAssigning position {position} with value {n1} + {n2} = {n1 + n2}')\\n return\",\n \"def inplace_elemwise_optimizer_op(OP):\\r\\n @gof.inplace_optimizer\\r\\n def inplace_elemwise_optimizer(fgraph):\\r\\n \\\"\\\"\\\"\\r\\n Usage: inplace_elemwise_optimizer.optimize(fgraph)\\r\\n\\r\\n Attempts to replace all Broadcast ops by versions of them\\r\\n that operate inplace. It operates greedily: for each Broadcast\\r\\n Op that is encountered, for each output, tries each input to\\r\\n see if it can operate inplace on that input. If so, makes the\\r\\n change and go to the next output or Broadcast Op.\\r\\n\\r\\n Examples:\\r\\n x + y + z -> x += y += z\\r\\n (x + y) * (x * y) -> (x += y) *= (x * y) or (x + y) *= (x *= y)\\r\\n \\\"\\\"\\\"\\r\\n # We should not validate too often as this takes too much time to\\r\\n # execute!\\r\\n # It is the _dfs_toposort() fct in theano/gof/destroyhandler.py\\r\\n # that takes so much time.\\r\\n # Should we try to use another lib that does toposort?\\r\\n # igraph: http://igraph.sourceforge.net/\\r\\n # networkx: https://networkx.lanl.gov/\\r\\n # Should we try to use cython?\\r\\n # Compiling only that fct is not enough, should we try to add the\\r\\n # deque class too?\\r\\n # And init the deque and other list to an upper bound number of\\r\\n # elements?\\r\\n # Maybe Theano should do online toposort as in\\r\\n # http://code.google.com/p/acyclic\\r\\n #\\r\\n # The next longest optimizer is the canonizer phase.\\r\\n # Then I think it is the [io_?]toposort (need to validate) so check if\\r\\n # the solution is also applicable there.\\r\\n\\r\\n # We execute `validate` after this number of change.\\r\\n check_each_change = config.tensor.insert_inplace_optimizer_validate_nb\\r\\n if check_each_change == -1:\\r\\n if len(fgraph.apply_nodes) > 500:\\r\\n check_each_change = 10\\r\\n else:\\r\\n check_each_change = 1\\r\\n\\r\\n nb_change_no_validate = 0\\r\\n chk = fgraph.checkpoint()\\r\\n\\r\\n for node in list(graph.io_toposort(fgraph.inputs, fgraph.outputs)):\\r\\n op = node.op\\r\\n if not isinstance(op, OP):\\r\\n continue\\r\\n baseline = op.inplace_pattern\\r\\n protected_inputs = [\\r\\n f.protected for f in node.fgraph._features if\\r\\n isinstance(f, theano.compile.function_module.Supervisor)]\\r\\n protected_inputs = sum(protected_inputs, []) # flatten the list\\r\\n protected_inputs.extend(fgraph.outputs)\\r\\n candidate_outputs = [i for i in xrange(len(node.outputs))\\r\\n if i not in baseline]\\r\\n # node inputs that are Constant, already destroyed,\\r\\n # fgraph protected inputs and fgraph outputs can't be used as inplace\\r\\n # target.\\r\\n # Remove here as faster.\\r\\n candidate_inputs = [i for i in xrange(len(node.inputs))\\r\\n if i not in baseline.values() \\\\\\r\\n and not isinstance(node.inputs[i],\\r\\n Constant)\\\\\\r\\n and not fgraph.destroyers(node.inputs[i])\\\\\\r\\n and node.inputs[i] not in protected_inputs]\\r\\n\\r\\n verbose = False\\r\\n\\r\\n raised_warning = not verbose\\r\\n\\r\\n for candidate_output in candidate_outputs:\\r\\n for candidate_input in candidate_inputs:\\r\\n #remove inputs that don't have the same dtype as the output\\r\\n if node.inputs[candidate_input].type != node.outputs[\\r\\n candidate_output].type:\\r\\n continue\\r\\n\\r\\n inplace_pattern = dict(baseline)\\r\\n inplace_pattern[candidate_output] = candidate_input\\r\\n try:\\r\\n if hasattr(op.scalar_op, \\\"make_new_inplace\\\"):\\r\\n new_scal = op.scalar_op.make_new_inplace(\\r\\n scalar.transfer_type(\\r\\n *[inplace_pattern.get(i, None) \\\\\\r\\n for i in xrange(len(node.outputs))]))\\r\\n else:\\r\\n new_scal = op.scalar_op.__class__(\\r\\n scalar.transfer_type(\\r\\n *[inplace_pattern.get(i, None) \\\\\\r\\n for i in xrange(len(node.outputs))]))\\r\\n new_outputs = OP(new_scal, inplace_pattern)(\\r\\n *node.inputs, **dict(return_list=True))\\r\\n new_node = new_outputs[0].owner\\r\\n\\r\\n for r, new_r in zip(node.outputs, new_outputs):\\r\\n fgraph.replace(r, new_r,\\r\\n reason=\\\"inplace_elemwise_optimizer\\\")\\r\\n nb_change_no_validate += 1\\r\\n if nb_change_no_validate >= check_each_change:\\r\\n fgraph.validate()\\r\\n chk = fgraph.checkpoint()\\r\\n nb_change_no_validate = 0\\r\\n except (ValueError, TypeError, InconsistencyError), e:\\r\\n if check_each_change != 1 and not raised_warning:\\r\\n print >> sys.stderr, (\\r\\n \\\"Some inplace optimization was not \\\"\\r\\n \\\"performed due to unexpected error:\\\")\\r\\n print >> sys.stderr, e\\r\\n raised_warning = True\\r\\n fgraph.revert(chk)\\r\\n continue\\r\\n candidate_inputs.remove(candidate_input)\\r\\n node = new_node\\r\\n baseline = inplace_pattern\\r\\n break\\r\\n\\r\\n if nb_change_no_validate > 0:\\r\\n try:\\r\\n fgraph.validate()\\r\\n except Exception:\\r\\n if not raised_warning:\\r\\n print >> sys.stderr, (\\\"Some inplace optimization was not \\\"\\r\\n \\\"performed due to unexpected error\\\")\\r\\n fgraph.revert(chk)\\r\\n return inplace_elemwise_optimizer\",\n \"def my_original(x):\\n return x + x * x\",\n \"def assign_in_place_subblock(A, a, i, j):\\n bi = 2*i\\n bj = 2*j\\n A[bi, bj] = a[0, 0]\\n A[bi, bj+1] = a[0, 1]\\n A[bi+1, bj] = a[1, 0]\\n A[bi+1, bj+1] = a[1, 1]\",\n \"def test_deepcopy(self):\\n t = Reverse(Quantize())\\n t.transform([2])\\n copy.deepcopy(t)\",\n \"def update(src):\",\n \"def pow_inplace(a, b):\",\n \"def replace(self, index, value):\\n index += self.n\\n self.data[index] = value\\n index //= 2\\n while index > 0:\\n self.data[index] = self.func(self.data[2*index], self.data[2*index+1])\\n index //= 2\",\n \"def fL():\\n for n in b.allNodes():\\n n.autoplace()\",\n \"def test_unsized(self):\\n cache = LRUCache()\\n for i in range(500):\\n cache[i] = i\\n for i in range(500):\\n assert i in cache\\n assert cache[i] == i\",\n \"def __opExpand1(self,that,op, out=None):\\n A = self\\n B = that if isinstance(that,Factor) else Factor([],that)\\n vall = A.v | B.v\\n axA = list(map(lambda x:A.v.index(x) if x in A.v else -1 ,vall))\\n axB = list(map(lambda x:B.v.index(x) if x in B.v else -1 ,vall))\\n if ( (not (out is None)) and (out.v == vall) ):\\n f = out\\n else:\\n f = Factor(vall) # TODO: should also change \\\"out\\\" if specified!\\n it = np.nditer([A.t, B.t, f.t], \\n op_axes = [ axA, axB, None ], \\n op_flags=[['readonly'], ['readonly'], ['writeonly']])\\n for (i,j,k) in it:\\n op(i,j,out=k)\\n return f\",\n \"def test_byteps_push_pull_inplace(self):\\n size = bps.size()\\n dtypes = ['float16', 'float32', 'float64']\\n dims = [1, 2, 3]\\n count = 0\\n ctx = self._current_context()\\n shapes = [(), (17), (17, 17), (17, 17, 17)]\\n for dtype, dim in itertools.product(dtypes, dims):\\n mx.random.seed(1234, ctx=ctx)\\n tensor = mx.nd.random.uniform(-100, 100, shape=shapes[dim],\\n ctx=ctx)\\n tensor = tensor.astype(dtype)\\n multiplied = tensor.copy()\\n bps.byteps_declare_tensor(\\\"tensor_\\\" + str(count))\\n bps.byteps_push_pull(tensor, name=\\\"tensor_\\\" + str(count))\\n max_difference = mx.nd.max(mx.nd.subtract(tensor, multiplied))\\n count += 1\\n\\n # Threshold for floating point equality depends on number of\\n # ranks, since we're comparing against precise multiplication.\\n if size <= 3 or dtype in ['int32', 'int64']:\\n threshold = 0\\n elif size < 10:\\n threshold = 1e-4\\n elif size < 15:\\n threshold = 5e-4\\n else:\\n break\\n\\n if max_difference > threshold:\\n print(\\\"self\\\", count, dtype, dim, max_difference, threshold)\\n print(\\\"tensor\\\", bps.rank(), tensor)\\n print(\\\"multiplied\\\", bps.rank(), multiplied)\\n assert max_difference <= threshold, 'bps.byteps_push_pull produces \\\\\\n incorrect results for self'\\n\\n print('test_byteps_push_pull_inplace passed')\",\n \"def local_inplace_incsubtensor1(node):\\r\\n if isinstance(node.op, AdvancedIncSubtensor1) and not node.op.inplace:\\r\\n new_op = node.op.__class__(\\r\\n inplace=True, set_instead_of_inc=node.op.set_instead_of_inc)\\r\\n new_node = new_op(*node.inputs)\\r\\n return [new_node]\\r\\n return False\",\n \"def incr_operand(self):\\n pass\",\n \"def swish_(t: Tensor) -> Tensor:\\n ctx = get_current_context()\\n g = ctx.graph\\n pb_g = g._pb_graph\\n\\n check_in_graph(g, t=t)\\n\\n settings = ctx._get_op_settings(\\\"swish_inplace\\\")\\n op = pb_g.createConnectedOp_SwishInplaceOp(\\n {0: t.id}, \\n {\\n 0: g._create_tensor_id(\\\"swish_inplace_out\\\")\\n }, \\n settings\\n )\\n\\n return Tensor._from_pb_tensor(op.outTensor(0))\",\n \"def heappop(heap):\\n pass\",\n \"def replace_op(self, op, replacement):\\n self.replacement_list.append((op, replacement))\",\n \"def insertion_optimized_alt(array):\\n j = 0\\n for i,val in enumerate(array):\\n for j in range(i,-1,-1):\\n if j>0 and val<array[j-1]:\\n array[j] = array[j-1]\\n else:\\n break\\n array[j] = val\",\n \"def vectorized(self):\\n return False\",\n \"def JNZ():\\n global pointer, memory, registers\\n if registers[memory[pointer + 0x01]] != 0:\\n pointer = memory[pointer + 0x02]\\n return\\n\\n pointer += 0x03\",\n \"def test_inplace_optimization(self):\\r\\n #inplace = False\\r\\n rf2 = RandomFunction(numpy.random.RandomState.uniform, tensor.dvector)\\r\\n rng_R = random_state_type()\\r\\n\\r\\n # If calling RandomFunction directly, all args have to be specified,\\r\\n # because shape will have to be moved to the end\\r\\n post_r2, out2 = rf2(rng_R, (4,), 0., 1.)\\r\\n\\r\\n f = compile.function(\\r\\n [compile.In(rng_R,\\r\\n value=numpy.random.RandomState(utt.fetch_seed()),\\r\\n update=post_r2,\\r\\n mutable=True)],\\r\\n out2,\\r\\n mode='FAST_RUN') # DEBUG_MODE can't pass the id-based\\r\\n # test below\\r\\n\\r\\n # test that the RandomState object stays the same from function call to\\r\\n # function call, but that the values returned change from call to call.\\r\\n\\r\\n id0 = id(f[rng_R])\\r\\n val0 = f()\\r\\n assert id0 == id(f[rng_R])\\r\\n val1 = f()\\r\\n assert id0 == id(f[rng_R])\\r\\n\\r\\n assert not numpy.allclose(val0, val1)\",\n \"def arccosh_inplace(a):\",\n \"def _make_soft_copy_op(tau, target, online):\\n return target.assign_sub(tau * (target - online))\",\n \"def _make_soft_copy_op(tau, target, online):\\n return target.assign_sub(tau * (target - online))\",\n \"def revise():\",\n \"def update(self, action): \\n self.memory.pop(-1) \\n self.memory.insert(0, [self.last_state.cpu().numpy(), action.cpu().numpy()])\\n\\n self.last_action = action\",\n \"def arctan2_inplace(a, b):\",\n \"def _arg_swapper(op):\\n\\n def op_swapped(a, b, *args, **kwargs):\\n return op(b, a, *args, **kwargs)\\n\\n return op_swapped\",\n \"def __execute(self, instruction: Instruction) -> NoReturn:\\n\\n op, *args = instruction\\n logging.debug(f\\\"Executing: {op}\\\")\\n logging.debug(self.memory)\\n function_map[op](*args, memory=self.memory)\\n logging.debug(self.memory)\",\n \"def _scal_inplace(symbol):\\r\\n symbolname = symbol.__name__\\r\\n inplace = symbolname.endswith('_inplace')\\r\\n\\r\\n if inplace:\\r\\n scalar_op = getattr(scal, symbolname[:-len('_inplace')])\\r\\n inplace_scalar_op = scalar_op.__class__(scal.transfer_type(0))\\r\\n rval = elemwise.Elemwise(inplace_scalar_op, {0: 0}, name=symbolname)\\r\\n else:\\r\\n scalar_op = getattr(scal, symbolname)\\r\\n rval = elemwise.Elemwise(scalar_op, name=symbolname)\\r\\n\\r\\n if getattr(symbol, '__doc__', False):\\r\\n rval.__doc__ = symbol.__doc__ + '\\\\n' + rval.__doc__\\r\\n\\r\\n #for the meaning of this see the ./epydoc script\\r\\n # it makes epydoc display rval as if it were a function, not an object\\r\\n rval.__epydoc_asRoutine = symbol\\r\\n rval.__module__ = 'theano.tensor.inplace'\\r\\n\\r\\n def chk(pstate, r):\\r\\n if not r.owner:\\r\\n return False\\r\\n op = r.owner.op\\r\\n# print op, rval, r.owner and op == rval\\r\\n# print op.inplace_pattern, rval.inplace_pattern, op.inplace_pattern == rval.inplace_pattern\\r\\n# print op.scalar_op, rval.scalar_op, op.scalar_op == rval.scalar_op\\r\\n return r.owner.op == rval\\r\\n\\r\\n pprint.assign(chk, printing.FunctionPrinter(symbolname.replace('_inplace', '=')))\\r\\n return rval\",\n \"def pre_compute(self, e_list):\\n\\t\\tpass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6320513","0.63055974","0.6295562","0.6247203","0.6221748","0.61597484","0.6049256","0.60334474","0.6032077","0.5932389","0.5925243","0.5923073","0.5862695","0.58618164","0.58565295","0.5828316","0.5803157","0.5762689","0.5715238","0.56960684","0.56938374","0.56680715","0.5661758","0.5620224","0.5565305","0.55537784","0.55132","0.54884785","0.54776216","0.5435641","0.5430816","0.54207224","0.54089797","0.5391752","0.5388715","0.53868556","0.5378204","0.5372077","0.5364736","0.5362026","0.5335219","0.5321193","0.5309115","0.529487","0.5291642","0.5277444","0.5265059","0.5253823","0.5239381","0.5232589","0.522635","0.5215159","0.5179893","0.5168081","0.51674414","0.51674414","0.5159805","0.5159805","0.5152936","0.5150079","0.5134569","0.512928","0.5124967","0.5124396","0.5114645","0.51111174","0.51087797","0.5105814","0.51025856","0.51022756","0.51002115","0.5094164","0.509124","0.5085856","0.50835747","0.50814706","0.5071718","0.5067038","0.5065559","0.5057934","0.50520897","0.5046512","0.5045801","0.5031939","0.5029039","0.50270516","0.5023617","0.5023061","0.50214756","0.5020136","0.50109947","0.50101095","0.5006499","0.5006499","0.50046265","0.50031346","0.49955085","0.49903566","0.4980284","0.4972389","0.49695513"],"string":"[\n \"0.6320513\",\n \"0.63055974\",\n \"0.6295562\",\n \"0.6247203\",\n \"0.6221748\",\n \"0.61597484\",\n \"0.6049256\",\n \"0.60334474\",\n \"0.6032077\",\n \"0.5932389\",\n \"0.5925243\",\n \"0.5923073\",\n \"0.5862695\",\n \"0.58618164\",\n \"0.58565295\",\n \"0.5828316\",\n \"0.5803157\",\n \"0.5762689\",\n \"0.5715238\",\n \"0.56960684\",\n \"0.56938374\",\n \"0.56680715\",\n \"0.5661758\",\n \"0.5620224\",\n \"0.5565305\",\n \"0.55537784\",\n \"0.55132\",\n \"0.54884785\",\n \"0.54776216\",\n \"0.5435641\",\n \"0.5430816\",\n \"0.54207224\",\n \"0.54089797\",\n \"0.5391752\",\n \"0.5388715\",\n \"0.53868556\",\n \"0.5378204\",\n \"0.5372077\",\n \"0.5364736\",\n \"0.5362026\",\n \"0.5335219\",\n \"0.5321193\",\n \"0.5309115\",\n \"0.529487\",\n \"0.5291642\",\n \"0.5277444\",\n \"0.5265059\",\n \"0.5253823\",\n \"0.5239381\",\n \"0.5232589\",\n \"0.522635\",\n \"0.5215159\",\n \"0.5179893\",\n \"0.5168081\",\n \"0.51674414\",\n \"0.51674414\",\n \"0.5159805\",\n \"0.5159805\",\n \"0.5152936\",\n \"0.5150079\",\n \"0.5134569\",\n \"0.512928\",\n \"0.5124967\",\n \"0.5124396\",\n \"0.5114645\",\n \"0.51111174\",\n \"0.51087797\",\n \"0.5105814\",\n \"0.51025856\",\n \"0.51022756\",\n \"0.51002115\",\n \"0.5094164\",\n \"0.509124\",\n \"0.5085856\",\n \"0.50835747\",\n \"0.50814706\",\n \"0.5071718\",\n \"0.5067038\",\n \"0.5065559\",\n \"0.5057934\",\n \"0.50520897\",\n \"0.5046512\",\n \"0.5045801\",\n \"0.5031939\",\n \"0.5029039\",\n \"0.50270516\",\n \"0.5023617\",\n \"0.5023061\",\n \"0.50214756\",\n \"0.5020136\",\n \"0.50109947\",\n \"0.50101095\",\n \"0.5006499\",\n \"0.5006499\",\n \"0.50046265\",\n \"0.50031346\",\n \"0.49955085\",\n \"0.49903566\",\n \"0.4980284\",\n \"0.4972389\",\n \"0.49695513\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93478,"cells":{"query":{"kind":"string","value":"Return a copy of the cVLS, but trim some points between triple junctions using one of several approaches."},"document":{"kind":"string","value":"def GetCVLSWithLimitedPointsBetweenNodes(\n cVLS, allValsByFrame, splitLength=1, fixedNumInteriorPoints=None, interpolate=True\n):\n allValues = list(set(tuple(flatten(allValsByFrame))))\n allPairs = sorted(\n list(set([tuple(c[0]) for cVLSByFrame in cVLS for c in cVLSByFrame]))\n ) # Value pairs...\n\n if fixedNumInteriorPoints:\n numInteriorPoints = {p: fixedNumInteriorPoints for p in allPairs}\n else:\n minLength = {}\n for p in allPairs:\n # minLength is the number of points of the shortest subcountour between cells p[0] and p[1] from all frames\n minLength[p] = min(\n [\n len(c[2])\n for cVLSByFrame in cVLS\n for c in cVLSByFrame\n if tuple(c[0]) == p\n ]\n )\n # length of subcontour\n numInteriorPoints = {}\n for p in allPairs:\n numInteriorPoints[p] = minLength[p] // splitLength\n\n cVLS2 = deepcopy(\n cVLS\n ) # otherwise, we'd also change the input argument cVLS in the outside world!\n limIntPtsFunc = (\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\n )\n\n for cvlsByFrame in cVLS2:\n for c in cvlsByFrame:\n c[2] = limIntPtsFunc(c[2], numInteriorPoints[tuple(c[0])])\n\n return cVLS2"},"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 decomposing_line_cut_by_splicing(P, v, w):\n\n\n\tv_Point = Point(v)\n\tw_Point = Point(w)\n\n\tchain = LineString(P[0]+[P[0][0]])\n\n\tdistance_to_v = chain.project(v_Point)\n\tdistance_to_w = chain.project(w_Point)\n\n\tif not chain.intersects(v_Point):\n\t\tprint(\"decomposing_cut_as_line: V not on chain\")\n\tif not chain.intersects(w_Point):\n\t\tprint(\"decomposing_cut_as_line: W not on chain\")\n\tif distance_to_w == distance_to_v:\n\t\tprint(\"decomposing_cut_as_line: W and V are the same\")\n\n\n\tif distance_to_w >= chain.length or distance_to_w == 0:\n\n\t\tleft_chain, right_chain = cut_linestring(chain, distance_to_v)\n\n\t\tp_l = left_chain.coords[:]\n\t\tp_r = right_chain.coords[:]\t\t\n\n\t\treturn p_l, p_r\n\n\tif distance_to_v >= chain.length or distance_to_v == 0:\n\n\t\tleft_chain, right_chain = cut_linestring(chain, distance_to_w)\n\n\t\tp_l = right_chain.coords[:]\n\t\tp_r = left_chain.coords[:]\t\t\n\n\t\treturn p_l, p_r\n\n\n\tif distance_to_w > distance_to_v:\n\n\t\tleft_v_cut, right_v_cut = cut_linestring(chain, distance_to_v)\n\n\t\tdistance_to_w = right_v_cut.project(w_Point)\n\t\tleft_w_chain, right_w_chain = cut_linestring(right_v_cut, distance_to_w)\n\n\t\tp_l = left_v_cut.coords[:]+right_w_chain.coords[:-1]\n\t\tp_r = left_w_chain.coords[:]\n\n\t\treturn p_l, p_r\n\n\telse:\n\n\t\tleft_w_cut, right_w_cut = cut_linestring(chain, distance_to_w)\n\n\t\tdistance_to_v = right_w_cut.project(v_Point)\n\t\tleft_v_chain, right_v_chain = cut_linestring(right_w_cut, distance_to_v)\n\n\t\tp_l = left_w_cut.coords[:]+right_v_chain.coords[:-1]\n\t\tp_r = left_v_chain.coords[:]\n\n\t\treturn p_l, p_r","def decomposing_poly_cut_by_set_op(P, v, w, epsilon=10e-2):\n\n\n\tgetcontext().prec = 28\n\n\tv_Point = Point(v)\n\tw_Point = Point(w)\n\n\tchain = LineString(P[0]+[P[0][0]])\n\n\tif not chain.intersects(v_Point):\n\t\tprint(\"decomposing_poly_cut_as_line: V not on chain\")\n\tif not chain.intersects(w_Point):\n\t\tprint(\"decomposing_poly_cut_as_line: W not on chain\")\n\n\n\tdistance_to_v = chain.project(v_Point)\n\tdistance_to_w = chain.project(w_Point)\n\n\tif distance_to_w == distance_to_v:\n\t\tprint(\"decomposing_cut_as_line: W and V are the same\")\n\n\n\t# Generate pairs of v and w modified by some epsilon amount \n\tv_l_displacements = [distance_to_v+(i*epsilon) for i in [-1, -2, 0]]\n\tv_r_displacements = [(distance_to_v+(i*epsilon))%chain.length for i in [1, 0, 2]]\n\tw_l_displacements = [distance_to_w+(i*epsilon) for i in [-1, -2, 0]]\n\tw_r_displacements = [(distance_to_w+(i*epsilon))%chain.length for i in [1, 0, 2]]\n\n\tdef splice_polygon(dist_v, dist_w):\n\t\t\"\"\"Portion of decomposing_line_cut_by_splicing wihtout points\n\n\t\tFunction for evaluating validity of candidates\n\t\t\"\"\"\n\n\t\tif dist_w >= chain.length or dist_w == 0:\n\n\t\t\tleft_chain, right_chain = cut_linestring(chain, dist_v)\n\n\t\t\tp_l = left_chain.coords[:]\n\t\t\tp_r = right_chain.coords[:]\t\t\n\n\t\t\treturn p_l, p_r\n\n\t\tif dist_v >= chain.length or dist_v == 0:\n\n\t\t\tleft_chain, right_chain = cut_linestring(chain, dist_w)\n\n\t\t\tp_l = right_chain.coords[:]\n\t\t\tp_r = left_chain.coords[:]\t\t\n\n\t\t\treturn p_l, p_r\n\n\n\t\tif dist_w%chain.length > dist_v%chain.length:\n\n\t\t\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\n\t\t\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\n\n\t\t\tcommon = LineString(left_w_chain).difference(LineString(left_v_chain))\n\n\t\t\tp_l = left_v_chain.coords[:]+right_w_chain.coords[:-1]\n\t\t\tp_r = common.coords[:]\n\n\t\t\treturn p_l, p_r\n\n\t\telse:\n\n\t\t\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\n\t\t\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\n\n\t\t\tcommon = LineString(left_v_chain).difference(LineString(left_w_chain))\n\n\t\t\tp_l = common.coords[:]\n\t\t\tp_r = left_w_chain.coords[:]+right_v_chain.coords[:-1]\n\n\t\t\treturn p_l, p_r\n\n\t# Check every ring for self-intersection, if cut is invalid => self-intersec\n\tfound = False\n\tfor i in range(len(v_l_displacements)):\n\t\tfor j in range(len(w_l_displacements)):\n\n\t\t\t# Check if resultant polygons are valid\n\t\t\tp_l, p_r = splice_polygon(v_l_displacements[i], w_r_displacements[j])\n\t\t\tp_l_lr = LinearRing(p_l+[p_l[0]])\n\t\t\tp_r_lr = LinearRing(p_r+[p_r[0]])\n\n\t\t\tif not p_l_lr.is_valid or not p_r_lr.is_valid:\n\t\t\t\tcontinue\n\n\t\t\tp_l, p_r = splice_polygon(v_r_displacements[i], w_l_displacements[j])\n\t\t\tp_l_lr = LinearRing(p_l+[p_l[0]])\n\t\t\tp_r_lr = LinearRing(p_r+[p_r[0]])\n\n\t\t\tif not p_l_lr.is_valid or not p_r_lr.is_valid:\n\t\t\t\tcontinue\n\n\t\t\t# Else, we have a valid candidate cut\n\t\t\tfound = True\n\t\t\tbreak\n\n\t\tif found:\n\t\t\tbreak\n\n\tif not found:\n\t\tprint(\"splice_polygon: No correct cut combination found!\")\n\t\treturn\n\n\tv_l = chain.interpolate(v_l_displacements[i]).coords[:]\n\tv_r = chain.interpolate(v_r_displacements[i]).coords[:]\n\tw_l = chain.interpolate(w_l_displacements[j]).coords[:]\n\tw_r = chain.interpolate(w_r_displacements[j]).coords[:]\n\n\tdef get_verts(v_l, v_r):\n\t\t\"\"\"Function for extraction verts between two points\n\t\t\"\"\"\n\n\t\tv_l = v_l%chain.length\n\t\tv_r = v_r%chain.length\n\n\t\tpoints = []\n\t\tcoords = list(chain.coords)\n\t\tif v_r > v_l:\n\n\t\t\tfor i in range(1, len(coords)):\n\t\t\t\n\t\t\t\tpd = LineString(coords[:i+1]).length\n\n\t\t\t\tif pd > v_l and pd < v_r:\n\t\t\t\t\tpoints.append(coords[i])\n\t\telse:\n\n\t\t\tfor i in range(1, len(coords)):\n\t\t\t\n\t\t\t\tpd = LineString(coords[:i+1]).length\n\n\t\t\t\tif pd > v_l:\n\t\t\t\t\tpoints.append(coords[i])\n\n\t\t\tfor i in range(1, len(coords)):\n\t\t\t\n\t\t\t\tpd = LineString(coords[:i+1]).length\n\n\t\t\t\tif pd < v_r:\n\t\t\t\t\tpoints.append(coords[i])\n\n\n\t\treturn points\n\n\t# Find all vertecies of the chain betwee v_l and v_r\n\tv_pts = get_verts(v_l_displacements[i], v_r_displacements[i])\n\tw_pts = get_verts(w_l_displacements[j], w_r_displacements[j])\n\n\tpoly = Polygon(*P)\n\n\tcut_poly = Polygon(v_l+v_pts+v_r+w_l+w_pts+w_r)\n\tcut_poly = poly.intersection(cut_poly)\n\n\tprint cut_poly\n\n\tp_l, p_r = poly.difference(cut_poly)\n\n\tprint p_l\n\tprint p_r","def simplify(self):\n \n added_clumps = []\n staying_tunnels = []\n removed_clumps = set()\n \n for tunnel in self.tunnels:\n tunnel_end_distance = self.get_distance(tunnel.start, tunnel.end)\n if tunnel_end_distance - tunnel.start.distance_from_wall < 0 or \\\n tunnel_end_distance - tunnel.end.distance_from_wall < 0:\n removed_clumps.add(tunnel.start.node)\n removed_clumps.add(tunnel.end.node)\n new_node = tunnel.merge_endpoints()\n added_clumps.append(new_node)\n else:\n staying_tunnels.append(tunnel)\n #print removed_clumps\n \n new_clumps = []\n \n for clump in list(self.clumps) + added_clumps:\n if clump not in removed_clumps:\n new_clumps.append(clump)\n else:\n removed_clumps.remove(clump)\n\n if removed_clumps:\n raise Exception(\"Some removed clumps couldn't be found in the main set and I'm scared\")\n \n self.clumps = new_clumps\n self.tunnels = staying_tunnels","def unfold_wire(pl):\n\tpl = phone_pl\n\tshape_points = [np.array(p) for p in pl.points]\n\tpointIter = takeNGenerator(shape_points, 4)\n\td0 = getDistance(*shape_points[0:2])\n\tpoints = [np.array([0, 0]), np.array([0, d0])]\n\tfor i in range(len(shape_points)-3):\n\t\t(p1,p2,p3,p4) = pointIter.next()\n\t\tv1 =p1-p2\n\t\tv2 = p3-p2\n\t\tv3 = p2-p3\n\t\tv4 = p4-p3\n\t\told_normal = np.cross(v1,v2)\n\t\tnew_normal = np.cross(v3,v4)\n\t\tnorm_old = old_normal/la.norm(old_normal)\n\t\tnorm_new = old_normal/la.norm(new_normal)\n\n\n\t\t#check if we need to transform:\n\t\tif any(norm_old != norm_new):\n\t\t\tprint norm_old, norm_new\n\t\t\t#create a transform that will rotate the next points to the old orientation\n\t\t\ttransform = create_transform(norm_new, norm_old)\n\t\t\trot_pot = p2\n\t\t\tpose = (rot_pot, transform)\n\t\t\tpoly = PolyLine(shape_points[i:])\n\t\t\ttranslated = poly.transformed(pose)\n\t\t\tnew_pts = [np.array(p) for p in translated.points]\n\n\t\t\tif len(shape_points[:i]) is 0:\n\t\t\t\tshape_points = new_pts\n\t\t\telse:\n\t\t\t\tshape_points = np.vstack((shape_points[:i], new_pts))\n\t\t\tpointIter = takeNGenerator(shape_points, 4)\n\t\t\tfast_forward(pointIter, i)\n\treturn PolyLine(shape_points)","def simplify_line_vw(points, small_area=100):\r\n while len(points) > 3:\r\n \r\n # For each coordinate that forms the apex of a two-segment\r\n # triangle, find the area of that triangle and put it into a list\r\n # along with the index, ordered from smallest to largest.\r\n \r\n popped, preserved = set(), set()\r\n \r\n triples = zip(points[:-2], points[1:-1], points[2:])\r\n triangles = [Polygon((p1, p2, p3)) for (p1, p2, p3) in triples]\r\n areas = [(triangle.area, index) for (index, triangle) in enumerate(triangles)]\r\n \r\n # Reduce any segments that makes a triangle whose area is below\r\n # the minimum threshold, starting with the smallest and working up.\r\n # Mark segments to be preserved until the next iteration.\r\n\r\n for (area, index) in sorted(areas):\r\n if area > small_area:\r\n # nothing more can be removed on this iteration\r\n break\r\n \r\n if (index + 1) in preserved:\r\n # current index is too close to a previously-preserved one\r\n continue\r\n \r\n preserved.add(index)\r\n popped.add(index + 1)\r\n preserved.add(index + 2)\r\n \r\n if not popped:\r\n # nothing was removed so we are done\r\n break\r\n \r\n # reduce the line, then try again\r\n points = [point for (index, point) in enumerate(points) if index not in popped]\r\n \r\n return list(points)","def coll_trim(th):\n lam = TipLoss(lamInit, th)\n AoA = th - lam / r\n dCL, dCD = PolarLookup(AoA)\n dCT = 0.5 * solDist * (dCL*np.cos(lam/r)-dCD*np.sin(lam/r))* r ** 2\n # dCT = 0.5 * solDist * dCL * r ** 2\n CT = np.trapz(dCT, r)\n\n return CT, dCT, dCL, dCD, lam, AoA","def clean_up(P, c):\n if not P.pairs: return # root case\n P.siblings.pop()\n s,r = P.pairs.pop()\n P.shape_pool.add(s)\n P.resource_pool.add(r)\n if P.r2p:\n pathway_id = P.r2p[P.resources[r]]\n if c and c[pathway_id]:\n c[pathway_id].pop()\n if P.segments[pathway_id]:\n P.segments[pathway_id].pop()","def attempt_splice(triple):\n\n def overlap_condition(triple):\n \"\"\"\n Decide whether these paths meet the overlap condition.\n Return fwd, rev, and overlap for next steps.\n \"\"\"\n p3_len = len(self.paths[triple[2]])\n\n fwd = compute_fwd(self.paths[triple[0]], self.paths[triple[2]])\n rev = compute_rev(self.paths[triple[2]], self.paths[triple[1]])\n overlap = rev + fwd - p3_len\n if fwd + rev - p3_len >= 0:\n print(\"# Triple {} meets overlap condition.\".format(triple))\n #print(\"fwd = {}, rev = {}, lap = {}\".format(fwd, rev, overlap))\n return(True, fwd, rev, overlap)\n return(False, fwd, rev, overlap)\n\n\n def flow_condition(p_prime, p3, triple):\n \"\"\"Process two potential paths resulting from a set of three\n paths.\"\"\"\n\n all_edges = set(self.arc_info.keys())\n not_p_prime = all_edges.difference(set(p_prime))\n #print(\"Not p_prime: {}\".format(not_p_prime))\n not_p3 = all_edges.difference(set(p3))\n #print(\"Not p_3: {}\".format(not_p3))\n p_prime_alone = list(set(p_prime).intersection(not_p3))\n #print(\"p_prime_alone: {}\".format(p_prime_alone))\n p3_alone = list(set(p3).intersection(not_p_prime))\n #print(\"p3 alone: {}\".format(p3_alone))\n overlap = list(set(p3).intersection(p_prime))\n #print(\"overlap alone: {}\".format(overlap))\n\n #print(\"computing L_wprime and U_wprime\")\n L_wprime, U_wprime = compute_bounds(p_prime_alone, triple)\n #print(\"computing L_w3 and U_w3\")\n L_w3, U_w3 = compute_bounds(p3_alone, triple)\n #print(\"computing L_overlap and U_overlap\")\n L_overlap, U_overlap = compute_bounds(overlap, triple)\n #print(\"L_wprime, U_wprime: {} {}\".format(L_wprime, U_wprime))\n #print(\"L_w3, U_w3: {} {}\".format(L_w3, U_w3))\n #print(\"{} <= {}\".format(L_overlap, U_wprime + U_w3))\n #print(\"{} >= {}\".format(U_overlap, L_wprime + L_w3))\n meets_conditions = (L_wprime <= U_wprime) & \\\n (L_w3 <= U_w3) & \\\n (L_overlap <= U_wprime + U_w3) & \\\n (L_wprime + L_w3 <= U_overlap)\n if meets_conditions:\n w_prime, w3 = center_flows(L_wprime, U_wprime,\n L_w3, U_w3,\n L_overlap, U_overlap)\n # change paths\n # first, delete:\n for index in sorted(triple, reverse=True):\n del self.paths[index]\n del self.weights[index]\n # now, add:\n self.paths.append(p3)\n self.paths.append(p_prime)\n self.weights.append(w3)\n self.weights.append(w_prime)\n # update weights on edges\n self.update_edge_weights()\n self.check_flow()\n self.check_paths()\n return(True)\n else:\n return(False)\n\n\n def check_flow_conditions(triple, fwd, rev, overlap):\n \"\"\"Check that the flow condition is met.\n If it is, return the new paths with weights.\"\"\"\n\n p1, p2, p3 = [self.paths[triple[x]] for x in [0,1,2]]\n p2_end_index = len(p2) - rev + overlap\n #print(\"p2_end_index = {}\".format(p2_end_index))\n p1_start_index = fwd + 1\n #print(\"p1_start_index = {}\".format(p1_start_index))\n #print(\"p1 subset: {}\".format(p1[p1_start_index - 1:]))\n #print(\"p2 subset = {}\".format(p2[:p2_end_index]))\n p_prime = p2[:p2_end_index] + p1[p1_start_index - 1:]\n #print(\"p_prime = {}\".format(p_prime))\n\n # try to rebalance\n if flow_condition(p1, p2, triple):\n print(\"Rebalance opportunity found. Now rebalancing.\")\n self.rebalances += 1\n return(True)\n\n # try to splice and merge\n if flow_condition(p_prime, p3, triple):\n print(\"Splice+merge opportunity found. Now splicing.\")\n self.splices += 1\n return(True)\n\n return(False)\n\n\n #print(\"# Can we splice {}?\".format(\n # [self.paths[x] for x in triple]))\n overlap_true, fwd_index, rev_index, overlap = overlap_condition(\n triple)\n if overlap_true:\n self.overlap_count += 1\n return(check_flow_conditions(triple,\n fwd_index, rev_index, overlap))\n return(False)","def prune_delta(links, nodes, shoreline_shp, inlets_shp, gdobj,\r\n prune_less):\r\n # Get inlet nodes\r\n nodes = find_inlet_nodes(nodes, inlets_shp, gdobj)\r\n\r\n if prune_less is False:\r\n # Remove spurs from network (this includes valid inlets and outlets)\r\n links, nodes = lnu.remove_all_spurs(links, nodes,\r\n dontremove=list(nodes['inlets']))\r\n\r\n # Clip the network with a shoreline polyline, adding outlet nodes\r\n links, nodes = clip_by_shoreline(links, nodes, shoreline_shp, gdobj)\r\n\r\n # Remove spurs from network (this includes valid inlets and outlets)\r\n links, nodes = lnu.remove_all_spurs(links, nodes,\r\n dontremove=list(nodes['inlets']) +\r\n list(nodes['outlets']))\r\n\r\n # Remove sets of links that are disconnected from inlets/outlets except for\r\n # a single bridge link (effectively re-pruning the network)\r\n links, nodes = lnu.remove_disconnected_bridge_links(links, nodes)\r\n\r\n # # Add artificial nodes where necessary\r\n # links, nodes = lnu.add_artificial_nodes(links, nodes, gdobj)\r\n\r\n # Remove one-node links\r\n links, nodes = lnu.remove_single_pixel_links(links, nodes)\r\n\r\n # Find parallel links\r\n links, nodes = lnu.find_parallel_links(links, nodes)\r\n\r\n return links, nodes","def cleanOpenBranches(skeleton, skelton_copy, points, radii, length, clean = True, verbose = False):\n \n assert np.isfortran(skeleton);\n assert np.isfortran(skelton_copy);\n \n timer = tmr.Timer();\n timer_all = tmr.Timer();\n \n # find branch and end points\n deg = cpl.convolve_3d_indices(skeleton, t3d.n26, points, out_dtype = 'uint8');\n branchpoints = points[deg >= 3];\n e_pts = points[deg == 1];\n \n if verbose:\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\n timer.reset();\n \n #prepare temps\n #skel = skeleton.copy();\n skel_flat = np.reshape(skelton_copy, -1, order = 'A');\n strides = np.array(skelton_copy.strides);\n \n \n if verbose:\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\n timer.reset();\n \n label = np.arange(27);\n label = label.reshape([3,3,3]);\n label[1,1,1] = 0;\n \n critical_points = [e_pts];\n delete_points = [];\n \n for l in range(1, length + 1):\n #neighbours of end points\n e_pts_label = cpl.convolve_3d_indices(skelton_copy, label, e_pts);\n \n if verbose:\n timer.printElapsedTime('Done labeling %d / %d' % (l, length));\n timer.reset();\n \n #label zero points are non-critical short isolated branches\n e_pts_zero = e_pts_label == 0;\n #print 'zero length:', np.unravel_index(e_pts[e_pts_zero], skel.shape)\n if e_pts_zero.sum() > 0:\n keep = np.logical_not(e_pts_zero);\n for m in range(l):\n critical_points[m] = critical_points[m][keep];\n e_pts_label = e_pts_label[keep];\n e_pts = e_pts[keep];\n \n if verbose:\n timer.printElapsedTime('Ignored %d small branches' % (keep.sum()));\n timer.reset();\n \n e_pts_new = e_pts + np.sum((np.vstack(np.unravel_index(e_pts_label, label.shape)) - 1).T * strides, axis = 1)\n \n # did we hit a branch point\n delete = np.in1d(e_pts_new, branchpoints); #, assume_unique = True);\n keep = np.logical_not(delete);\n #print delete.shape, keep.shape, e_pts_new.shape\n \n #delete all path that hit a branch point\n if delete.sum() > 0:\n for m in range(l):\n delete_points.append(critical_points[m][delete]);\n #print 'deleting:', np.unravel_index(critical_points[m][delete], skel.shape)\n critical_points[m] = critical_points[m][keep];\n e_pts_new = e_pts_new[keep];\n \n if verbose:\n timer.printElapsedTime('Deleted %d points' % (delete.sum()));\n timer.reset();\n \n if l < length:\n skel_flat[e_pts] = False; # remove endpoints for new neighbour detection\n critical_points.append(e_pts_new);\n e_pts = e_pts_new;\n \n if verbose:\n timer.printElapsedTime('Cleanup iteration %d / %d done.' % (l, length));\n \n #gather all points\n if len(delete_points) > 0:\n delete_points = np.hstack(delete_points);\n delete_points = np.unique(delete_points);\n else:\n delete_points = np.zeros(0);\n \n if verbose:\n timer_all.printElapsedTime('Cleanup');\n \n if clean:\n skel_flat = np.reshape(skeleton, -1, order = 'F');\n skel_flat[delete_points] = False;\n keep_ids = np.logical_not(np.in1d(points, delete_points, assume_unique = True))\n points = points[keep_ids];\n radii = radii[keep_ids];\n return skeleton, points, radii\n \n return delete_points;","def splice_polygon(dist_v, dist_w):\n\n\t\tif dist_w >= chain.length or dist_w == 0:\n\n\t\t\tleft_chain, right_chain = cut_linestring(chain, dist_v)\n\n\t\t\tp_l = left_chain.coords[:]\n\t\t\tp_r = right_chain.coords[:]\t\t\n\n\t\t\treturn p_l, p_r\n\n\t\tif dist_v >= chain.length or dist_v == 0:\n\n\t\t\tleft_chain, right_chain = cut_linestring(chain, dist_w)\n\n\t\t\tp_l = right_chain.coords[:]\n\t\t\tp_r = left_chain.coords[:]\t\t\n\n\t\t\treturn p_l, p_r\n\n\n\t\tif dist_w%chain.length > dist_v%chain.length:\n\n\t\t\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\n\t\t\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\n\n\t\t\tcommon = LineString(left_w_chain).difference(LineString(left_v_chain))\n\n\t\t\tp_l = left_v_chain.coords[:]+right_w_chain.coords[:-1]\n\t\t\tp_r = common.coords[:]\n\n\t\t\treturn p_l, p_r\n\n\t\telse:\n\n\t\t\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\n\t\t\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\n\n\t\t\tcommon = LineString(left_v_chain).difference(LineString(left_w_chain))\n\n\t\t\tp_l = common.coords[:]\n\t\t\tp_r = left_w_chain.coords[:]+right_v_chain.coords[:-1]\n\n\t\t\treturn p_l, p_r","def _mps_truncateC(self, C, Dmax, tol):\n U, S, V = svd(C)\n tol = max(np.finfo(float).eps, tol)\n keep = min(sum(S > (S[0] * tol)), Dmax)\n projR = V[:keep, :]\n projL = U[:, :keep]\n discarded = np.sqrt(sum(S[keep:]**2)) / S[0]\n S = np.diag(S[:keep])\n return projL, S, projR, keep, discarded","def simplify(self):\n # First remove all simple loops\n while self._removeTripleLoop():\n pass\n\n # First remove all simple loops\n while self._removeSimpleLoop():\n pass\n\n # Iteratively remove vacuums until finished\n while self._remove_vacuumcoupling():\n pass\n\n return self","def prune_short_lines(lines, min_length): \n pruned_lines = [line for line in lines] # converts MultiLineString to list\n to_prune = []\n \n for i, line in enumerate(pruned_lines):\n if line.length < min_length:\n to_prune.append(i)\n for n in neighbors(pruned_lines, line):\n contact_point = line.intersection(pruned_lines[n])\n pruned_lines[n] = bend_towards(pruned_lines[n], \n where=contact_point,\n to=line.centroid)\n \n return [line for i, line in enumerate(pruned_lines) if i not in to_prune]","def __create_chain_roads(self, roads: Set[JuncRoadSingleConnection], with_removed=False) \\\n -> Union[List[JuncRoadChainConnection], Tuple[List[JuncRoadChainConnection], int]]:\n chain_connections: List[JuncRoadChainConnection] = list()\n handled: Set[JuncRoadSingleConnection] = set()\n in_roads, out_roads = self.__get_in_out_roads_dicts_by_single(roads)\n loop_removed = 0\n # the id of chain, will be the id of the future road\n curr_chain_id = 0\n # now run over all roads\n connected2: Set[JuncIndices] = self.__get_2_connected_juncs(roads, (in_roads, out_roads))\n while len(handled) != len(roads):\n # init a chain road connection\n chain: List[JuncRoadSingleConnection] = list()\n # get a random road\n curr_road: JuncRoadSingleConnection = sample(roads.difference(handled), 1)[0]\n handled.add(curr_road)\n chain.append(curr_road)\n \"\"\"\n now we have to be careful. there are 4 case:\n 1. both sides of the road are not 2-connected juncs, just add the chain.\n 2. the target is a 2-connected junc, loop forward until reaching a non 2-connected junc\n 3. the source is a 2-connected junc, loop backwards until reaching a non 2-connected junc\n 4. both sides of the road are 2-connected juncs, we should loop both forwars and backwards,\n but also notice that it is possible that we are in a loop of N juncs that are all 2-connected,\n in that case we should remove all of them. to check that we should have a set of visited juncs.\n \"\"\"\n # case 1\n if curr_road.source not in connected2 and curr_road.target not in connected2:\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\n curr_chain_id += 1\n # case 2\n elif curr_road.source not in connected2 and curr_road.target in connected2:\n while curr_road.target in connected2:\n curr_road = list(out_roads[curr_road.target])[0] # the length of the set is 1. get its element.\n handled.add(curr_road)\n chain.append(curr_road)\n # reached False, so we should not skip over the next target, we are done.\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\n curr_chain_id += 1\n # remove the 2-connected junctions\n for road in chain[:-1]:\n self.remove_junction(self.get_junc(road.target))\n # case 3\n elif curr_road.source in connected2 and curr_road.target not in connected2:\n while curr_road.source in connected2:\n curr_road = list(in_roads[curr_road.source])[0] # the length of the set is 1. get its element.\n handled.add(curr_road)\n chain.insert(0, curr_road)\n # reached False, so we should not skip over the next target, we are done.\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\n curr_chain_id += 1\n # remove the 2-connected junctions\n for road in chain[:-1]:\n self.remove_junction(self.get_junc(road.target))\n # case 4\n elif curr_road.source in connected2 and curr_road.target in connected2:\n \"\"\"\n save the prev of the current road, to know if there is a loop.\n we dont save just the current road becuase this creates troubles in the while condition.\n \"\"\"\n loop_start_road = list(in_roads[curr_road.source])[0]\n original_road = curr_road\n while curr_road.target in connected2 and curr_road != loop_start_road:\n curr_road = list(out_roads[curr_road.target])[0] # the length of the set is 1. get its element.\n handled.add(curr_road)\n chain.append(curr_road)\n # we finished going forwards, for 1 of 2 reasons:\n if loop_start_road != curr_road:\n # regular operations. now go backwards:\n curr_road = original_road\n while curr_road.source in connected2:\n curr_road = list(in_roads[curr_road.source])[0] # the length of the set is 1. get its element.\n handled.add(curr_road)\n chain.insert(0, curr_road)\n # in the end, add the chain\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\n curr_chain_id += 1\n # remove the 2-connected junctions\n for road in chain[:-1]:\n self.remove_junction(self.get_junc(road.target))\n else:\n \"\"\"\n we have a loop. handle the removing of all these junctions.\n do the following:\n 1. find all junctions and roads that take part in the loop.\n 2. remove all of the roads from the roads set,\n and also from the handled set to keep the while loop stop condition.\n *. no need to remove them from them from in_roads/out_roads/connceted2 since they are\n irrelevent to the other roads and junctions.\n 3. then, just apply the junc removing function on all junctions.\n \"\"\"\n # step 1: we already have exactly them in the chain list!\n # step 2:\n for road in chain:\n roads.remove(road)\n handled.remove(road)\n # step 3:\n juncs_indices: List[JuncIndices] = [road.source for road in chain]\n loop_removed += len(juncs_indices)\n for junc_indices in juncs_indices:\n self.remove_junction(self.get_junc(junc_indices))\n # just error checking\n else:\n raise Exception(\"error in if chain, in graph.__create_chain_roads\")\n if with_removed:\n return chain_connections, loop_removed\n return chain_connections","def subsettter(clipsegments, lengthtype):\n if lengthtype == 'twothirds':\n clipsegments.remove('AR8')\n clipsegments.remove('AF13')\n elif lengthtype == 'abouthalf':\n clipsegments.remove('AR8')\n clipsegments.remove('AF13')\n clipsegments.remove('AF7')\n return clipsegments","def wake_trim(pairs, wake_trim_min, period_length_sec):\r\n trim = int((60/period_length_sec) * wake_trim_min)\r\n trimmed_pairs = []\r\n for true, pred in pairs:\r\n inds = np.where(true != 0)[0]\r\n start = max(0, inds[0]-trim)\r\n end = inds[-1]+trim\r\n trimmed_pairs.append([\r\n true[start:end], pred[start:end]\r\n ])\r\n return trimmed_pairs","def pruning(self):\n data = self.data.copy()\n for d in self.data:\n # cascade purning method. Inspired from \"Efficient Computation of Group Skyline Queries on MapReduce (FCU)\"\n if d in data:\n pastart = [self.drange[1] if i+self.radius>self.drange[1] else i+self.radius for i in d.getLocationMax()]\n pamax = [self.drange[1] for j in range(self.dim)]\n # prune data points that are obviously dominated by current data point\n pruned = (self.index.intersection(tuple(pastart+pamax),objects=True))\n for p in pruned:\n if p.object in data:\n data.remove(p.object)\n self.pruned = data","def remove_lead(self, lead):\n self.leads = self.leads[:lead] + self.leads[lead+1:]\n self.connections = self.connections[:lead] + self.connections[lead+1:]","def ltrimboth (l,proportiontocut):\r\n lowercut = int(proportiontocut*len(l))\r\n uppercut = len(l) - lowercut\r\n return l[lowercut:uppercut]","def floor_remove(points, set_max_window_size = 20, set_slope = 1.0, set_initial_distance = 0.5, set_max_distance = 3.0):\n PointCloud = points\n ind = pclpy.pcl.vectors.Int()\n pmf = pclpy.pcl.segmentation.ApproximateProgressiveMorphologicalFilter.PointXYZ()\n pmf.setInputCloud(PointCloud)\n pmf.setMaxWindowSize(set_max_window_size)\n pmf.setSlope(set_slope)\n pmf.setInitialDistance(set_initial_distance)\n pmf.setMaxDistance(set_max_distance)\n pmf.extract(ind)\n ext = pclpy.pcl.filters.ExtractIndices.PointXYZ()\n ground = pclpy.pcl.PointCloud.PointXYZ()\n non_ground_points = pclpy.pcl.PointCloud.PointXYZ()\n ext.setInputCloud(PointCloud)\n ext.setIndices(ind)\n ext.filter(ground)\n ext.setNegative(True)\n ext.filter(non_ground_points)\n\n return non_ground_points.xyz, ground.xyz","def hole_cleanup(atom_list): \n joey = atom_list.copy()\n while (len(joey) != 0):\n for atom in joey:\n takein = [atom]\n source_update = takein.copy()\n check = 1\n while (check == 1):\n source = source_update.copy()\n source_update = []\n c = len(takein)\n for element in source:\n bonds = [bond[0] for bond in identify_bonds(element, joey) if bond[0] not in takein]\n for h in bonds:\n takein.append(h)\n source_update.append(h)\n if ((len(takein) == c) and (len(takein) < 6)):\n check = 0\n for element in takein:\n atom_list.remove(element)\n elif (len(takein) == c):\n check = 0\n for element in takein:\n joey.remove(element)\n return atom_list","def prolongTrail(trails, first_appearance, t0, t1):\n v1 = cellCenter(t0)\n v2 = cellCenter(t1)\n seg = (v2 - v1) / np.linalg.norm(v2 - v1)\n first_app = first_appearance[t0]\n orig_trail = trails[first_app[0]]\n candidates = []\n if first_app[1] > 0:\n candidates.append(orig_trail[first_app[1] - 1])\n if first_app[1] < len(orig_trail) - 1:\n candidates.append(orig_trail[first_app[1] + 1])\n cand_centers = [cellCenter(candidate) for candidate in candidates]\n cand_segs = [(v1 - v) / np.linalg.norm(v1 - v) for v in cand_centers]\n cand_dot = [np.dot(cand_seg, seg) for cand_seg in cand_segs]\n return candidates[np.argmax(cand_dot)]","def clifford_set(u):\n i, x, y, z = u.v\n result = []\n result.append(u.clone()) # I\n result.append(Uop(-x, i, -z, y, u.hierarchy, u.construction + [\"X\"], gateset=u.gateset)) # iX, but treat it as X due to only phase difference\n result.append(Uop((i-x)/SQRT2, (x+i)/SQRT2, (y-z)/SQRT2, (z+y)/SQRT2, u.hierarchy, u.construction + [\"(I+iX)\"], gateset=u.gateset))\n result.append(Uop((i+x)/SQRT2, (x-i)/SQRT2, (y+z)/SQRT2, (z-y)/SQRT2, u.hierarchy, u.construction + [\"(I-iX)\"], gateset=u.gateset))\n result.append(Uop((i-y)/SQRT2, (x+z)/SQRT2, (y+i)/SQRT2, (z-x)/SQRT2, u.hierarchy, u.construction + [\"(I+iY)\"], gateset=u.gateset))\n result.append(Uop((i+y)/SQRT2, (x-z)/SQRT2, (y-i)/SQRT2, (z+x)/SQRT2, u.hierarchy, u.construction + [\"(I-iY)\"], gateset=u.gateset))\n for idx in range(6):\n i, x, y, z = result[idx].v\n c = result[idx].construction[-1:] if idx != 0 else []\n result.append(Uop(-z, -y, x, i, u.hierarchy, u.construction + c + [\"Z\"], gateset=u.gateset)) # iZ\n result.append(Uop((i-z)/SQRT2, (x-y)/SQRT2, (y+x)/SQRT2, (z+i)/SQRT2, u.hierarchy, u.construction + c + [\"(I+iZ)\"], gateset=u.gateset))\n result.append(Uop((i+z)/SQRT2, (x+y)/SQRT2, (y-x)/SQRT2, (z-i)/SQRT2, u.hierarchy, u.construction + c + [\"(I-iZ)\"], gateset=u.gateset))\n\n return result","def simplify_polyline_epsilon(points, epsilon):\n raise NotImplementedError(\"TODO: test this code\")\n\n if len(points) < 3:\n return points\n\n begin, end = points[0], points[-1]\n dist_sq = [segment_point_distance_sq(\n begin[0], begin[1], end[0], end[1], p[0], p[1])\n for p in points[1:-1]]\n\n maxdist = max(dist_sq)\n if maxdist < epsilon ** 2:\n return [begin, end]\n\n pos = dist_sq.index(maxdist)\n return (simplify_polyline_epsilon(points[:pos + 2], epsilon) +\n simplify_polyline_epsilon(points[pos + 1:], epsilon)[1:])","def cut_line(self):\r\n self.parachute.pop(0)","def clip(self, clip, s_entry, c_entry):\n\n # detect clip mode\n unionmode = not s_entry and not c_entry\n intersectionmode = s_entry and c_entry\n differencemode = not s_entry and c_entry\n\n # prep by removing repeat of startpoint at end\n first = self.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n first = clip.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n\n # TODO: maybe also remove repeat points anywhere?\n # ...\n \n # phase one - find intersections\n # ------------------------------\n anyintersection = False\n s_intsecs = []\n c_intsecs = []\n for s in self.iter(): # for each vertex Si of subject polygon do\n for c in clip.iter(): # for each vertex Cj of clip polygon do\n try:\n #print \"find isect %s - %s and %s - %s\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\n c, clip.next(c.__next__))\n \n iS = Vertex(i, alphaS, intersect=True, entry=False)\n iC = Vertex(i, alphaC, intersect=True, entry=False)\n\n iS.neighbour = iC\n iC.neighbour = iS\n \n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\n \n anyintersection = True\n \n except TypeError:\n pass # this simply means intersect() returned None\n\n # insert intersections into originals\n for iS,a,s,s_next in reversed(s_intsecs):\n if a == 0:\n self.replace(s, iS)\n elif a == 1:\n self.replace(s_next, iS)\n else:\n self.insert(iS, s, s_next)\n for iC,a,c,c_next in reversed(c_intsecs):\n if a == 0:\n self.replace(c, iC)\n elif a == 1:\n self.replace(c_next, iC)\n else:\n clip.insert(iC, c, c_next)\n\n #print \"testing if insert was done correctly\"\n for s in self.iter():\n #print s\n pass\n #print \"and\"\n for c in clip.iter():\n #print c\n pass\n \n\n # phase one and a half - no intersections between subject and clip, so correctly return results\n # --------------------\n def specialcase_insidetest():\n resultpolys = []\n if unionmode: # union\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so just return subject shell\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so just return clip shell\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so return both\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif intersectionmode: # intersection\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so no intersection to return\n pass\n elif differencemode: # difference\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n hole = Polygon()\n for c in clip.iter():\n hole.add(Vertex(c))\n polytuple = (clipped, [hole])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so there is no difference\n pass\n else:\n #clip polygon is entirely outside subject, so difference is simply the subject\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n # no need to continue so just return result\n return resultpolys\n \n if not anyintersection: \n return specialcase_insidetest()\n\n\n\n\n\n\n\n # phase two - identify entry/exit points\n # --------------------------------------\n\n # From K&K\n \n def mark_flags(poly, c, c_entry):\n \"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\"\n #print \"intersection\"\n #print \"\\t\",c\n # intersection is degenerate, is the start/endpoint of a line\n # so maybe delete intersection flag based on prev/next locations\n prevloc = testLocation(c.prev, poly)\n nextloc = testLocation(c.__next__, poly)\n if prevloc == \"on\" or nextloc == \"on\":\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\n prevloc = testLocation(prevmid, poly)\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\n nextloc = testLocation(nextmid, poly)\n if prevloc == \"in\" or nextloc == \"in\":\n poly.anyinside = True\n #print \"\\t %s -> degenintsec -> %s\" %(prevloc,nextloc)\n if prevloc == \"out\":\n if nextloc == \"out\":\n #just touching\n c.entry = \"en/ex\" if c_entry else \"ex/en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif nextloc == \"on\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif prevloc == \"in\":\n #union and difference should never go inside the other polygon\n #so this should only happen for intersectmode...\n if nextloc == \"in\":\n #just touching\n c.entry = \"ex/en\" if c_entry else \"en/ex\"\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"on\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif prevloc == \"on\":\n if nextloc == \"on\":\n c.entry = None\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n\n self.anyinside = False\n\n # set clip\n prevsingle = None\n for c in clip.iter():\n if c.intersect:\n mark_flags(self, c, c_entry)\n # set couple\n if c.entry in (\"ex\",\"en\"):\n if prevsingle and c.entry == prevsingle.entry:\n c.couple = prevsingle\n prevsingle.couple = c\n prevsingle = c\n # set crosschange\n # some modifications based on implementation in qt clipper source code\n #if c.entry == \"en/ex\" == c.neighbour.entry or c.entry == \"ex/en\" == c.neighbour.entry:\n if False: #c.entry == \"en/ex\" or c.entry == \"ex/en\":\n print(\"Maybe crosschange...\")\n # tri1\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\n dir1 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n # tri2\n #a,b,c = c.neighbour.prev, c.prev, c.next\n a,b,c = c.__next__, c.prev, c.neighbour.prev\n dir2 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n print(dir1,dir2)\n #if dir1 < 0 != dir2 < 0: # different orientation\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\n print(\"CROSSCHANGE!!!\")\n c.cross_change = True\n c.neighbour.cross_change = True # not sure if should set neighbour too\n\n # maybe early abort\n if not self.anyinside and intersectionmode:\n return []\n\n # what about perfect overlap???\n # ...\n\n if False: #DEBUG:\n print(\"view clip entries\")\n for c in clip.iter():\n print(c, c.entry)\n\n # find first isect where both neighbours have valid flag\n for c in clip.iter():\n if c.entry:\n s = c.neighbour\n mark_flags(clip, s, s_entry)\n if s.entry:\n first_c = c\n first_s = s\n # print 777,s.entry\n break\n\n else:\n return specialcase_insidetest()\n #raise Exception(\"weird special case, no neighbours that both have flag left\")\n \n # autoset subj, if neighbour of first is different, then set all as opposite\n # TODO: how deal with s_entry in case of different modes...?\n print(\"view first\")\n print(first_c, first_c.entry)\n print(first_s, first_s.entry)\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\n for c in clip.iter():\n if c.entry:\n if c.entry == \"en\": c.neighbour.entry = \"ex\"\n elif c.entry == \"ex\": c.neighbour.entry = \"en\"\n elif c.entry == \"en/ex\": c.neighbour.entry = \"ex/en\"\n elif c.entry == \"ex/en\": c.neighbour.entry = \"en/ex\"\n \n # else set all same\n else:\n for c in clip.iter():\n if c.entry:\n c.neighbour.entry = c.entry\n\n # set couple for subj (not sure if needed)\n prevsingle = None\n for s in self.iter():\n if s.entry:\n if s.entry in (\"ex\",\"en\"):\n if prevsingle and s.entry == prevsingle.entry:\n s.couple = prevsingle\n prevsingle.couple = s\n prevsingle = s\n\n if False: #DEBUG: \n print(\"view subj entries\")\n for s in self.iter():\n print(s, s.entry)\n\n\n\n\n\n # phase three - construct a list of clipped polygons\n # --------------------------------------------------\n\n ######\n # Defs\n def next_unprocessed(vert):\n origvert = vert\n while vert:\n if vert.entry and not (vert.checked or vert.neighbour.checked):\n #print \"vert, found next unproc\", vert, vert.checked, vert.neighbour.checked\n if vert.couple:\n # rule 1\n if vert.couple.entry and vert.entry:\n # rule 2\n if vert.couple.entry == \"en\" and vert.entry == \"en\":\n return vert.couple\n elif vert.couple.entry == \"ex\" and vert.entry == \"ex\":\n return vert\n # rule 3\n else:\n return vert\n \n vert = vert.__next__\n \n if vert == origvert:\n # if returned to first, return None\n return None\n\n def DeleteFlag1(cur, stat):\n if cur.entry == \"en/ex\":\n cur.entry = None\n if cur.cross_change:\n if stat == \"D3\":\n return \"D3\"\n else:\n return \"D4\"\n if stat == \"D3\":\n return \"D4\"\n else:\n return \"D3\"\n if cur.entry == \"ex/en\":\n if stat == \"D3\":\n cur.entry = \"en\"\n return \"D2\"\n else:\n cur.entry = \"ex\"\n return \"D1\"\n if cur.entry == \"en\":\n cur.entry = None\n return \"D1\"\n if cur.entry == \"ex\":\n cur.entry = None\n return \"D2\"\n\n def DeleteFlag2(cur, prev, stat):\n if cur.entry == \"en/ex\":\n if stat == \"D1\":\n cur.entry = \"ex\"\n else:\n cur.entry = \"en\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex/en\":\n if stat == \"D1\":\n cur.entry = \"en\"\n else:\n cur.entry = \"ex\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"en\":\n cur.entry = None\n if stat == \"D1\" and cur.couple and prev.couple == cur:\n return \"D1\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex\":\n cur.entry = None\n if stat != \"D1\" and cur.couple and prev.couple == cur:\n return \"D2\"\n else:\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n\n def proceed(cur, stat):\n cur.checked = True\n if stat == \"D1\":\n clipped.add(Vertex(cur))\n return cur.__next__\n elif stat == \"D2\":\n clipped.add(Vertex(cur))\n return cur.prev\n else:\n return cur.neighbour\n\n ####\n resultpolys = []\n\n self.first.checked = True\n cur = prev = start = next_unprocessed(self.first)\n\n while cur:\n # each new polygon\n print(\"new poly\")\n\n stat = DeleteFlag1(cur, \"D3\")\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n clipped = Polygon()\n cur = proceed(cur, stat)\n\n # collect vertexes\n while cur != start:\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n if cur.entry:\n if stat == \"D1\" or stat == \"D2\":\n stat = DeleteFlag2(cur, prev, stat)\n else:\n stat = DeleteFlag1(cur, stat)\n prev = cur\n cur = proceed(cur, stat)\n\n # return to first vertex\n clipped.add(Vertex(clipped.first))\n\n print(clipped)\n\n resultpolys.append((clipped,[]))\n cur = prev = start = next_unprocessed(self.first)\n\n\n\n # finally, sort into exteriors and holes\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\n for otherext,otherholes in resultpolys:\n if polyext == otherext:\n continue # don't compare to self\n if polyext.first.isInside(otherext):\n otherholes.append(polyext) #poly is within other so make into a hole\n del resultpolys[pindex] #and delete poly from being an independent poly\n return resultpolys","def clean(self):\n\t\tfor v in self:\n\t\t\tv.reset_distance()\n\t\t\tv.reset_predecessor()\n\t\t\tv.reset_visited()","def trimDups( options, data ):\n for c in data.chrNames:\n prevBlock = MafBlock()\n replacement = []\n if c not in data.mafBlocksByChrom:\n data.mafBlocksByChrom[ c ] = replacement\n continue\n for m in data.mafBlocksByChrom[ c ]:\n if m.refStart <= prevBlock.refEnd:\n if m.refEnd > prevBlock.refEnd:\n # only add in the new, distinct, bases\n m.refStart = prevBlock.refEnd + 1\n else:\n # this block is totally covered by the previous block\n continue\n replacement.append( m )\n prevBlock = m\n data.mafBlocksByChrom[ c ] = replacement","def _pair_based_graph_cut(self, graph):\n for node in self._find_paired_nodes(graph):\n graph.remove_node(node)\n return","def lift(point):\n return gs.copy(point)","def clip(self, clipbox):\r\n pmin, pmax = clipbox\r\n ind = []\r\n vlt = []\r\n # Direct elimination of out of bounds edges and vertices\r\n for i in range(len(self.vl)):\r\n if self.vl[i][0] < pmin[0] or self.vl[i][1] < pmin[1] or \\\r\n self.vl[i][0] > pmax[0] or self.vl[i][1] > pmax[1]:\r\n ind.append(i)\r\n else:\r\n vlt.append(self.vl[i])\r\n elt = filter((lambda x: (x[0] not in ind) and (x[1] not in ind)),\r\n self.el)\r\n li = filter((lambda x: x not in ind), range(len(self.vl)))\r\n # We rename the indices in the trimmed edge list\r\n lf = range(len(self.vl) - len(ind))\r\n equiv = {}\r\n for i in range(len(li)):\r\n if li[i] != lf[i]:\r\n equiv[li[i]] = lf[i]\r\n\r\n for i in range(len(elt)):\r\n if elt[i][0] in equiv:\r\n x = equiv[elt[i][0]]\r\n else:\r\n x = elt[i][0]\r\n if elt[i][1] in equiv:\r\n y = equiv[elt[i][1]]\r\n else:\r\n y = elt[i][1]\r\n elt[i] = (x, y)\r\n\r\n self.vl = vlt\r\n self.el = elt\r\n self.minmax()","def prune(pybel_list, min_RMSD):\n #Set up OBAling object\n align = openbabel.OBAlign()\n #Loop\n i = 0\n total_removed = 0\n while i < len(pybel_list):\n referens = pybel_list[i].OBMol #reference\n align.SetRefMol(referens)\n j = i + 1\n while j < len(pybel_list):\n target = pybel_list[j].OBMol #target\n align.SetTargetMol(target)\n #Align and ret rmsd\n if align.Align():\n rmsd = align.GetRMSD()\n if rmsd < min_RMSD:\n pybel_list.pop(j) #remove from both lists\n total_removed += 1\n else:\n j = j + 1\n else:\n print \"Couldn't align\"\n raise Exception()\n #end of inner loop\n i = i + 1\n #end of outer loop\n print \"finished deleting, total number of \\\n removed conformers is\", total_removed\n return pybel_list","def msep_from_given(self, A, C=set()):\n\n A = core_utils.to_set(A)\n C = core_utils.to_set(C)\n\n determined = set()\n descendants = set()\n\n for c in C:\n determined.add(c)\n descendants.add(c)\n self._add_upstream(descendants, c)\n\n reachable = set()\n i_links = set()\n labeled_links = set()\n\n for a in A:\n i_links.add((None, a))\n reachable.add(a)\n\n while True:\n i_p_1_links = set()\n # Find all unlabled links v->w adjacent to at least one link u->v labeled i, such that (u->v,v->w) is a legal pair.\n for link in i_links:\n u, v = link\n for w in self._adjacent[v]:\n if not u == w and (v, w) not in labeled_links:\n if self._is_collider(u, v, w): # Is collider?\n if v in descendants:\n i_p_1_links.add((v, w))\n reachable.add(w)\n else: # Not collider\n if v not in determined:\n i_p_1_links.add((v, w))\n reachable.add(w)\n\n if len(i_p_1_links) == 0:\n break\n\n labeled_links = labeled_links.union(i_links)\n i_links = i_p_1_links\n\n return self._nodes.difference(A).difference(C).difference(reachable)","def trim_dag(G):\n SINKS = G.graph['SINKS']\n SOURCES = G.graph['SOURCES']\n\n for node in G.nodes():\n node_attr = G.node[node]\n children = G.successors(node)\n\n if check_key(node_attr, 'is_const', True):\n if len(children) == 0:\n print \"!!!!! \", node\n\n SOURCES.remove(node)\n if node in SINKS:\n SINKS.remove(node)\n for c in children:\n if 'immediates' in G.node[c].keys():\n G.node[c]['immediates'].append(node_attr['value'])\n\n if check_key(node_attr, 'op', \"mv\") or check_key(node_attr, 'is_const', True) :\n parents = G.predecessors(node)\n \n for p in parents:\n for c in children:\n G.add_edge(p, c)\n #print G.predecessors(node), \" -> \", node, \" -> \", G.successors(node)\n G.remove_node(node)\n\n return","def trim_features():\n pass","def compact(self, distance=2):\n pass","def trim_netlist(nets, components, selected_component, verbose=None):\n\n selected = selected_component\n #>17 <2\n # nets[0].pins[0].component.idx\n trimmed_net = []\n net_idx = [[each.pins[0].component.idx, each.pins[1].component.idx] for each in nets]\n len_net_idx = len(net_idx)\n count = 0\n trimmed_nets, trimmed_components = [], []\n while count < (len_net_idx - 1):\n for i in range(count + 1, len_net_idx): # i keep track of nets from next net to last net\n # first set is formed of elements from current to backwards\n first_set = set(net_idx[count])\n # second set is formed of elements from current + 1 to forward\n second_set = set(net_idx[i])\n if len(first_set.intersection(second_set)) > 0: # if there are common elements between two sets\n net_idx.pop(i) # remove the nets from the list\n net_idx.pop(count) # remove the count net as well\n # merged them and add to the list\n net_idx.append(list(first_set.union(second_set)))\n len_net_idx -= 1 # 2 removed 1 added so reduce 1\n count -= 1 # readjust count as the elements have shifted to left\n break\n count += 1\n for net in net_idx:\n if(selected.idx in net):\n trimmed_components = [each for each in components if each.idx in net]\n trimmed_nets = [each for each in nets if (\n each.pins[0].component.idx in net or each.pins[1].component.idx in net)]\n if verbose:\n print(\"success - netlist trimmed\")\n\n return trimmed_nets, trimmed_components","def trim(network, pores=[], throats=[]):\n pores = network._parse_indices(pores)\n throats = network._parse_indices(throats)\n Pkeep = np.copy(network['pore.all'])\n Tkeep = np.copy(network['throat.all'])\n if np.size(pores) > 0:\n Pkeep[pores] = False\n if not np.any(Pkeep):\n raise Exception('Cannot delete ALL pores')\n # # Performing customized find_neighbor_throats which is much faster, but\n # # not general for other types of queries\n # temp = np.in1d(network['throat.conns'].flatten(), pores)\n # temp = np.reshape(temp, (network.Nt, 2))\n # Ts = np.any(temp, axis=1)\n # Ts = network.Ts[Ts]\n Ts = network.find_neighbor_throats(pores=~Pkeep, mode='union')\n if len(Ts) > 0:\n Tkeep[Ts] = False\n if np.size(throats) > 0:\n Tkeep[throats] = False\n # The following IF catches the special case of deleting ALL throats\n # It removes all throat props, adds 'all', and skips rest of function\n if not np.any(Tkeep):\n logger.info('Removing ALL throats from network')\n for item in list(network.keys()):\n if item.split('.')[0] == 'throat':\n del network[item]\n network['throat.all'] = np.array([], ndmin=1)\n return\n\n # Temporarily store throat conns and pore map for processing later\n Np_old = network.Np\n Nt_old = network.Nt\n Pkeep_inds = np.where(Pkeep)[0]\n Tkeep_inds = np.where(Tkeep)[0]\n Pmap = np.ones((network.Np,), dtype=int)*-1\n tpore1 = network['throat.conns'][:, 0]\n tpore2 = network['throat.conns'][:, 1]\n\n # Delete specified pores and throats from all objects\n for obj in network.project[::-1]:\n if (obj.Np == Np_old) and (obj.Nt == Nt_old):\n Ps = Pkeep_inds\n Ts = Tkeep_inds\n else: # If subdomain object then Np/Nt < Np/Nt_old\n Ps = obj.to_local(pores=Pkeep_inds, missing_vals=None)\n Ts = obj.to_local(throats=Tkeep_inds, missing_vals=None)\n for key in list(obj.keys()):\n temp = obj.pop(key)\n if key.split('.')[0] == 'throat':\n obj.update({key: temp[Ts]})\n if key.split('.')[0] == 'pore':\n obj.update({key: temp[Ps]})\n\n # Remap throat connections\n Pmap[Pkeep] = np.arange(0, np.sum(Pkeep))\n Tnew1 = Pmap[tpore1[Tkeep]]\n Tnew2 = Pmap[tpore2[Tkeep]]\n network.update({'throat.conns': np.vstack((Tnew1, Tnew2)).T})\n\n # Clear adjacency and incidence matrices which will be out of date now\n network._am.clear()\n network._im.clear()","def remove_subdivison(self):\n temp_sub_vertices = []\n for index in range(0, len(self.subdivision_list) - 1, 4):\n v0 = Vec3d(0, 0, 0, 0)\n v1 = Vec3d(0, 0, 0, 0)\n v2 = Vec3d(0, 0, 0, 0)\n\n v0.x = self.subdivision_list[index + 1][0].x\n v0.y = self.subdivision_list[index + 1][0].y\n v0.z = self.subdivision_list[index + 1][0].z\n v0.w = self.subdivision_list[index + 1][0].w\n\n v1.x = self.subdivision_list[index + 2][0].x\n v1.y = self.subdivision_list[index + 2][0].y\n v1.z = self.subdivision_list[index + 2][0].z\n v1.w = self.subdivision_list[index + 2][0].w\n\n v2.x = self.subdivision_list[index + 3][0].x\n v2.y = self.subdivision_list[index + 3][0].y\n v2.z = self.subdivision_list[index + 3][0].z\n v2.w = self.subdivision_list[index + 3][0].w\n\n temp_sub_vertices.append([v0, v1, v2])\n\n self.subdivision_list = temp_sub_vertices","def triple_cut(deck_of_cards):\n new_deck =[]\n big_joker_value = get_big_joker_value(deck_of_cards)\n small_joker_value = get_small_joker_value(deck_of_cards)\n\t \n index1 = deck_of_cards.index(small_joker_value)\n index2 = deck_of_cards.index(big_joker_value)\n index_top_card = min(index1, index2)\n index_bottom_card = max(index1, index2)\n # This function will give us the joker that is on the top and the joker \n # that is in the bottom of the deck regardless of their value\n \n new_top = deck_of_cards[(index_bottom_card + 1):]\n # Creates a deck that is to be moved the top, from the lower joker and\n # below \n middle = deck_of_cards[index_top_card : index_bottom_card + 1]\n # Middle portion of the deck that is not moved that is in between the jokers\n new_bottom = deck_of_cards[:index_top_card]\n # The deck portion that is to be moved to the bottom, from higher joker and\n # above.\n deck = new_top + middle + new_bottom\n deck_of_cards[:] = deck\n # This will then give a new deck that shifts the cards above the higher \n # joker to the end and the cards below the lower joker to the top.","def triple_cut(deck: List[int]) -> None:\n\n small_joker_index = deck.index(get_small_joker_value(deck))\n big_joker_index = deck.index(max(deck))\n\n if big_joker_index > small_joker_index:\n left_joker = small_joker_index\n right_joker = big_joker_index\n\n else:\n right_joker = small_joker_index\n left_joker = big_joker_index\n\n left_list = deck[:left_joker]\n right_list = deck[right_joker + 1:]\n middle_list = deck[left_joker:right_joker + 1]\n del deck[:]\n deck.extend(right_list)\n deck.extend(middle_list)\n deck.extend(left_list)","def _trim_similar_hypotheses(self, hts, ongoing_play):\n trimmed_hs_data = []\n kept_hs = []\n remaining_hts = collections.deque(hts)\n while remaining_hts:\n ht = remaining_hts.popleft()\n n_remaining_hts = collections.deque()\n kept_hs.append(ht)\n while remaining_hts:\n n_ht = remaining_hts.popleft()\n s = self.sim_f(ht, n_ht, ongoing_play)\n if s > (1 - self.similarity_epsilon):\n trimmed_hs_data.append((n_ht, ht))\n else:\n n_remaining_hts.append(n_ht)\n\n remaining_hts = n_remaining_hts\n\n return (kept_hs, trimmed_hs_data)","def strip_profiles_copy(profiles):\n return strip_profiles(lambda x: x['operation'] == 'copy', profiles)","def crop_data(vol):\n\n thres = 250\n\n num_x = vol.shape[0]\n num_y = vol.shape[1]\n num_z = vol.shape[2]\n\n \n # set up starting positions\n starts = []\n\n # front and back\n for i in range(num_x):\n for j in range(num_z):\n starts.append( (i, 0, j) )\n starts.append( (i, num_y-1, j) )\n\n # left and right\n for i in range(num_y):\n for j in range(num_z):\n starts.append( (0, i, j) )\n starts.append( (num_x-1, i, j) )\n\n # DFS\n seenpositions = set()\n currentpositions = set(starts)\n\n while currentpositions:\n nextpositions = set()\n for p in currentpositions:\n seenpositions.add(p)\n succ = possiblesuccessors(vol, p, thres)\n for np in succ:\n if np in seenpositions: continue\n nextpositions.add(np)\n\n currentpositions = nextpositions\n\n print \"cropping %i (%i addional) voxels\" % (len(seenpositions), len(seenpositions) - len(starts))\n\n # crop visited voxels\n for pos in seenpositions:\n vol[pos[0], pos[1], pos[2]] = 0.0\n\n return vol","def remove_jumps(self) -> None:\n q_diff = np.diff(self.array, axis=0)\n jumps = np.nonzero(np.where(np.linalg.norm(q_diff, axis=1)>1, 1, 0))[0]+1\n if len(jumps) % 2:\n jumps = np.append(jumps, [len(q_diff)+1])\n jump_pairs = jumps.reshape((len(jumps)//2, 2))\n for j in jump_pairs:\n self.array[j[0]:j[1]] *= -1.0","def clip_trips_to_window(trips):\n\tto_remove = []\n\tfor i, trip in enumerate(trips):\n\t\tif ( # checking for GOOD trips \n\t\t\t# departs inside window\n\t\t\tconfig.window_start_time <= trip.depart.time() <= config.window_end_time \n\t\t\t# and departs within date range\n\t\t\tand trip.depart.date() >= config.window_start_date\n\t\t\tand trip.depart.date() <= config.window_end_date \n\t\t): \n\t\t\tpass\n\t\telse:\n\t\t\tto_remove.append(i)\n\tfor i in reversed(to_remove):\n\t\tdel trips[i]","def cleaned_list():\n ws_oc = catalog.srcs.copy() # write-safe read copy for\n # the GLEAM object catalog\n cat = catalog.srcs.copy()\n # we loop in reverse, to avoid concurrent mod. exceptions\n for i in range(len(ws_oc) - 1, 0, -1):\n # classic. The easiest way to check if a value is NaN:\n # it won't equal itself\n if ws_oc[i].alpha != ws_oc[i].alpha:\n cat = np.delete(cat, i)\n return cat","def remove_4s_every_other_in_between(seq):\n seq_copy = seq [4:-4:2]\n return seq_copy","def reduce_to_planar_3_coloring(G):\n\n if G.is_planar():\n return G\n\n H = FalsePlanarGraph.from_graph(G)\n\n for e in H.false_edges:\n u, v = e\n\n # set a combinatorial embedding in H\n H.is_planar()\n\n # find the minimum crossing path from u to v\n path = min_crossing_path(H, u, v)\n\n # apply the planar gadget to every crossing\n uncross_edges(H, e, path)\n\n return H.planar_copy()","def remove_disconnected_vertices(self):\n if self.empty():\n return Skeleton(\n segid=self.id, \n space=self.space, \n extra_attributes=self.extra_attributes,\n transform=self.transform,\n )\n\n all_edges = fastremap.unique(self.edges.flat)\n\n if len(self.vertices) == all_edges.size:\n return self.clone()\n\n idx_map = {}\n for i, vert in enumerate(self.vertices):\n idx_map[tuple(vert)] = i\n\n connected_verts = np.unique(self.vertices[ self.edges.flat ], axis=0)\n\n edge_map = np.zeros( (len(self.vertices),), dtype=self.edges.dtype)\n vertex_remap = np.zeros( (len(self.vertices),), dtype=np.int32) - 1\n for i, vert in enumerate(connected_verts):\n reverse_idx = idx_map[tuple(vert)]\n edge_map[reverse_idx] = i\n vertex_remap[i] = reverse_idx\n\n edges = np.sort(edge_map[self.edges], axis=1)\n vertex_remap = vertex_remap[ vertex_remap > -1 ]\n\n skel = Skeleton(\n connected_verts, edges, \n segid=self.id, \n space=self.space,\n extra_attributes=self.extra_attributes,\n transform=self.transform,\n )\n\n if len(self.extra_attributes) == 0:\n return skel\n\n for attr in self.extra_attributes:\n name = attr['id']\n self_buf = getattr(self, name)\n skel_buf = self_buf[vertex_remap]\n setattr(skel, name, skel_buf)\n \n return skel","def _filter_nonmonotone_data_points(xs, ys):\n diffs = np.diff(xs)\n xs_new = [xs[0]]\n ys_new = [ys[0]]\n middle = int(len(xs)/2)\n sgn = 1 if xs[0] < xs[-1] else -1\n for i, dx in enumerate(diffs):\n if sgn*dx > 0.0:\n xs_new.append(xs[i+1])\n ys_new.append(ys[i+1])\n elif i > middle:\n xs_new[-1] = xs[i+1]\n ys_new[-1] = ys[i+1]\n return xs_new, ys_new","def declutter(vector):\n for key in vector:\n clutter_values = [value for value in vector[key] if vector[key][value]<2] # gather everything with a value less than two and save it in a list\n for feature in clutter_values: # remove everything in the clutter values from a dictionary\n vector[key].pop(feature,None)\n return vector","def clip_polygon(subject, clipper, operation = 'difference'):\n Subject = Polygon()\n Clipper = Polygon()\n\n for s in subject:\n Subject.add(Vertex(s))\n\n for c in clipper:\n Clipper.add(Vertex(c))\n\n clipped = Clipper.difference(Subject)\\\n if operation == 'reversed-diff'\\\n else Subject.__getattribute__(operation)(Clipper)\n\n clipped = [(ext.points,[hole.points for hole in holes]) for ext,holes in clipped]\n return clipped","def main(self, data, quant_factor=None):\n\n if not data[\"linestrings\"]:\n data[\"junctions\"] = self.junctions\n return data\n\n # quantize linestrings before comparing\n # if set to None or a value < 1 (True equals 1) no quantizing is applied.\n if quant_factor is not None:\n if quant_factor > 1:\n kx, ky, x0, y0 = self.prequantize(data[\"linestrings\"], quant_factor)\n data[\"transform\"] = {\"scale\": [kx, ky], \"translate\": [x0, y0]}\n\n # create list with unique combinations of lines using a rdtree\n line_combs = select_unique_combs(data[\"linestrings\"])\n\n # iterate over index combinations\n for i1, i2 in line_combs:\n g1 = data[\"linestrings\"][i1]\n g2 = data[\"linestrings\"][i2]\n\n # check if geometry are equal\n # being equal meaning the geometry object coincide with each other.\n # a rotated polygon or reversed linestring are both considered equal.\n if not g1.equals(g2):\n # geoms are unique, let's find junctions\n self.shared_segs(g1, g2)\n\n # self.segments are nested lists of LineStrings, get coordinates of each nest\n s_coords = []\n for segment in self.segments:\n s_coords.extend(\n [\n [\n (x.xy[0][y], x.xy[1][y])\n for x in segment\n for y in range(len(x.xy[0]))\n ]\n ]\n )\n # s_coords.extend([[y for x in segment for y in list(x.coords)]])\n\n # only keep junctions that appear only once in each segment (nested list)\n # coordinates that appear multiple times are not junctions\n for coords in s_coords:\n self.junctions.extend(\n [geometry.Point(i) for i in coords if coords.count(i) is 1]\n )\n\n # junctions can appear multiple times in multiple segments, remove duplicates\n self.junctions = [\n loads(xy) for xy in list(set([x.wkb for x in self.junctions]))\n ]\n\n # prepare to return object\n data[\"junctions\"] = self.junctions\n\n return data","def trim_occluded_throats(self):\n occluded_ts = list(self.throats()[self[\"throat.area\"]==0])\n #occluded_throats = np.asarray(occluded_throats)\n if len(occluded_ts) > 0:\n self.trim(throats=occluded_ts)\n \"Also get rid of isolated pores\"\n isolated_ps = self.check_network_health()['isolated_pores']\n if len(isolated_ps) > 0:\n self.trim(isolated_ps)","def trim(self):\n while np.any(self.vertex_valance <= 1):\n edge_to_keep = np.all(self.vertex_valance[self.edges] > 1,\n axis=1).tolist();\n self.raw_wires.filter_edges(edge_to_keep);\n vertex_to_keep = [len(self.get_vertex_neighbors(i)) > 0 for i in\n range(self.num_vertices)];\n self.raw_wires.filter_vertices(vertex_to_keep);\n\n self.__initialize_wires();\n if len(self.vertices) == 0:\n raise RuntimeError(\"Zero vertices left after trimming.\");","def trim(self):\n for i in range(len(self)):\n if self[i] != TRIT_ZERO:\n return self.__class__(self[i:])\n return self.__class__([])","def crossing_minimization(self):\n self.layer_sweep()","def get_corner_node_prune(lcurve):\r\n rho, eta = np.zeros(len(lcurve)), np.zeros(len(lcurve))\r\n for lia in range(len(lcurve)):\r\n rho[lia] = lcurve[lia][0]\r\n eta[lia] = lcurve[lia][1]\r\n\r\n if len(rho) != len(eta):\r\n raise ValueError(\"both arrays must have the same size\")\r\n fin = np.isfinite(rho + eta)\r\n nzr = np.array([False]*len(rho))\r\n nzr[np.nonzero(rho*eta)[0]] = True\r\n keep = fin & nzr\r\n if len(keep) < 1:\r\n raise ValueError(\"To few accepted data found\")\r\n if len(keep) < len(rho):\r\n print(\"I had to trim the data due to NaN/Inf or zero values\")\r\n rho = rho[keep]\r\n eta = eta[keep]\r\n if np.any(rho[:-1] < rho[1:]) or np.any(eta[:-1] > eta[1:]):\r\n print(\"Warning: L-curve lacks monotonicity\")\r\n nP = len(rho) # number of points\r\n P = np.log10(np.array([rho, eta])).T # Coordinates of the loglog L-curve\r\n V = P[1:, :] - P[:-1, :] # The vectors defined by these coord\r\n v = np.sqrt(np.sum(V**2, axis=1)) # length of the vectors\r\n # W = V/np.tile(v, (1, 2)); # Normalized vectors.\r\n W = np.zeros(V.shape)\r\n W[:, 0] = V[:, 0]/v\r\n W[:, 1] = V[:, 1]/v\r\n clist = [] # list of condidates\r\n p = np.min([5, nP]) # number of vectors in pruned L-curve\r\n # convex = 0 # Are the pruned L-curves convex\r\n Ind = np.argsort(v)[::-1] # Sort lengths decending\r\n while p < (nP-1)*2:\r\n elmts = np.sort(Ind[:np.min([p, nP-1])])\r\n candidate = Angles(W[elmts, :], elmts)\r\n # print(\"candidate p={}, {}\".format(p, candidate))\r\n if candidate not in clist:\r\n clist.append(candidate)\r\n candidate = Global_Behaviour(P, W[elmts, :], elmts)\r\n if candidate not in clist:\r\n clist.append(candidate)\r\n p = p*2\r\n # print(clist)\r\n if 0 not in clist:\r\n clist.insert(0, 0)\r\n clist = np.sort(clist)\r\n\r\n vz = np.argwhere(np.diff(P[clist, 1]) >= np.abs(np.diff(P[clist, 0])))\r\n if len(vz) > 1:\r\n if vz[0] == 0:\r\n vz = vz[1:]\r\n elif len(vz) == 1:\r\n if vz[0] == 0:\r\n vz = []\r\n if vz == [] or len(vz) == 0:\r\n # if vz.size <= 0:\r\n index = clist[-1]\r\n else:\r\n vects = np.array([P[clist[1:], 0] - P[clist[:-1], 0], P[clist[1:], 1] - P[clist[:-1], 1]]).T\r\n vects = np.dot(np.diag(1/np.sqrt(np.sum(vects**2, 1))), vects)\r\n delta = vects[:-1, 0] * vects[1:, 1] - vects[1:, 0] * vects[:-1, 1]\r\n vv = np.argwhere(delta[vz-1] <= 0)\r\n # print(vv)\r\n # print(vz)\r\n if vv == [] or len(vv) == 0:\r\n # if vv.size <= 0:\r\n index = clist[vz[-1]]\r\n else:\r\n index = clist[vz[vv[0]]]\r\n\r\n try:\r\n retval = int(index)\r\n except TypeError:\r\n print(\"index!!!!: {}\".format(index))\r\n retval = int(index[0])\r\n return retval","def all_notes_line_up(a_list, b_list):\n a_list = [x for x in a_list if not x.is_rest] # copy NoteList to list\n b_list = [x for x in b_list if not x.is_rest] # copy NoteList to list\n\n # remove matched notes\n for a_note in a_list[:]:\n for b_note in b_list[:]:\n if (a_note.start, a_note.end) == (b_note.start, b_note.end):\n # remove the matched pair from their respective lists\n a_list.remove(a_note)\n b_list.remove(b_note)\n break\n\n return a_list, b_list","def _repartition(self, v, radius, contribute=False):\n # =============== PRE-ALLOCATION ===============\n # Compute on non-masked sources :\n xyz = self.xyz[~self.data.mask]\n # Get sign of the x coordinate :\n xsign = np.sign(xyz[:, 0]).reshape(1, -1)\n # Corticale repartition :\n repartition = np.ma.zeros((v.shape[0], v.shape[1]), dtype=np.int)\n\n # For each triangle :\n for k in range(3):\n # =============== EUCLIDIAN DISTANCE ===============\n eucl = cdist(v[:, k, :], xyz).astype(np.float32)\n mask = eucl <= radius\n # Contribute :\n if not contribute:\n # Get vertices signn :\n vsign = np.sign(v[:, k, 0]).reshape(-1, 1)\n # Find where vsign and xsign are equals :\n isign = np.logical_and(vsign != xsign, xsign != 0)\n mask[isign] = False\n\n # =============== REPARTITION ===============\n # Sum over sources dimension :\n sm = np.sum(mask, 1, dtype=np.int)\n smmask = np.invert(sm.astype(bool))\n repartition[:, k] = np.ma.masked_array(sm, mask=smmask)\n\n return repartition","def cross_route(current: Solution, rnd_state: Generator) -> Solution:\n problem = Problem()\n destroyed = deepcopy(current)\n\n customers = set(range(problem.num_customers))\n removed = SetList()\n\n while len(removed) < customers_to_remove():\n candidate = rnd_state.choice(tuple(customers))\n\n route_candidate = destroyed.find_route(candidate)\n _remove(destroyed, candidate, removed, customers)\n\n # Find the nearest customer that is not yet removed and in a different\n # route, and remove it and its neighbours as well.\n for other in problem.nearest_customers[candidate]:\n if other not in route_candidate and other not in removed:\n _remove(destroyed, other, removed, customers)\n break\n\n destroyed.unassigned = removed.to_list()\n\n return destroyed","def simplify(self):\n state_copy = copy.deepcopy(self)\n state_copy.space.spacecrafts = [state_copy.spacecraft] + state_copy.space.close_spacecrafts_to(\n state_copy.spacecraft, self.PERCEPTION_DISTANCE)\n\n return state_copy","def clean_junctions(seqlst, proteins, escores, models, mutate_cutoff=0.38,\n mutate_gap=0, primer=\"GTCTTGATTCGCTTGACGCTGCTG\",\n max_mutate_count=2):\n # loop through each sequence in seqlst\n for i in range(len(seqlst)):\n seq = seqlst[i]\n # if there is not sequence, don't do anything\n if seq == \"\":\n continue\n es_preds = {}\n model_preds = {}\n es_preds_primer = {}\n model_preds_primer = {}\n es_preds_primer = {}\n model_preds_primer = {}\n d = {\"sequence\": [seq]}\n df = pd.DataFrame.from_dict(d)\n d_primer = {\"sequence\": [seq + primer]}\n df_primer = pd.DataFrame.from_dict(d_primer)\n # check for forward orientation\n for protein in proteins:\n # predict sequence without primer\n es_preds[protein] = escores[protein].predict_sequences(df)[\"sequence1\"]\n model_preds[protein] = models[protein].predict_sequences(df)[\"sequence1\"]\n # predict sequence with primer\n es_preds_primer[protein] = escores[protein].predict_sequences(df_primer)[\"sequence1\"]\n model_preds_primer[protein] = models[protein].predict_sequences(df_primer)[\"sequence1\"]\n seq_bs = Sequence(es_preds, model_preds, proteins, escores, mutate_cutoff, mutate_gap)\n seq_primer_bs = Sequence(es_preds_primer, model_preds_primer, proteins,\n escores, mutate_cutoff, mutate_gap)\n # theres a sequence with less bsites with primer. why?\n if seq_bs.site_count_all() > seq_primer_bs.site_count_all():\n print(\"Number of bsites with primer should not be less than without\")\n seqlst[i] = \"\"\n if seq_bs.site_count_all() < seq_primer_bs.site_count_all():\n new_seq = clean_junction_seq(ori_seq=seq,\n proteins=proteins,\n mutate_cutoff=mutate_cutoff,\n escores=escores,\n max_mutate_count=2)\n if new_seq == seq:\n seqlst[i] = \"\"\n\n # check reverse complement\n for i in range(len(seqlst)):\n # get the sequence\n seq = seqlst[i]\n # get the reverse complement of the primer\n primer_obj = Seq(primer)\n rev_primer = str(primer_obj.reverse_complement())\n # if there is not sequence, don't do anything\n if seq == \"\":\n continue\n\n es_preds = {}\n model_preds = {}\n es_preds_primer = {}\n model_preds_primer = {}\n\n d = {\"sequence\": [seq]}\n df = pd.DataFrame.from_dict(d)\n d_primer = {\"sequence\": [rev_primer + seq]}\n df_primer = pd.DataFrame.from_dict(d_primer)\n\n # check for reverse complement\n for protein in proteins:\n # predict sequence without primer\n es_preds[protein] = escores[protein].predict_sequences(df)[\"sequence1\"]\n model_preds[protein] = models[protein].predict_sequences(df)[\"sequence1\"]\n # predict reverse complement of sequence with primer\n es_preds_primer[protein] = escores[protein].predict_sequences(df_primer)[\"sequence1\"]\n model_preds_primer[protein] = models[protein].predict_sequences(df_primer)[\"sequence1\"]\n seq_bs = Sequence(es_preds, model_preds, proteins, escores, mutate_cutoff, mutate_gap)\n seq_primer_bs = Sequence(es_preds_primer, model_preds_primer, proteins,\n escores, mutate_cutoff, mutate_gap)\n if seq_bs.site_count_all() > seq_primer_bs.site_count_all():\n print(\"Number of bsites with primer should not be less than without\")\n seqlst[i] = \"\"\n if seq_bs.site_count_all() < seq_primer_bs.site_count_all():\n new_seq = clean_junction_rev_seq(ori_seq=seq,\n proteins=proteins,\n mutate_cutoff=mutate_cutoff,\n escores=escores,\n max_mutate_count=2)\n if new_seq == seq:\n seqlst[i] = \"\"\n\n else:\n seqlst[i] = seqlst[i] + primer\n\n # if wild type is empty, return false\n if seqlst[0] == \"\":\n return [], False\n\n # otherwise, return the new seqlist\n return seqlst, True","def unchanging(sv):\r\n for nod in sv.Object.values():\r\n clauselist=[] # initialize new clause list \r\n for cond, vlu in nod.clauses:\r\n if cond[0]==Change: # look for change condition\r\n if is_fixed(cond[1][0]): continue # ignore clause \r\n if cond[1][0]==nod.name: continue # ignore clause \r\n clauselist+=[(cond, vlu)] # accept clause\r\n nod.clauses=clauselist","def trim2(self, starttime=None, endtime=None, reftime=None, check_npts=True, **kwargs):\n # same as in rf package + mid possibility\n for tr in self.traces:\n st = tr.stats\n ref = (st.starttime + 0.5 * (st.endtime - st.starttime)\n if reftime in ('mid', 'middle') else reftime)\n t1 = _seconds2utc(tr, starttime, reftime=ref)\n t2 = _seconds2utc(tr, endtime, reftime=ref)\n tr.trim(t1, t2, **kwargs)\n if check_npts:\n npts = int(round(np.median([len(tr) for tr in self.traces])))\n self.traces = [tr for tr in self.traces if len(tr) >= npts]\n for tr in self.traces:\n tr.data = tr.data[:npts]\n return self","def smart_concat(strokes):\n\n # compute the average of spaces between connected points\n total_length = 0\n for stroke in strokes:\n length, _ = stroke.euclidian_length()\n total_length += length\n space = total_length / float(len(strokes) * 7 + 0.00001)\n\n i = 0\n while len(strokes[i + 1:]) > 0:\n test = False\n stroke = strokes[i]\n indice = i\n for stroke_i in strokes[i + 1:]:\n\n indice += 1\n x11 = stroke.get_x()[-1]\n x21 = stroke_i.get_x()[0]\n y11 = stroke.get_y()[-1]\n y21 = stroke_i.get_y()[0]\n\n x12 = stroke.get_x()[-2]\n x22 = stroke_i.get_x()[1]\n y12 = stroke.get_y()[-2]\n y22 = stroke_i.get_y()[1]\n dist = np.sqrt((x11 - x21) ** 2 + (y11 - y21) ** 2)\n\n dx1 = x11 - x12\n dx2 = x21 - x11\n dx3 = x22 - x21\n dx = [dx1, dx2, dx3]\n # print dx\n\n dy1 = y11 - y12\n dy2 = y21 - y11\n dy3 = y22 - y21\n dy = [dy1, dy2, dy3]\n # print dy\n\n good_angle = False\n \"\"\"if dx1*dx3<0 and dy1*dy3<0:\n good_angle = True\"\"\"\n\n if max(dx) * min(dx) > -10 and max(dy) * min(dy) > -10:\n good_angle = True\n\n if dist < space and good_angle:\n test = True\n strokes[i] = concat([stroke, stroke_i])\n strokes[indice:-1] = strokes[indice + 1:]\n strokes = strokes[:-1]\n break\n if not test:\n i += 1\n\n return strokes","def trim_data(data, xy, p = 0.1):\n if xy is False:\n length = len(data)\n num = int(length * (p/2))\n return data[num:length - num]\n X, Y = data\n length = len(X)\n num = int(length * (p/2))\n return X[num:length - num], Y[num:length - num]","def connect_points(clipped, side1, side2, window):\n edge = side1\n while edge != side2:\n clipped.append(window.points[0][edge])\n edge = (edge - 1) % 4","def copy_triangle(tri):\n return [[peg for peg in row] for row in tri]","def _strip(self, mols):\n\n # The order of operations is important here as stripping atom map\n # numbers first will lead to total removal of the molecules.\n return self._strip_map(self._strip_env(mols))","def smart_split(strokes):\n\n splited = []\n for stroke in strokes:\n splited += stroke.split_non_differentiable_points()\n return splited","def Trim(self, *args):\n return _Adaptor3d.Adaptor3d_Curve_Trim(self, *args)","def remove_projection(X, w):\n return [remove_projection_from_vector(x_i, w) for x_i in X]","def proc_sw_only_morphs(forward_pairs, morphs, backward_pairs):\n sandwich_pairs = []\n if not backward_pairs:\n forward_pairs[-1].morphs.extend(morphs)\n elif len(morphs) == 1:\n morph = morphs[0]\n morph_str = str(morph)\n if morph_str in ['이/VCP', '하/VX'] and backward_pairs[0].morphs[0].tag.startswith('E'):\n # '이' 긍정지정사나 '하' 보조용언 뒤에 어미가 나올 경우\n backward_pairs[0].morphs.insert(0, morphs[0])\n del morphs[:]\n elif morph_str == '에/JKB' and backward_pairs[0].morphs[0].tag == 'JX':\n # '에' 부사격조사 뒤에 보조사가 나올 경우\n backward_pairs[0].morphs.insert(0, morphs[0])\n del morphs[:]\n elif morph_str == 'ᆯ/ETM' and forward_pairs[-1].morphs[-1].tag.startswith('V'):\n # 'ㄹ' 관형형전성어미 앞에 용언이 나올 경우\n forward_pairs[-1].morphs.append(morphs[0])\n del morphs[:]\n elif morph.tag in ['EC', 'EF'] and forward_pairs[-1].morphs[-1].tag.startswith('V'):\n # 연결어미나 종결어미 앞에 용언이 나올 경우\n forward_pairs[-1].morphs.append(morphs[0])\n del morphs[:]\n elif morph.tag.startswith('XS'):\n # append suffixes to the end of forward pair list\n forward_pairs[-1].morphs.append(morphs[0])\n del morphs[:]\n else:\n raise AlignError()\n else:\n morphs_str = ' + '.join([str(morph) for morph in morphs])\n if morphs_str == '(/SS + 대북/NNG + (/SS + 대북/NNG + )/SS + )/SS' and forward_pairs[-1].word_str == u'대북':\n del morphs[:]\n elif morphs_str == '(/SS + 동경/NNP + )/SS' and forward_pairs[-1].word_str == u'도쿄':\n del morphs[:]\n else:\n raise AlignError()\n return sandwich_pairs","def cut_ppl_off(self, G):\r\n for pre, node in list(G.edges):\r\n ew = G.edges[pre, node]['weight']\r\n if ew <= -.95:\r\n G.remove_edge(pre, node)\r\n elif ew >= 1:\r\n G.edges[pre, node]['weight'] = 1.0\r\n else:\r\n continue\r\n return G","def remove_gap_traces(st):\n # Check 1:\n gaps = st.get_gaps()\n for i in range(len(gaps)):\n for tr in st.select(network=gaps[i][0], station=gaps[i][1], location=gaps[i][2], channel=gaps[i][3]):\n st.remove(tr)\n # Check 2:\n masked = [np.ma.is_masked(tr.data) for tr in st]\n for i, tr in enumerate(st):\n if masked[i]:\n st.remove(tr)\n return st","def get_clipped_pointcloud(pointcloud, boundary):\r\n\tassert (pointcloud.shape[0]>=2)\r\n\tpointcloud = pointcloud[:,np.logical_and(pointcloud[0,:]<boundary[1], pointcloud[0,:]>boundary[0])]\r\n\tpointcloud = pointcloud[:,np.logical_and(pointcloud[1,:]<boundary[3], pointcloud[1,:]>boundary[2])]\r\n\treturn pointcloud","def remove_constant_points(path):\n z = path\n while \"UD\" in z or \"DU\" in z or \"LR\" in z or \"RL\" in z:\n z = z.replace(\"UD\", \"\")\n z = z.replace(\"DU\", \"\")\n z = z.replace(\"LR\", \"\")\n z = z.replace(\"RL\", \"\")\n return z","def translateSweep(self, vect, epsilon=COMPARISON_EPSILON):\n return self.sweep(lambda c: (c[0] + vect.x,\n c[1] + vect.y,\n c[2] + vect.z),\n epsilon)","def zzX_strip(f):\n if poly_univariate_p(f):\n return zzx_strip(f)\n\n if zzX_zero_p(f):\n return f\n\n k = 0\n\n for coeff in f:\n if not zzX_zero_p(coeff):\n break\n else:\n k += 1\n\n if k == len(f):\n return zzX_zero_of(f)\n else:\n return f[k:]","def simplify_plaquettes(self, model, dataset=None):\n for x in self.xvals():\n for y in self.yvals():\n p = self.get_plaquette(x, y)\n if p is not None:\n p.simplify_circuits(model, dataset)","def cutPoly(self,geom,startPt,endPt,debug=False):\r\n #if we have disjoint Multi geometry as geom to split we need to iterate over its parts\r\n splittedGeoms=[]\r\n leftFragments=[]\r\n rightFragments=[]\r\n #if self.debug: print \"Number of geoms when slicing: \",str(len(geom.asGeometryCollection()))\r\n for geomPart in geom.asGeometryCollection():\r\n #split the actual part by cut line defined by startPt,endPt\r\n (res,splittedGeomsPart,topo)=geomPart.splitGeometry([startPt,endPt],False)\r\n splittedGeoms+=splittedGeomsPart\r\n #Add the remaining geomPart to the rightFragments or letfFragments\r\n #depending on distance\r\n d=self.signedDistCentroidFromLine(geomPart,startPt,endPt)\r\n if d>0:\r\n rightFragments.append(geomPart)\r\n else:\r\n leftFragments.append(geomPart)\r\n #if self.debug: print j,splittedGeoms\r\n\r\n for fragment in splittedGeoms:\r\n \"\"\"\r\n calculate signed distance of centroid of fragment and the splitline\r\n if signed distance is below zero, the point is to the left of the line\r\n if above zero the point is to the right of the line\r\n \"\"\"\r\n d=self.signedDistCentroidFromLine(fragment,startPt,endPt)\r\n #if debug==True:\r\n #if self.debug: print d\r\n\r\n if d>0:\r\n rightFragments.append(fragment)\r\n else:\r\n leftFragments.append(fragment)\r\n\r\n #if self.debug: print \"Left frags:\",len(leftFragments),\"Right frags:\",len(rightFragments)\r\n leftGeom=self.buildMultiPolygon(leftFragments)\r\n rightGeom=self.buildMultiPolygon(rightFragments)\r\n return leftGeom,rightGeom","def prune_path(self, path):\n while len(path.poses) >= 2:\n pose0 = pose322(r2g(path.poses[0].pose))\n pose1 = pose322(r2g(path.poses[1].pose))\n d0 = np.linalg.norm(g2n(pose0.between(self.current_frame.pose)))\n d1 = np.linalg.norm(g2n(pose1.between(self.current_frame.pose)))\n if d1 < d0:\n path.poses.pop(0)\n else:\n break\n return path","def get_layer_trimmed(self, layername: str):\n\n lyr = self.get_layer_by_name(layername)\n notnan = ~np.isnan(lyr)\n rows = np.any(notnan, axis=1)\n cols = np.any(notnan, axis=0)\n rmin, rmax = np.where(rows)[0][[0, -1]]\n cmin, cmax = np.where(cols)[0][[0, -1]]\n\n rmax += 1\n cmax += 1\n\n return lyr[rmin:rmax, cmin:cmax], [rmin, cmin], [rmax, cmax]","def destroy(\n start: int, cycle: List[int], destroy_fraction: float\n) -> Tuple[List[int], Set[int]]:\n n = len(cycle)\n to_destroy = int(destroy_fraction * n)\n\n removed_vertices = set(cycle[start : start + to_destroy])\n cycle[start : start + to_destroy] = []\n\n if start + to_destroy > n:\n removed_vertices.update(cycle[0 : start + to_destroy - n])\n cycle[0 : start + to_destroy - n] = []\n\n return cycle, removed_vertices","def truncate(self,G):\n return {(v,w):{(v,u) for u in G[v] if u != w} | {(w,v)}\n for v in G for w in G[v]}","def clean(self):\n if self.reloading:\n self.cleaned = pd.concat(\n [self.raw[0: self.brkIdx1+1],\n self.raw[self.brkIdx3+1: self.brkIdx4+1]])\n else:\n self.cleaned = self.raw[0: self.brkIdx1+1]\n self.cleaned.reset_index(drop=True, inplace=True) # update idx\n # -- Cubic spline that passes through the data\n sigmaLog = np.log10(self.cleaned['stress'][1:])\n cs = CubicSpline(x=sigmaLog, y=self.cleaned['e'][1:])\n self.eSigmaV = float(cs(np.log10(self.sigmaV))) # void ratio at sigmaV\n return","def left_guard_separated(self) -> Sequence[np.poly1d]:\n l_fit = np.copy(self.fit)\n l_fit[-1] += self.tolerance * self.image.dpmm\n if not self._separate_leaves:\n return [\n np.poly1d(l_fit),\n ]\n else:\n other_fit = copy.copy(l_fit)\n mag_factor = self.image.sid / 1000\n l_fit[-1] += self._nominal_gap * mag_factor / 2 * self.image.dpmm\n other_fit[-1] -= self._nominal_gap * mag_factor / 2 * self.image.dpmm\n return [np.poly1d(l_fit), np.poly1d(other_fit)]","def VTrim(self, *args):\n return _Adaptor3d.Adaptor3d_Surface_VTrim(self, *args)","def trim(self, start, end):","def copy(self):\n return Segment([p.copy() for p in self.endpoints])","def clean():\n filter_phase_data()\n combine_phase_data()\n remove_duplicates_phase_data()","def stage_three_preprocessing(data: pd.Series) -> pd.Series:\n data_ = data.dropna()\n data_ = shrink_whitespace(data_)\n #data_ = lemmatize(data_)\n return data_","def trimap(adata: AnnData, *args, **kwargs):\n return scatters(adata, \"trimap\", *args, **kwargs)","def delaunay(cls,\n points: Sequence[Point],\n context: Context) -> 'Triangulation':\n points = sorted(points)\n result = [cls._initialize_triangulation(points[start:stop],\n context)\n for start, stop in pairwise(accumulate(\n chain((0,), coin_change(len(points), _base_cases))))]\n for _ in repeat(None, ceil_log2(len(result))):\n parts_to_merge_count = len(result) // 2 * 2\n result = ([result[offset]._merge(result[offset + 1])\n for offset in range(0, parts_to_merge_count, 2)]\n + result[parts_to_merge_count:])\n return result[0]","def ltrim1 (l,proportiontocut,tail='right'):\r\n if tail == 'right':\r\n lowercut = 0\r\n uppercut = len(l) - int(proportiontocut*len(l))\r\n elif tail == 'left':\r\n lowercut = int(proportiontocut*len(l))\r\n uppercut = len(l)\r\n return l[lowercut:uppercut]","def makeSparse(self):\n center = self.center\n l = []\n for point in self.points:\n angle = Vector.createFromTwoPoints(point, center).angle\n l.append((angle, copy.deepcopy(point)))\n l = sorted(l, key=lambda x: x[0])\n for i in range(len(l)):\n self.points[i].set(l[i][1])","def remove_projection_from_vector(v, w):\n return vector_subtract(v, project(v, w))"],"string":"[\n \"def decomposing_line_cut_by_splicing(P, v, w):\\n\\n\\n\\tv_Point = Point(v)\\n\\tw_Point = Point(w)\\n\\n\\tchain = LineString(P[0]+[P[0][0]])\\n\\n\\tdistance_to_v = chain.project(v_Point)\\n\\tdistance_to_w = chain.project(w_Point)\\n\\n\\tif not chain.intersects(v_Point):\\n\\t\\tprint(\\\"decomposing_cut_as_line: V not on chain\\\")\\n\\tif not chain.intersects(w_Point):\\n\\t\\tprint(\\\"decomposing_cut_as_line: W not on chain\\\")\\n\\tif distance_to_w == distance_to_v:\\n\\t\\tprint(\\\"decomposing_cut_as_line: W and V are the same\\\")\\n\\n\\n\\tif distance_to_w >= chain.length or distance_to_w == 0:\\n\\n\\t\\tleft_chain, right_chain = cut_linestring(chain, distance_to_v)\\n\\n\\t\\tp_l = left_chain.coords[:]\\n\\t\\tp_r = right_chain.coords[:]\\t\\t\\n\\n\\t\\treturn p_l, p_r\\n\\n\\tif distance_to_v >= chain.length or distance_to_v == 0:\\n\\n\\t\\tleft_chain, right_chain = cut_linestring(chain, distance_to_w)\\n\\n\\t\\tp_l = right_chain.coords[:]\\n\\t\\tp_r = left_chain.coords[:]\\t\\t\\n\\n\\t\\treturn p_l, p_r\\n\\n\\n\\tif distance_to_w > distance_to_v:\\n\\n\\t\\tleft_v_cut, right_v_cut = cut_linestring(chain, distance_to_v)\\n\\n\\t\\tdistance_to_w = right_v_cut.project(w_Point)\\n\\t\\tleft_w_chain, right_w_chain = cut_linestring(right_v_cut, distance_to_w)\\n\\n\\t\\tp_l = left_v_cut.coords[:]+right_w_chain.coords[:-1]\\n\\t\\tp_r = left_w_chain.coords[:]\\n\\n\\t\\treturn p_l, p_r\\n\\n\\telse:\\n\\n\\t\\tleft_w_cut, right_w_cut = cut_linestring(chain, distance_to_w)\\n\\n\\t\\tdistance_to_v = right_w_cut.project(v_Point)\\n\\t\\tleft_v_chain, right_v_chain = cut_linestring(right_w_cut, distance_to_v)\\n\\n\\t\\tp_l = left_w_cut.coords[:]+right_v_chain.coords[:-1]\\n\\t\\tp_r = left_v_chain.coords[:]\\n\\n\\t\\treturn p_l, p_r\",\n \"def decomposing_poly_cut_by_set_op(P, v, w, epsilon=10e-2):\\n\\n\\n\\tgetcontext().prec = 28\\n\\n\\tv_Point = Point(v)\\n\\tw_Point = Point(w)\\n\\n\\tchain = LineString(P[0]+[P[0][0]])\\n\\n\\tif not chain.intersects(v_Point):\\n\\t\\tprint(\\\"decomposing_poly_cut_as_line: V not on chain\\\")\\n\\tif not chain.intersects(w_Point):\\n\\t\\tprint(\\\"decomposing_poly_cut_as_line: W not on chain\\\")\\n\\n\\n\\tdistance_to_v = chain.project(v_Point)\\n\\tdistance_to_w = chain.project(w_Point)\\n\\n\\tif distance_to_w == distance_to_v:\\n\\t\\tprint(\\\"decomposing_cut_as_line: W and V are the same\\\")\\n\\n\\n\\t# Generate pairs of v and w modified by some epsilon amount \\n\\tv_l_displacements = [distance_to_v+(i*epsilon) for i in [-1, -2, 0]]\\n\\tv_r_displacements = [(distance_to_v+(i*epsilon))%chain.length for i in [1, 0, 2]]\\n\\tw_l_displacements = [distance_to_w+(i*epsilon) for i in [-1, -2, 0]]\\n\\tw_r_displacements = [(distance_to_w+(i*epsilon))%chain.length for i in [1, 0, 2]]\\n\\n\\tdef splice_polygon(dist_v, dist_w):\\n\\t\\t\\\"\\\"\\\"Portion of decomposing_line_cut_by_splicing wihtout points\\n\\n\\t\\tFunction for evaluating validity of candidates\\n\\t\\t\\\"\\\"\\\"\\n\\n\\t\\tif dist_w >= chain.length or dist_w == 0:\\n\\n\\t\\t\\tleft_chain, right_chain = cut_linestring(chain, dist_v)\\n\\n\\t\\t\\tp_l = left_chain.coords[:]\\n\\t\\t\\tp_r = right_chain.coords[:]\\t\\t\\n\\n\\t\\t\\treturn p_l, p_r\\n\\n\\t\\tif dist_v >= chain.length or dist_v == 0:\\n\\n\\t\\t\\tleft_chain, right_chain = cut_linestring(chain, dist_w)\\n\\n\\t\\t\\tp_l = right_chain.coords[:]\\n\\t\\t\\tp_r = left_chain.coords[:]\\t\\t\\n\\n\\t\\t\\treturn p_l, p_r\\n\\n\\n\\t\\tif dist_w%chain.length > dist_v%chain.length:\\n\\n\\t\\t\\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\\n\\t\\t\\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\\n\\n\\t\\t\\tcommon = LineString(left_w_chain).difference(LineString(left_v_chain))\\n\\n\\t\\t\\tp_l = left_v_chain.coords[:]+right_w_chain.coords[:-1]\\n\\t\\t\\tp_r = common.coords[:]\\n\\n\\t\\t\\treturn p_l, p_r\\n\\n\\t\\telse:\\n\\n\\t\\t\\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\\n\\t\\t\\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\\n\\n\\t\\t\\tcommon = LineString(left_v_chain).difference(LineString(left_w_chain))\\n\\n\\t\\t\\tp_l = common.coords[:]\\n\\t\\t\\tp_r = left_w_chain.coords[:]+right_v_chain.coords[:-1]\\n\\n\\t\\t\\treturn p_l, p_r\\n\\n\\t# Check every ring for self-intersection, if cut is invalid => self-intersec\\n\\tfound = False\\n\\tfor i in range(len(v_l_displacements)):\\n\\t\\tfor j in range(len(w_l_displacements)):\\n\\n\\t\\t\\t# Check if resultant polygons are valid\\n\\t\\t\\tp_l, p_r = splice_polygon(v_l_displacements[i], w_r_displacements[j])\\n\\t\\t\\tp_l_lr = LinearRing(p_l+[p_l[0]])\\n\\t\\t\\tp_r_lr = LinearRing(p_r+[p_r[0]])\\n\\n\\t\\t\\tif not p_l_lr.is_valid or not p_r_lr.is_valid:\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tp_l, p_r = splice_polygon(v_r_displacements[i], w_l_displacements[j])\\n\\t\\t\\tp_l_lr = LinearRing(p_l+[p_l[0]])\\n\\t\\t\\tp_r_lr = LinearRing(p_r+[p_r[0]])\\n\\n\\t\\t\\tif not p_l_lr.is_valid or not p_r_lr.is_valid:\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# Else, we have a valid candidate cut\\n\\t\\t\\tfound = True\\n\\t\\t\\tbreak\\n\\n\\t\\tif found:\\n\\t\\t\\tbreak\\n\\n\\tif not found:\\n\\t\\tprint(\\\"splice_polygon: No correct cut combination found!\\\")\\n\\t\\treturn\\n\\n\\tv_l = chain.interpolate(v_l_displacements[i]).coords[:]\\n\\tv_r = chain.interpolate(v_r_displacements[i]).coords[:]\\n\\tw_l = chain.interpolate(w_l_displacements[j]).coords[:]\\n\\tw_r = chain.interpolate(w_r_displacements[j]).coords[:]\\n\\n\\tdef get_verts(v_l, v_r):\\n\\t\\t\\\"\\\"\\\"Function for extraction verts between two points\\n\\t\\t\\\"\\\"\\\"\\n\\n\\t\\tv_l = v_l%chain.length\\n\\t\\tv_r = v_r%chain.length\\n\\n\\t\\tpoints = []\\n\\t\\tcoords = list(chain.coords)\\n\\t\\tif v_r > v_l:\\n\\n\\t\\t\\tfor i in range(1, len(coords)):\\n\\t\\t\\t\\n\\t\\t\\t\\tpd = LineString(coords[:i+1]).length\\n\\n\\t\\t\\t\\tif pd > v_l and pd < v_r:\\n\\t\\t\\t\\t\\tpoints.append(coords[i])\\n\\t\\telse:\\n\\n\\t\\t\\tfor i in range(1, len(coords)):\\n\\t\\t\\t\\n\\t\\t\\t\\tpd = LineString(coords[:i+1]).length\\n\\n\\t\\t\\t\\tif pd > v_l:\\n\\t\\t\\t\\t\\tpoints.append(coords[i])\\n\\n\\t\\t\\tfor i in range(1, len(coords)):\\n\\t\\t\\t\\n\\t\\t\\t\\tpd = LineString(coords[:i+1]).length\\n\\n\\t\\t\\t\\tif pd < v_r:\\n\\t\\t\\t\\t\\tpoints.append(coords[i])\\n\\n\\n\\t\\treturn points\\n\\n\\t# Find all vertecies of the chain betwee v_l and v_r\\n\\tv_pts = get_verts(v_l_displacements[i], v_r_displacements[i])\\n\\tw_pts = get_verts(w_l_displacements[j], w_r_displacements[j])\\n\\n\\tpoly = Polygon(*P)\\n\\n\\tcut_poly = Polygon(v_l+v_pts+v_r+w_l+w_pts+w_r)\\n\\tcut_poly = poly.intersection(cut_poly)\\n\\n\\tprint cut_poly\\n\\n\\tp_l, p_r = poly.difference(cut_poly)\\n\\n\\tprint p_l\\n\\tprint p_r\",\n \"def simplify(self):\\n \\n added_clumps = []\\n staying_tunnels = []\\n removed_clumps = set()\\n \\n for tunnel in self.tunnels:\\n tunnel_end_distance = self.get_distance(tunnel.start, tunnel.end)\\n if tunnel_end_distance - tunnel.start.distance_from_wall < 0 or \\\\\\n tunnel_end_distance - tunnel.end.distance_from_wall < 0:\\n removed_clumps.add(tunnel.start.node)\\n removed_clumps.add(tunnel.end.node)\\n new_node = tunnel.merge_endpoints()\\n added_clumps.append(new_node)\\n else:\\n staying_tunnels.append(tunnel)\\n #print removed_clumps\\n \\n new_clumps = []\\n \\n for clump in list(self.clumps) + added_clumps:\\n if clump not in removed_clumps:\\n new_clumps.append(clump)\\n else:\\n removed_clumps.remove(clump)\\n\\n if removed_clumps:\\n raise Exception(\\\"Some removed clumps couldn't be found in the main set and I'm scared\\\")\\n \\n self.clumps = new_clumps\\n self.tunnels = staying_tunnels\",\n \"def unfold_wire(pl):\\n\\tpl = phone_pl\\n\\tshape_points = [np.array(p) for p in pl.points]\\n\\tpointIter = takeNGenerator(shape_points, 4)\\n\\td0 = getDistance(*shape_points[0:2])\\n\\tpoints = [np.array([0, 0]), np.array([0, d0])]\\n\\tfor i in range(len(shape_points)-3):\\n\\t\\t(p1,p2,p3,p4) = pointIter.next()\\n\\t\\tv1 =p1-p2\\n\\t\\tv2 = p3-p2\\n\\t\\tv3 = p2-p3\\n\\t\\tv4 = p4-p3\\n\\t\\told_normal = np.cross(v1,v2)\\n\\t\\tnew_normal = np.cross(v3,v4)\\n\\t\\tnorm_old = old_normal/la.norm(old_normal)\\n\\t\\tnorm_new = old_normal/la.norm(new_normal)\\n\\n\\n\\t\\t#check if we need to transform:\\n\\t\\tif any(norm_old != norm_new):\\n\\t\\t\\tprint norm_old, norm_new\\n\\t\\t\\t#create a transform that will rotate the next points to the old orientation\\n\\t\\t\\ttransform = create_transform(norm_new, norm_old)\\n\\t\\t\\trot_pot = p2\\n\\t\\t\\tpose = (rot_pot, transform)\\n\\t\\t\\tpoly = PolyLine(shape_points[i:])\\n\\t\\t\\ttranslated = poly.transformed(pose)\\n\\t\\t\\tnew_pts = [np.array(p) for p in translated.points]\\n\\n\\t\\t\\tif len(shape_points[:i]) is 0:\\n\\t\\t\\t\\tshape_points = new_pts\\n\\t\\t\\telse:\\n\\t\\t\\t\\tshape_points = np.vstack((shape_points[:i], new_pts))\\n\\t\\t\\tpointIter = takeNGenerator(shape_points, 4)\\n\\t\\t\\tfast_forward(pointIter, i)\\n\\treturn PolyLine(shape_points)\",\n \"def simplify_line_vw(points, small_area=100):\\r\\n while len(points) > 3:\\r\\n \\r\\n # For each coordinate that forms the apex of a two-segment\\r\\n # triangle, find the area of that triangle and put it into a list\\r\\n # along with the index, ordered from smallest to largest.\\r\\n \\r\\n popped, preserved = set(), set()\\r\\n \\r\\n triples = zip(points[:-2], points[1:-1], points[2:])\\r\\n triangles = [Polygon((p1, p2, p3)) for (p1, p2, p3) in triples]\\r\\n areas = [(triangle.area, index) for (index, triangle) in enumerate(triangles)]\\r\\n \\r\\n # Reduce any segments that makes a triangle whose area is below\\r\\n # the minimum threshold, starting with the smallest and working up.\\r\\n # Mark segments to be preserved until the next iteration.\\r\\n\\r\\n for (area, index) in sorted(areas):\\r\\n if area > small_area:\\r\\n # nothing more can be removed on this iteration\\r\\n break\\r\\n \\r\\n if (index + 1) in preserved:\\r\\n # current index is too close to a previously-preserved one\\r\\n continue\\r\\n \\r\\n preserved.add(index)\\r\\n popped.add(index + 1)\\r\\n preserved.add(index + 2)\\r\\n \\r\\n if not popped:\\r\\n # nothing was removed so we are done\\r\\n break\\r\\n \\r\\n # reduce the line, then try again\\r\\n points = [point for (index, point) in enumerate(points) if index not in popped]\\r\\n \\r\\n return list(points)\",\n \"def coll_trim(th):\\n lam = TipLoss(lamInit, th)\\n AoA = th - lam / r\\n dCL, dCD = PolarLookup(AoA)\\n dCT = 0.5 * solDist * (dCL*np.cos(lam/r)-dCD*np.sin(lam/r))* r ** 2\\n # dCT = 0.5 * solDist * dCL * r ** 2\\n CT = np.trapz(dCT, r)\\n\\n return CT, dCT, dCL, dCD, lam, AoA\",\n \"def clean_up(P, c):\\n if not P.pairs: return # root case\\n P.siblings.pop()\\n s,r = P.pairs.pop()\\n P.shape_pool.add(s)\\n P.resource_pool.add(r)\\n if P.r2p:\\n pathway_id = P.r2p[P.resources[r]]\\n if c and c[pathway_id]:\\n c[pathway_id].pop()\\n if P.segments[pathway_id]:\\n P.segments[pathway_id].pop()\",\n \"def attempt_splice(triple):\\n\\n def overlap_condition(triple):\\n \\\"\\\"\\\"\\n Decide whether these paths meet the overlap condition.\\n Return fwd, rev, and overlap for next steps.\\n \\\"\\\"\\\"\\n p3_len = len(self.paths[triple[2]])\\n\\n fwd = compute_fwd(self.paths[triple[0]], self.paths[triple[2]])\\n rev = compute_rev(self.paths[triple[2]], self.paths[triple[1]])\\n overlap = rev + fwd - p3_len\\n if fwd + rev - p3_len >= 0:\\n print(\\\"# Triple {} meets overlap condition.\\\".format(triple))\\n #print(\\\"fwd = {}, rev = {}, lap = {}\\\".format(fwd, rev, overlap))\\n return(True, fwd, rev, overlap)\\n return(False, fwd, rev, overlap)\\n\\n\\n def flow_condition(p_prime, p3, triple):\\n \\\"\\\"\\\"Process two potential paths resulting from a set of three\\n paths.\\\"\\\"\\\"\\n\\n all_edges = set(self.arc_info.keys())\\n not_p_prime = all_edges.difference(set(p_prime))\\n #print(\\\"Not p_prime: {}\\\".format(not_p_prime))\\n not_p3 = all_edges.difference(set(p3))\\n #print(\\\"Not p_3: {}\\\".format(not_p3))\\n p_prime_alone = list(set(p_prime).intersection(not_p3))\\n #print(\\\"p_prime_alone: {}\\\".format(p_prime_alone))\\n p3_alone = list(set(p3).intersection(not_p_prime))\\n #print(\\\"p3 alone: {}\\\".format(p3_alone))\\n overlap = list(set(p3).intersection(p_prime))\\n #print(\\\"overlap alone: {}\\\".format(overlap))\\n\\n #print(\\\"computing L_wprime and U_wprime\\\")\\n L_wprime, U_wprime = compute_bounds(p_prime_alone, triple)\\n #print(\\\"computing L_w3 and U_w3\\\")\\n L_w3, U_w3 = compute_bounds(p3_alone, triple)\\n #print(\\\"computing L_overlap and U_overlap\\\")\\n L_overlap, U_overlap = compute_bounds(overlap, triple)\\n #print(\\\"L_wprime, U_wprime: {} {}\\\".format(L_wprime, U_wprime))\\n #print(\\\"L_w3, U_w3: {} {}\\\".format(L_w3, U_w3))\\n #print(\\\"{} <= {}\\\".format(L_overlap, U_wprime + U_w3))\\n #print(\\\"{} >= {}\\\".format(U_overlap, L_wprime + L_w3))\\n meets_conditions = (L_wprime <= U_wprime) & \\\\\\n (L_w3 <= U_w3) & \\\\\\n (L_overlap <= U_wprime + U_w3) & \\\\\\n (L_wprime + L_w3 <= U_overlap)\\n if meets_conditions:\\n w_prime, w3 = center_flows(L_wprime, U_wprime,\\n L_w3, U_w3,\\n L_overlap, U_overlap)\\n # change paths\\n # first, delete:\\n for index in sorted(triple, reverse=True):\\n del self.paths[index]\\n del self.weights[index]\\n # now, add:\\n self.paths.append(p3)\\n self.paths.append(p_prime)\\n self.weights.append(w3)\\n self.weights.append(w_prime)\\n # update weights on edges\\n self.update_edge_weights()\\n self.check_flow()\\n self.check_paths()\\n return(True)\\n else:\\n return(False)\\n\\n\\n def check_flow_conditions(triple, fwd, rev, overlap):\\n \\\"\\\"\\\"Check that the flow condition is met.\\n If it is, return the new paths with weights.\\\"\\\"\\\"\\n\\n p1, p2, p3 = [self.paths[triple[x]] for x in [0,1,2]]\\n p2_end_index = len(p2) - rev + overlap\\n #print(\\\"p2_end_index = {}\\\".format(p2_end_index))\\n p1_start_index = fwd + 1\\n #print(\\\"p1_start_index = {}\\\".format(p1_start_index))\\n #print(\\\"p1 subset: {}\\\".format(p1[p1_start_index - 1:]))\\n #print(\\\"p2 subset = {}\\\".format(p2[:p2_end_index]))\\n p_prime = p2[:p2_end_index] + p1[p1_start_index - 1:]\\n #print(\\\"p_prime = {}\\\".format(p_prime))\\n\\n # try to rebalance\\n if flow_condition(p1, p2, triple):\\n print(\\\"Rebalance opportunity found. Now rebalancing.\\\")\\n self.rebalances += 1\\n return(True)\\n\\n # try to splice and merge\\n if flow_condition(p_prime, p3, triple):\\n print(\\\"Splice+merge opportunity found. Now splicing.\\\")\\n self.splices += 1\\n return(True)\\n\\n return(False)\\n\\n\\n #print(\\\"# Can we splice {}?\\\".format(\\n # [self.paths[x] for x in triple]))\\n overlap_true, fwd_index, rev_index, overlap = overlap_condition(\\n triple)\\n if overlap_true:\\n self.overlap_count += 1\\n return(check_flow_conditions(triple,\\n fwd_index, rev_index, overlap))\\n return(False)\",\n \"def prune_delta(links, nodes, shoreline_shp, inlets_shp, gdobj,\\r\\n prune_less):\\r\\n # Get inlet nodes\\r\\n nodes = find_inlet_nodes(nodes, inlets_shp, gdobj)\\r\\n\\r\\n if prune_less is False:\\r\\n # Remove spurs from network (this includes valid inlets and outlets)\\r\\n links, nodes = lnu.remove_all_spurs(links, nodes,\\r\\n dontremove=list(nodes['inlets']))\\r\\n\\r\\n # Clip the network with a shoreline polyline, adding outlet nodes\\r\\n links, nodes = clip_by_shoreline(links, nodes, shoreline_shp, gdobj)\\r\\n\\r\\n # Remove spurs from network (this includes valid inlets and outlets)\\r\\n links, nodes = lnu.remove_all_spurs(links, nodes,\\r\\n dontremove=list(nodes['inlets']) +\\r\\n list(nodes['outlets']))\\r\\n\\r\\n # Remove sets of links that are disconnected from inlets/outlets except for\\r\\n # a single bridge link (effectively re-pruning the network)\\r\\n links, nodes = lnu.remove_disconnected_bridge_links(links, nodes)\\r\\n\\r\\n # # Add artificial nodes where necessary\\r\\n # links, nodes = lnu.add_artificial_nodes(links, nodes, gdobj)\\r\\n\\r\\n # Remove one-node links\\r\\n links, nodes = lnu.remove_single_pixel_links(links, nodes)\\r\\n\\r\\n # Find parallel links\\r\\n links, nodes = lnu.find_parallel_links(links, nodes)\\r\\n\\r\\n return links, nodes\",\n \"def cleanOpenBranches(skeleton, skelton_copy, points, radii, length, clean = True, verbose = False):\\n \\n assert np.isfortran(skeleton);\\n assert np.isfortran(skelton_copy);\\n \\n timer = tmr.Timer();\\n timer_all = tmr.Timer();\\n \\n # find branch and end points\\n deg = cpl.convolve_3d_indices(skeleton, t3d.n26, points, out_dtype = 'uint8');\\n branchpoints = points[deg >= 3];\\n e_pts = points[deg == 1];\\n \\n if verbose:\\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\\n timer.reset();\\n \\n #prepare temps\\n #skel = skeleton.copy();\\n skel_flat = np.reshape(skelton_copy, -1, order = 'A');\\n strides = np.array(skelton_copy.strides);\\n \\n \\n if verbose:\\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\\n timer.reset();\\n \\n label = np.arange(27);\\n label = label.reshape([3,3,3]);\\n label[1,1,1] = 0;\\n \\n critical_points = [e_pts];\\n delete_points = [];\\n \\n for l in range(1, length + 1):\\n #neighbours of end points\\n e_pts_label = cpl.convolve_3d_indices(skelton_copy, label, e_pts);\\n \\n if verbose:\\n timer.printElapsedTime('Done labeling %d / %d' % (l, length));\\n timer.reset();\\n \\n #label zero points are non-critical short isolated branches\\n e_pts_zero = e_pts_label == 0;\\n #print 'zero length:', np.unravel_index(e_pts[e_pts_zero], skel.shape)\\n if e_pts_zero.sum() > 0:\\n keep = np.logical_not(e_pts_zero);\\n for m in range(l):\\n critical_points[m] = critical_points[m][keep];\\n e_pts_label = e_pts_label[keep];\\n e_pts = e_pts[keep];\\n \\n if verbose:\\n timer.printElapsedTime('Ignored %d small branches' % (keep.sum()));\\n timer.reset();\\n \\n e_pts_new = e_pts + np.sum((np.vstack(np.unravel_index(e_pts_label, label.shape)) - 1).T * strides, axis = 1)\\n \\n # did we hit a branch point\\n delete = np.in1d(e_pts_new, branchpoints); #, assume_unique = True);\\n keep = np.logical_not(delete);\\n #print delete.shape, keep.shape, e_pts_new.shape\\n \\n #delete all path that hit a branch point\\n if delete.sum() > 0:\\n for m in range(l):\\n delete_points.append(critical_points[m][delete]);\\n #print 'deleting:', np.unravel_index(critical_points[m][delete], skel.shape)\\n critical_points[m] = critical_points[m][keep];\\n e_pts_new = e_pts_new[keep];\\n \\n if verbose:\\n timer.printElapsedTime('Deleted %d points' % (delete.sum()));\\n timer.reset();\\n \\n if l < length:\\n skel_flat[e_pts] = False; # remove endpoints for new neighbour detection\\n critical_points.append(e_pts_new);\\n e_pts = e_pts_new;\\n \\n if verbose:\\n timer.printElapsedTime('Cleanup iteration %d / %d done.' % (l, length));\\n \\n #gather all points\\n if len(delete_points) > 0:\\n delete_points = np.hstack(delete_points);\\n delete_points = np.unique(delete_points);\\n else:\\n delete_points = np.zeros(0);\\n \\n if verbose:\\n timer_all.printElapsedTime('Cleanup');\\n \\n if clean:\\n skel_flat = np.reshape(skeleton, -1, order = 'F');\\n skel_flat[delete_points] = False;\\n keep_ids = np.logical_not(np.in1d(points, delete_points, assume_unique = True))\\n points = points[keep_ids];\\n radii = radii[keep_ids];\\n return skeleton, points, radii\\n \\n return delete_points;\",\n \"def splice_polygon(dist_v, dist_w):\\n\\n\\t\\tif dist_w >= chain.length or dist_w == 0:\\n\\n\\t\\t\\tleft_chain, right_chain = cut_linestring(chain, dist_v)\\n\\n\\t\\t\\tp_l = left_chain.coords[:]\\n\\t\\t\\tp_r = right_chain.coords[:]\\t\\t\\n\\n\\t\\t\\treturn p_l, p_r\\n\\n\\t\\tif dist_v >= chain.length or dist_v == 0:\\n\\n\\t\\t\\tleft_chain, right_chain = cut_linestring(chain, dist_w)\\n\\n\\t\\t\\tp_l = right_chain.coords[:]\\n\\t\\t\\tp_r = left_chain.coords[:]\\t\\t\\n\\n\\t\\t\\treturn p_l, p_r\\n\\n\\n\\t\\tif dist_w%chain.length > dist_v%chain.length:\\n\\n\\t\\t\\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\\n\\t\\t\\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\\n\\n\\t\\t\\tcommon = LineString(left_w_chain).difference(LineString(left_v_chain))\\n\\n\\t\\t\\tp_l = left_v_chain.coords[:]+right_w_chain.coords[:-1]\\n\\t\\t\\tp_r = common.coords[:]\\n\\n\\t\\t\\treturn p_l, p_r\\n\\n\\t\\telse:\\n\\n\\t\\t\\tleft_v_chain, right_v_chain = cut_linestring(chain, dist_v)\\n\\t\\t\\tleft_w_chain, right_w_chain = cut_linestring(chain, dist_w)\\n\\n\\t\\t\\tcommon = LineString(left_v_chain).difference(LineString(left_w_chain))\\n\\n\\t\\t\\tp_l = common.coords[:]\\n\\t\\t\\tp_r = left_w_chain.coords[:]+right_v_chain.coords[:-1]\\n\\n\\t\\t\\treturn p_l, p_r\",\n \"def _mps_truncateC(self, C, Dmax, tol):\\n U, S, V = svd(C)\\n tol = max(np.finfo(float).eps, tol)\\n keep = min(sum(S > (S[0] * tol)), Dmax)\\n projR = V[:keep, :]\\n projL = U[:, :keep]\\n discarded = np.sqrt(sum(S[keep:]**2)) / S[0]\\n S = np.diag(S[:keep])\\n return projL, S, projR, keep, discarded\",\n \"def simplify(self):\\n # First remove all simple loops\\n while self._removeTripleLoop():\\n pass\\n\\n # First remove all simple loops\\n while self._removeSimpleLoop():\\n pass\\n\\n # Iteratively remove vacuums until finished\\n while self._remove_vacuumcoupling():\\n pass\\n\\n return self\",\n \"def prune_short_lines(lines, min_length): \\n pruned_lines = [line for line in lines] # converts MultiLineString to list\\n to_prune = []\\n \\n for i, line in enumerate(pruned_lines):\\n if line.length < min_length:\\n to_prune.append(i)\\n for n in neighbors(pruned_lines, line):\\n contact_point = line.intersection(pruned_lines[n])\\n pruned_lines[n] = bend_towards(pruned_lines[n], \\n where=contact_point,\\n to=line.centroid)\\n \\n return [line for i, line in enumerate(pruned_lines) if i not in to_prune]\",\n \"def __create_chain_roads(self, roads: Set[JuncRoadSingleConnection], with_removed=False) \\\\\\n -> Union[List[JuncRoadChainConnection], Tuple[List[JuncRoadChainConnection], int]]:\\n chain_connections: List[JuncRoadChainConnection] = list()\\n handled: Set[JuncRoadSingleConnection] = set()\\n in_roads, out_roads = self.__get_in_out_roads_dicts_by_single(roads)\\n loop_removed = 0\\n # the id of chain, will be the id of the future road\\n curr_chain_id = 0\\n # now run over all roads\\n connected2: Set[JuncIndices] = self.__get_2_connected_juncs(roads, (in_roads, out_roads))\\n while len(handled) != len(roads):\\n # init a chain road connection\\n chain: List[JuncRoadSingleConnection] = list()\\n # get a random road\\n curr_road: JuncRoadSingleConnection = sample(roads.difference(handled), 1)[0]\\n handled.add(curr_road)\\n chain.append(curr_road)\\n \\\"\\\"\\\"\\n now we have to be careful. there are 4 case:\\n 1. both sides of the road are not 2-connected juncs, just add the chain.\\n 2. the target is a 2-connected junc, loop forward until reaching a non 2-connected junc\\n 3. the source is a 2-connected junc, loop backwards until reaching a non 2-connected junc\\n 4. both sides of the road are 2-connected juncs, we should loop both forwars and backwards,\\n but also notice that it is possible that we are in a loop of N juncs that are all 2-connected,\\n in that case we should remove all of them. to check that we should have a set of visited juncs.\\n \\\"\\\"\\\"\\n # case 1\\n if curr_road.source not in connected2 and curr_road.target not in connected2:\\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\\n curr_chain_id += 1\\n # case 2\\n elif curr_road.source not in connected2 and curr_road.target in connected2:\\n while curr_road.target in connected2:\\n curr_road = list(out_roads[curr_road.target])[0] # the length of the set is 1. get its element.\\n handled.add(curr_road)\\n chain.append(curr_road)\\n # reached False, so we should not skip over the next target, we are done.\\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\\n curr_chain_id += 1\\n # remove the 2-connected junctions\\n for road in chain[:-1]:\\n self.remove_junction(self.get_junc(road.target))\\n # case 3\\n elif curr_road.source in connected2 and curr_road.target not in connected2:\\n while curr_road.source in connected2:\\n curr_road = list(in_roads[curr_road.source])[0] # the length of the set is 1. get its element.\\n handled.add(curr_road)\\n chain.insert(0, curr_road)\\n # reached False, so we should not skip over the next target, we are done.\\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\\n curr_chain_id += 1\\n # remove the 2-connected junctions\\n for road in chain[:-1]:\\n self.remove_junction(self.get_junc(road.target))\\n # case 4\\n elif curr_road.source in connected2 and curr_road.target in connected2:\\n \\\"\\\"\\\"\\n save the prev of the current road, to know if there is a loop.\\n we dont save just the current road becuase this creates troubles in the while condition.\\n \\\"\\\"\\\"\\n loop_start_road = list(in_roads[curr_road.source])[0]\\n original_road = curr_road\\n while curr_road.target in connected2 and curr_road != loop_start_road:\\n curr_road = list(out_roads[curr_road.target])[0] # the length of the set is 1. get its element.\\n handled.add(curr_road)\\n chain.append(curr_road)\\n # we finished going forwards, for 1 of 2 reasons:\\n if loop_start_road != curr_road:\\n # regular operations. now go backwards:\\n curr_road = original_road\\n while curr_road.source in connected2:\\n curr_road = list(in_roads[curr_road.source])[0] # the length of the set is 1. get its element.\\n handled.add(curr_road)\\n chain.insert(0, curr_road)\\n # in the end, add the chain\\n chain_connections.append(JuncRoadChainConnection(curr_chain_id, chain))\\n curr_chain_id += 1\\n # remove the 2-connected junctions\\n for road in chain[:-1]:\\n self.remove_junction(self.get_junc(road.target))\\n else:\\n \\\"\\\"\\\"\\n we have a loop. handle the removing of all these junctions.\\n do the following:\\n 1. find all junctions and roads that take part in the loop.\\n 2. remove all of the roads from the roads set,\\n and also from the handled set to keep the while loop stop condition.\\n *. no need to remove them from them from in_roads/out_roads/connceted2 since they are\\n irrelevent to the other roads and junctions.\\n 3. then, just apply the junc removing function on all junctions.\\n \\\"\\\"\\\"\\n # step 1: we already have exactly them in the chain list!\\n # step 2:\\n for road in chain:\\n roads.remove(road)\\n handled.remove(road)\\n # step 3:\\n juncs_indices: List[JuncIndices] = [road.source for road in chain]\\n loop_removed += len(juncs_indices)\\n for junc_indices in juncs_indices:\\n self.remove_junction(self.get_junc(junc_indices))\\n # just error checking\\n else:\\n raise Exception(\\\"error in if chain, in graph.__create_chain_roads\\\")\\n if with_removed:\\n return chain_connections, loop_removed\\n return chain_connections\",\n \"def subsettter(clipsegments, lengthtype):\\n if lengthtype == 'twothirds':\\n clipsegments.remove('AR8')\\n clipsegments.remove('AF13')\\n elif lengthtype == 'abouthalf':\\n clipsegments.remove('AR8')\\n clipsegments.remove('AF13')\\n clipsegments.remove('AF7')\\n return clipsegments\",\n \"def wake_trim(pairs, wake_trim_min, period_length_sec):\\r\\n trim = int((60/period_length_sec) * wake_trim_min)\\r\\n trimmed_pairs = []\\r\\n for true, pred in pairs:\\r\\n inds = np.where(true != 0)[0]\\r\\n start = max(0, inds[0]-trim)\\r\\n end = inds[-1]+trim\\r\\n trimmed_pairs.append([\\r\\n true[start:end], pred[start:end]\\r\\n ])\\r\\n return trimmed_pairs\",\n \"def pruning(self):\\n data = self.data.copy()\\n for d in self.data:\\n # cascade purning method. Inspired from \\\"Efficient Computation of Group Skyline Queries on MapReduce (FCU)\\\"\\n if d in data:\\n pastart = [self.drange[1] if i+self.radius>self.drange[1] else i+self.radius for i in d.getLocationMax()]\\n pamax = [self.drange[1] for j in range(self.dim)]\\n # prune data points that are obviously dominated by current data point\\n pruned = (self.index.intersection(tuple(pastart+pamax),objects=True))\\n for p in pruned:\\n if p.object in data:\\n data.remove(p.object)\\n self.pruned = data\",\n \"def remove_lead(self, lead):\\n self.leads = self.leads[:lead] + self.leads[lead+1:]\\n self.connections = self.connections[:lead] + self.connections[lead+1:]\",\n \"def ltrimboth (l,proportiontocut):\\r\\n lowercut = int(proportiontocut*len(l))\\r\\n uppercut = len(l) - lowercut\\r\\n return l[lowercut:uppercut]\",\n \"def floor_remove(points, set_max_window_size = 20, set_slope = 1.0, set_initial_distance = 0.5, set_max_distance = 3.0):\\n PointCloud = points\\n ind = pclpy.pcl.vectors.Int()\\n pmf = pclpy.pcl.segmentation.ApproximateProgressiveMorphologicalFilter.PointXYZ()\\n pmf.setInputCloud(PointCloud)\\n pmf.setMaxWindowSize(set_max_window_size)\\n pmf.setSlope(set_slope)\\n pmf.setInitialDistance(set_initial_distance)\\n pmf.setMaxDistance(set_max_distance)\\n pmf.extract(ind)\\n ext = pclpy.pcl.filters.ExtractIndices.PointXYZ()\\n ground = pclpy.pcl.PointCloud.PointXYZ()\\n non_ground_points = pclpy.pcl.PointCloud.PointXYZ()\\n ext.setInputCloud(PointCloud)\\n ext.setIndices(ind)\\n ext.filter(ground)\\n ext.setNegative(True)\\n ext.filter(non_ground_points)\\n\\n return non_ground_points.xyz, ground.xyz\",\n \"def hole_cleanup(atom_list): \\n joey = atom_list.copy()\\n while (len(joey) != 0):\\n for atom in joey:\\n takein = [atom]\\n source_update = takein.copy()\\n check = 1\\n while (check == 1):\\n source = source_update.copy()\\n source_update = []\\n c = len(takein)\\n for element in source:\\n bonds = [bond[0] for bond in identify_bonds(element, joey) if bond[0] not in takein]\\n for h in bonds:\\n takein.append(h)\\n source_update.append(h)\\n if ((len(takein) == c) and (len(takein) < 6)):\\n check = 0\\n for element in takein:\\n atom_list.remove(element)\\n elif (len(takein) == c):\\n check = 0\\n for element in takein:\\n joey.remove(element)\\n return atom_list\",\n \"def prolongTrail(trails, first_appearance, t0, t1):\\n v1 = cellCenter(t0)\\n v2 = cellCenter(t1)\\n seg = (v2 - v1) / np.linalg.norm(v2 - v1)\\n first_app = first_appearance[t0]\\n orig_trail = trails[first_app[0]]\\n candidates = []\\n if first_app[1] > 0:\\n candidates.append(orig_trail[first_app[1] - 1])\\n if first_app[1] < len(orig_trail) - 1:\\n candidates.append(orig_trail[first_app[1] + 1])\\n cand_centers = [cellCenter(candidate) for candidate in candidates]\\n cand_segs = [(v1 - v) / np.linalg.norm(v1 - v) for v in cand_centers]\\n cand_dot = [np.dot(cand_seg, seg) for cand_seg in cand_segs]\\n return candidates[np.argmax(cand_dot)]\",\n \"def clifford_set(u):\\n i, x, y, z = u.v\\n result = []\\n result.append(u.clone()) # I\\n result.append(Uop(-x, i, -z, y, u.hierarchy, u.construction + [\\\"X\\\"], gateset=u.gateset)) # iX, but treat it as X due to only phase difference\\n result.append(Uop((i-x)/SQRT2, (x+i)/SQRT2, (y-z)/SQRT2, (z+y)/SQRT2, u.hierarchy, u.construction + [\\\"(I+iX)\\\"], gateset=u.gateset))\\n result.append(Uop((i+x)/SQRT2, (x-i)/SQRT2, (y+z)/SQRT2, (z-y)/SQRT2, u.hierarchy, u.construction + [\\\"(I-iX)\\\"], gateset=u.gateset))\\n result.append(Uop((i-y)/SQRT2, (x+z)/SQRT2, (y+i)/SQRT2, (z-x)/SQRT2, u.hierarchy, u.construction + [\\\"(I+iY)\\\"], gateset=u.gateset))\\n result.append(Uop((i+y)/SQRT2, (x-z)/SQRT2, (y-i)/SQRT2, (z+x)/SQRT2, u.hierarchy, u.construction + [\\\"(I-iY)\\\"], gateset=u.gateset))\\n for idx in range(6):\\n i, x, y, z = result[idx].v\\n c = result[idx].construction[-1:] if idx != 0 else []\\n result.append(Uop(-z, -y, x, i, u.hierarchy, u.construction + c + [\\\"Z\\\"], gateset=u.gateset)) # iZ\\n result.append(Uop((i-z)/SQRT2, (x-y)/SQRT2, (y+x)/SQRT2, (z+i)/SQRT2, u.hierarchy, u.construction + c + [\\\"(I+iZ)\\\"], gateset=u.gateset))\\n result.append(Uop((i+z)/SQRT2, (x+y)/SQRT2, (y-x)/SQRT2, (z-i)/SQRT2, u.hierarchy, u.construction + c + [\\\"(I-iZ)\\\"], gateset=u.gateset))\\n\\n return result\",\n \"def simplify_polyline_epsilon(points, epsilon):\\n raise NotImplementedError(\\\"TODO: test this code\\\")\\n\\n if len(points) < 3:\\n return points\\n\\n begin, end = points[0], points[-1]\\n dist_sq = [segment_point_distance_sq(\\n begin[0], begin[1], end[0], end[1], p[0], p[1])\\n for p in points[1:-1]]\\n\\n maxdist = max(dist_sq)\\n if maxdist < epsilon ** 2:\\n return [begin, end]\\n\\n pos = dist_sq.index(maxdist)\\n return (simplify_polyline_epsilon(points[:pos + 2], epsilon) +\\n simplify_polyline_epsilon(points[pos + 1:], epsilon)[1:])\",\n \"def cut_line(self):\\r\\n self.parachute.pop(0)\",\n \"def clip(self, clip, s_entry, c_entry):\\n\\n # detect clip mode\\n unionmode = not s_entry and not c_entry\\n intersectionmode = s_entry and c_entry\\n differencemode = not s_entry and c_entry\\n\\n # prep by removing repeat of startpoint at end\\n first = self.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n first = clip.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n\\n # TODO: maybe also remove repeat points anywhere?\\n # ...\\n \\n # phase one - find intersections\\n # ------------------------------\\n anyintersection = False\\n s_intsecs = []\\n c_intsecs = []\\n for s in self.iter(): # for each vertex Si of subject polygon do\\n for c in clip.iter(): # for each vertex Cj of clip polygon do\\n try:\\n #print \\\"find isect %s - %s and %s - %s\\\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\\n c, clip.next(c.__next__))\\n \\n iS = Vertex(i, alphaS, intersect=True, entry=False)\\n iC = Vertex(i, alphaC, intersect=True, entry=False)\\n\\n iS.neighbour = iC\\n iC.neighbour = iS\\n \\n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\\n \\n anyintersection = True\\n \\n except TypeError:\\n pass # this simply means intersect() returned None\\n\\n # insert intersections into originals\\n for iS,a,s,s_next in reversed(s_intsecs):\\n if a == 0:\\n self.replace(s, iS)\\n elif a == 1:\\n self.replace(s_next, iS)\\n else:\\n self.insert(iS, s, s_next)\\n for iC,a,c,c_next in reversed(c_intsecs):\\n if a == 0:\\n self.replace(c, iC)\\n elif a == 1:\\n self.replace(c_next, iC)\\n else:\\n clip.insert(iC, c, c_next)\\n\\n #print \\\"testing if insert was done correctly\\\"\\n for s in self.iter():\\n #print s\\n pass\\n #print \\\"and\\\"\\n for c in clip.iter():\\n #print c\\n pass\\n \\n\\n # phase one and a half - no intersections between subject and clip, so correctly return results\\n # --------------------\\n def specialcase_insidetest():\\n resultpolys = []\\n if unionmode: # union\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so just return subject shell\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so just return clip shell\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so return both\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif intersectionmode: # intersection\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so no intersection to return\\n pass\\n elif differencemode: # difference\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n hole = Polygon()\\n for c in clip.iter():\\n hole.add(Vertex(c))\\n polytuple = (clipped, [hole])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so there is no difference\\n pass\\n else:\\n #clip polygon is entirely outside subject, so difference is simply the subject\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n # no need to continue so just return result\\n return resultpolys\\n \\n if not anyintersection: \\n return specialcase_insidetest()\\n\\n\\n\\n\\n\\n\\n\\n # phase two - identify entry/exit points\\n # --------------------------------------\\n\\n # From K&K\\n \\n def mark_flags(poly, c, c_entry):\\n \\\"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\\\"\\n #print \\\"intersection\\\"\\n #print \\\"\\\\t\\\",c\\n # intersection is degenerate, is the start/endpoint of a line\\n # so maybe delete intersection flag based on prev/next locations\\n prevloc = testLocation(c.prev, poly)\\n nextloc = testLocation(c.__next__, poly)\\n if prevloc == \\\"on\\\" or nextloc == \\\"on\\\":\\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\\n prevloc = testLocation(prevmid, poly)\\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\\n nextloc = testLocation(nextmid, poly)\\n if prevloc == \\\"in\\\" or nextloc == \\\"in\\\":\\n poly.anyinside = True\\n #print \\\"\\\\t %s -> degenintsec -> %s\\\" %(prevloc,nextloc)\\n if prevloc == \\\"out\\\":\\n if nextloc == \\\"out\\\":\\n #just touching\\n c.entry = \\\"en/ex\\\" if c_entry else \\\"ex/en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif prevloc == \\\"in\\\":\\n #union and difference should never go inside the other polygon\\n #so this should only happen for intersectmode...\\n if nextloc == \\\"in\\\":\\n #just touching\\n c.entry = \\\"ex/en\\\" if c_entry else \\\"en/ex\\\"\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif prevloc == \\\"on\\\":\\n if nextloc == \\\"on\\\":\\n c.entry = None\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n\\n self.anyinside = False\\n\\n # set clip\\n prevsingle = None\\n for c in clip.iter():\\n if c.intersect:\\n mark_flags(self, c, c_entry)\\n # set couple\\n if c.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and c.entry == prevsingle.entry:\\n c.couple = prevsingle\\n prevsingle.couple = c\\n prevsingle = c\\n # set crosschange\\n # some modifications based on implementation in qt clipper source code\\n #if c.entry == \\\"en/ex\\\" == c.neighbour.entry or c.entry == \\\"ex/en\\\" == c.neighbour.entry:\\n if False: #c.entry == \\\"en/ex\\\" or c.entry == \\\"ex/en\\\":\\n print(\\\"Maybe crosschange...\\\")\\n # tri1\\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\\n dir1 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n # tri2\\n #a,b,c = c.neighbour.prev, c.prev, c.next\\n a,b,c = c.__next__, c.prev, c.neighbour.prev\\n dir2 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n print(dir1,dir2)\\n #if dir1 < 0 != dir2 < 0: # different orientation\\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\\n print(\\\"CROSSCHANGE!!!\\\")\\n c.cross_change = True\\n c.neighbour.cross_change = True # not sure if should set neighbour too\\n\\n # maybe early abort\\n if not self.anyinside and intersectionmode:\\n return []\\n\\n # what about perfect overlap???\\n # ...\\n\\n if False: #DEBUG:\\n print(\\\"view clip entries\\\")\\n for c in clip.iter():\\n print(c, c.entry)\\n\\n # find first isect where both neighbours have valid flag\\n for c in clip.iter():\\n if c.entry:\\n s = c.neighbour\\n mark_flags(clip, s, s_entry)\\n if s.entry:\\n first_c = c\\n first_s = s\\n # print 777,s.entry\\n break\\n\\n else:\\n return specialcase_insidetest()\\n #raise Exception(\\\"weird special case, no neighbours that both have flag left\\\")\\n \\n # autoset subj, if neighbour of first is different, then set all as opposite\\n # TODO: how deal with s_entry in case of different modes...?\\n print(\\\"view first\\\")\\n print(first_c, first_c.entry)\\n print(first_s, first_s.entry)\\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\\n for c in clip.iter():\\n if c.entry:\\n if c.entry == \\\"en\\\": c.neighbour.entry = \\\"ex\\\"\\n elif c.entry == \\\"ex\\\": c.neighbour.entry = \\\"en\\\"\\n elif c.entry == \\\"en/ex\\\": c.neighbour.entry = \\\"ex/en\\\"\\n elif c.entry == \\\"ex/en\\\": c.neighbour.entry = \\\"en/ex\\\"\\n \\n # else set all same\\n else:\\n for c in clip.iter():\\n if c.entry:\\n c.neighbour.entry = c.entry\\n\\n # set couple for subj (not sure if needed)\\n prevsingle = None\\n for s in self.iter():\\n if s.entry:\\n if s.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and s.entry == prevsingle.entry:\\n s.couple = prevsingle\\n prevsingle.couple = s\\n prevsingle = s\\n\\n if False: #DEBUG: \\n print(\\\"view subj entries\\\")\\n for s in self.iter():\\n print(s, s.entry)\\n\\n\\n\\n\\n\\n # phase three - construct a list of clipped polygons\\n # --------------------------------------------------\\n\\n ######\\n # Defs\\n def next_unprocessed(vert):\\n origvert = vert\\n while vert:\\n if vert.entry and not (vert.checked or vert.neighbour.checked):\\n #print \\\"vert, found next unproc\\\", vert, vert.checked, vert.neighbour.checked\\n if vert.couple:\\n # rule 1\\n if vert.couple.entry and vert.entry:\\n # rule 2\\n if vert.couple.entry == \\\"en\\\" and vert.entry == \\\"en\\\":\\n return vert.couple\\n elif vert.couple.entry == \\\"ex\\\" and vert.entry == \\\"ex\\\":\\n return vert\\n # rule 3\\n else:\\n return vert\\n \\n vert = vert.__next__\\n \\n if vert == origvert:\\n # if returned to first, return None\\n return None\\n\\n def DeleteFlag1(cur, stat):\\n if cur.entry == \\\"en/ex\\\":\\n cur.entry = None\\n if cur.cross_change:\\n if stat == \\\"D3\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if stat == \\\"D3\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D3\\\":\\n cur.entry = \\\"en\\\"\\n return \\\"D2\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n return \\\"D1\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n return \\\"D1\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n return \\\"D2\\\"\\n\\n def DeleteFlag2(cur, prev, stat):\\n if cur.entry == \\\"en/ex\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"ex\\\"\\n else:\\n cur.entry = \\\"en\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"en\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n if stat == \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D1\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n if stat != \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D2\\\"\\n else:\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n\\n def proceed(cur, stat):\\n cur.checked = True\\n if stat == \\\"D1\\\":\\n clipped.add(Vertex(cur))\\n return cur.__next__\\n elif stat == \\\"D2\\\":\\n clipped.add(Vertex(cur))\\n return cur.prev\\n else:\\n return cur.neighbour\\n\\n ####\\n resultpolys = []\\n\\n self.first.checked = True\\n cur = prev = start = next_unprocessed(self.first)\\n\\n while cur:\\n # each new polygon\\n print(\\\"new poly\\\")\\n\\n stat = DeleteFlag1(cur, \\\"D3\\\")\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n clipped = Polygon()\\n cur = proceed(cur, stat)\\n\\n # collect vertexes\\n while cur != start:\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n if cur.entry:\\n if stat == \\\"D1\\\" or stat == \\\"D2\\\":\\n stat = DeleteFlag2(cur, prev, stat)\\n else:\\n stat = DeleteFlag1(cur, stat)\\n prev = cur\\n cur = proceed(cur, stat)\\n\\n # return to first vertex\\n clipped.add(Vertex(clipped.first))\\n\\n print(clipped)\\n\\n resultpolys.append((clipped,[]))\\n cur = prev = start = next_unprocessed(self.first)\\n\\n\\n\\n # finally, sort into exteriors and holes\\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\\n for otherext,otherholes in resultpolys:\\n if polyext == otherext:\\n continue # don't compare to self\\n if polyext.first.isInside(otherext):\\n otherholes.append(polyext) #poly is within other so make into a hole\\n del resultpolys[pindex] #and delete poly from being an independent poly\\n return resultpolys\",\n \"def clean(self):\\n\\t\\tfor v in self:\\n\\t\\t\\tv.reset_distance()\\n\\t\\t\\tv.reset_predecessor()\\n\\t\\t\\tv.reset_visited()\",\n \"def trimDups( options, data ):\\n for c in data.chrNames:\\n prevBlock = MafBlock()\\n replacement = []\\n if c not in data.mafBlocksByChrom:\\n data.mafBlocksByChrom[ c ] = replacement\\n continue\\n for m in data.mafBlocksByChrom[ c ]:\\n if m.refStart <= prevBlock.refEnd:\\n if m.refEnd > prevBlock.refEnd:\\n # only add in the new, distinct, bases\\n m.refStart = prevBlock.refEnd + 1\\n else:\\n # this block is totally covered by the previous block\\n continue\\n replacement.append( m )\\n prevBlock = m\\n data.mafBlocksByChrom[ c ] = replacement\",\n \"def _pair_based_graph_cut(self, graph):\\n for node in self._find_paired_nodes(graph):\\n graph.remove_node(node)\\n return\",\n \"def lift(point):\\n return gs.copy(point)\",\n \"def clip(self, clipbox):\\r\\n pmin, pmax = clipbox\\r\\n ind = []\\r\\n vlt = []\\r\\n # Direct elimination of out of bounds edges and vertices\\r\\n for i in range(len(self.vl)):\\r\\n if self.vl[i][0] < pmin[0] or self.vl[i][1] < pmin[1] or \\\\\\r\\n self.vl[i][0] > pmax[0] or self.vl[i][1] > pmax[1]:\\r\\n ind.append(i)\\r\\n else:\\r\\n vlt.append(self.vl[i])\\r\\n elt = filter((lambda x: (x[0] not in ind) and (x[1] not in ind)),\\r\\n self.el)\\r\\n li = filter((lambda x: x not in ind), range(len(self.vl)))\\r\\n # We rename the indices in the trimmed edge list\\r\\n lf = range(len(self.vl) - len(ind))\\r\\n equiv = {}\\r\\n for i in range(len(li)):\\r\\n if li[i] != lf[i]:\\r\\n equiv[li[i]] = lf[i]\\r\\n\\r\\n for i in range(len(elt)):\\r\\n if elt[i][0] in equiv:\\r\\n x = equiv[elt[i][0]]\\r\\n else:\\r\\n x = elt[i][0]\\r\\n if elt[i][1] in equiv:\\r\\n y = equiv[elt[i][1]]\\r\\n else:\\r\\n y = elt[i][1]\\r\\n elt[i] = (x, y)\\r\\n\\r\\n self.vl = vlt\\r\\n self.el = elt\\r\\n self.minmax()\",\n \"def prune(pybel_list, min_RMSD):\\n #Set up OBAling object\\n align = openbabel.OBAlign()\\n #Loop\\n i = 0\\n total_removed = 0\\n while i < len(pybel_list):\\n referens = pybel_list[i].OBMol #reference\\n align.SetRefMol(referens)\\n j = i + 1\\n while j < len(pybel_list):\\n target = pybel_list[j].OBMol #target\\n align.SetTargetMol(target)\\n #Align and ret rmsd\\n if align.Align():\\n rmsd = align.GetRMSD()\\n if rmsd < min_RMSD:\\n pybel_list.pop(j) #remove from both lists\\n total_removed += 1\\n else:\\n j = j + 1\\n else:\\n print \\\"Couldn't align\\\"\\n raise Exception()\\n #end of inner loop\\n i = i + 1\\n #end of outer loop\\n print \\\"finished deleting, total number of \\\\\\n removed conformers is\\\", total_removed\\n return pybel_list\",\n \"def msep_from_given(self, A, C=set()):\\n\\n A = core_utils.to_set(A)\\n C = core_utils.to_set(C)\\n\\n determined = set()\\n descendants = set()\\n\\n for c in C:\\n determined.add(c)\\n descendants.add(c)\\n self._add_upstream(descendants, c)\\n\\n reachable = set()\\n i_links = set()\\n labeled_links = set()\\n\\n for a in A:\\n i_links.add((None, a))\\n reachable.add(a)\\n\\n while True:\\n i_p_1_links = set()\\n # Find all unlabled links v->w adjacent to at least one link u->v labeled i, such that (u->v,v->w) is a legal pair.\\n for link in i_links:\\n u, v = link\\n for w in self._adjacent[v]:\\n if not u == w and (v, w) not in labeled_links:\\n if self._is_collider(u, v, w): # Is collider?\\n if v in descendants:\\n i_p_1_links.add((v, w))\\n reachable.add(w)\\n else: # Not collider\\n if v not in determined:\\n i_p_1_links.add((v, w))\\n reachable.add(w)\\n\\n if len(i_p_1_links) == 0:\\n break\\n\\n labeled_links = labeled_links.union(i_links)\\n i_links = i_p_1_links\\n\\n return self._nodes.difference(A).difference(C).difference(reachable)\",\n \"def trim_dag(G):\\n SINKS = G.graph['SINKS']\\n SOURCES = G.graph['SOURCES']\\n\\n for node in G.nodes():\\n node_attr = G.node[node]\\n children = G.successors(node)\\n\\n if check_key(node_attr, 'is_const', True):\\n if len(children) == 0:\\n print \\\"!!!!! \\\", node\\n\\n SOURCES.remove(node)\\n if node in SINKS:\\n SINKS.remove(node)\\n for c in children:\\n if 'immediates' in G.node[c].keys():\\n G.node[c]['immediates'].append(node_attr['value'])\\n\\n if check_key(node_attr, 'op', \\\"mv\\\") or check_key(node_attr, 'is_const', True) :\\n parents = G.predecessors(node)\\n \\n for p in parents:\\n for c in children:\\n G.add_edge(p, c)\\n #print G.predecessors(node), \\\" -> \\\", node, \\\" -> \\\", G.successors(node)\\n G.remove_node(node)\\n\\n return\",\n \"def trim_features():\\n pass\",\n \"def compact(self, distance=2):\\n pass\",\n \"def trim_netlist(nets, components, selected_component, verbose=None):\\n\\n selected = selected_component\\n #>17 <2\\n # nets[0].pins[0].component.idx\\n trimmed_net = []\\n net_idx = [[each.pins[0].component.idx, each.pins[1].component.idx] for each in nets]\\n len_net_idx = len(net_idx)\\n count = 0\\n trimmed_nets, trimmed_components = [], []\\n while count < (len_net_idx - 1):\\n for i in range(count + 1, len_net_idx): # i keep track of nets from next net to last net\\n # first set is formed of elements from current to backwards\\n first_set = set(net_idx[count])\\n # second set is formed of elements from current + 1 to forward\\n second_set = set(net_idx[i])\\n if len(first_set.intersection(second_set)) > 0: # if there are common elements between two sets\\n net_idx.pop(i) # remove the nets from the list\\n net_idx.pop(count) # remove the count net as well\\n # merged them and add to the list\\n net_idx.append(list(first_set.union(second_set)))\\n len_net_idx -= 1 # 2 removed 1 added so reduce 1\\n count -= 1 # readjust count as the elements have shifted to left\\n break\\n count += 1\\n for net in net_idx:\\n if(selected.idx in net):\\n trimmed_components = [each for each in components if each.idx in net]\\n trimmed_nets = [each for each in nets if (\\n each.pins[0].component.idx in net or each.pins[1].component.idx in net)]\\n if verbose:\\n print(\\\"success - netlist trimmed\\\")\\n\\n return trimmed_nets, trimmed_components\",\n \"def trim(network, pores=[], throats=[]):\\n pores = network._parse_indices(pores)\\n throats = network._parse_indices(throats)\\n Pkeep = np.copy(network['pore.all'])\\n Tkeep = np.copy(network['throat.all'])\\n if np.size(pores) > 0:\\n Pkeep[pores] = False\\n if not np.any(Pkeep):\\n raise Exception('Cannot delete ALL pores')\\n # # Performing customized find_neighbor_throats which is much faster, but\\n # # not general for other types of queries\\n # temp = np.in1d(network['throat.conns'].flatten(), pores)\\n # temp = np.reshape(temp, (network.Nt, 2))\\n # Ts = np.any(temp, axis=1)\\n # Ts = network.Ts[Ts]\\n Ts = network.find_neighbor_throats(pores=~Pkeep, mode='union')\\n if len(Ts) > 0:\\n Tkeep[Ts] = False\\n if np.size(throats) > 0:\\n Tkeep[throats] = False\\n # The following IF catches the special case of deleting ALL throats\\n # It removes all throat props, adds 'all', and skips rest of function\\n if not np.any(Tkeep):\\n logger.info('Removing ALL throats from network')\\n for item in list(network.keys()):\\n if item.split('.')[0] == 'throat':\\n del network[item]\\n network['throat.all'] = np.array([], ndmin=1)\\n return\\n\\n # Temporarily store throat conns and pore map for processing later\\n Np_old = network.Np\\n Nt_old = network.Nt\\n Pkeep_inds = np.where(Pkeep)[0]\\n Tkeep_inds = np.where(Tkeep)[0]\\n Pmap = np.ones((network.Np,), dtype=int)*-1\\n tpore1 = network['throat.conns'][:, 0]\\n tpore2 = network['throat.conns'][:, 1]\\n\\n # Delete specified pores and throats from all objects\\n for obj in network.project[::-1]:\\n if (obj.Np == Np_old) and (obj.Nt == Nt_old):\\n Ps = Pkeep_inds\\n Ts = Tkeep_inds\\n else: # If subdomain object then Np/Nt < Np/Nt_old\\n Ps = obj.to_local(pores=Pkeep_inds, missing_vals=None)\\n Ts = obj.to_local(throats=Tkeep_inds, missing_vals=None)\\n for key in list(obj.keys()):\\n temp = obj.pop(key)\\n if key.split('.')[0] == 'throat':\\n obj.update({key: temp[Ts]})\\n if key.split('.')[0] == 'pore':\\n obj.update({key: temp[Ps]})\\n\\n # Remap throat connections\\n Pmap[Pkeep] = np.arange(0, np.sum(Pkeep))\\n Tnew1 = Pmap[tpore1[Tkeep]]\\n Tnew2 = Pmap[tpore2[Tkeep]]\\n network.update({'throat.conns': np.vstack((Tnew1, Tnew2)).T})\\n\\n # Clear adjacency and incidence matrices which will be out of date now\\n network._am.clear()\\n network._im.clear()\",\n \"def remove_subdivison(self):\\n temp_sub_vertices = []\\n for index in range(0, len(self.subdivision_list) - 1, 4):\\n v0 = Vec3d(0, 0, 0, 0)\\n v1 = Vec3d(0, 0, 0, 0)\\n v2 = Vec3d(0, 0, 0, 0)\\n\\n v0.x = self.subdivision_list[index + 1][0].x\\n v0.y = self.subdivision_list[index + 1][0].y\\n v0.z = self.subdivision_list[index + 1][0].z\\n v0.w = self.subdivision_list[index + 1][0].w\\n\\n v1.x = self.subdivision_list[index + 2][0].x\\n v1.y = self.subdivision_list[index + 2][0].y\\n v1.z = self.subdivision_list[index + 2][0].z\\n v1.w = self.subdivision_list[index + 2][0].w\\n\\n v2.x = self.subdivision_list[index + 3][0].x\\n v2.y = self.subdivision_list[index + 3][0].y\\n v2.z = self.subdivision_list[index + 3][0].z\\n v2.w = self.subdivision_list[index + 3][0].w\\n\\n temp_sub_vertices.append([v0, v1, v2])\\n\\n self.subdivision_list = temp_sub_vertices\",\n \"def triple_cut(deck_of_cards):\\n new_deck =[]\\n big_joker_value = get_big_joker_value(deck_of_cards)\\n small_joker_value = get_small_joker_value(deck_of_cards)\\n\\t \\n index1 = deck_of_cards.index(small_joker_value)\\n index2 = deck_of_cards.index(big_joker_value)\\n index_top_card = min(index1, index2)\\n index_bottom_card = max(index1, index2)\\n # This function will give us the joker that is on the top and the joker \\n # that is in the bottom of the deck regardless of their value\\n \\n new_top = deck_of_cards[(index_bottom_card + 1):]\\n # Creates a deck that is to be moved the top, from the lower joker and\\n # below \\n middle = deck_of_cards[index_top_card : index_bottom_card + 1]\\n # Middle portion of the deck that is not moved that is in between the jokers\\n new_bottom = deck_of_cards[:index_top_card]\\n # The deck portion that is to be moved to the bottom, from higher joker and\\n # above.\\n deck = new_top + middle + new_bottom\\n deck_of_cards[:] = deck\\n # This will then give a new deck that shifts the cards above the higher \\n # joker to the end and the cards below the lower joker to the top.\",\n \"def triple_cut(deck: List[int]) -> None:\\n\\n small_joker_index = deck.index(get_small_joker_value(deck))\\n big_joker_index = deck.index(max(deck))\\n\\n if big_joker_index > small_joker_index:\\n left_joker = small_joker_index\\n right_joker = big_joker_index\\n\\n else:\\n right_joker = small_joker_index\\n left_joker = big_joker_index\\n\\n left_list = deck[:left_joker]\\n right_list = deck[right_joker + 1:]\\n middle_list = deck[left_joker:right_joker + 1]\\n del deck[:]\\n deck.extend(right_list)\\n deck.extend(middle_list)\\n deck.extend(left_list)\",\n \"def _trim_similar_hypotheses(self, hts, ongoing_play):\\n trimmed_hs_data = []\\n kept_hs = []\\n remaining_hts = collections.deque(hts)\\n while remaining_hts:\\n ht = remaining_hts.popleft()\\n n_remaining_hts = collections.deque()\\n kept_hs.append(ht)\\n while remaining_hts:\\n n_ht = remaining_hts.popleft()\\n s = self.sim_f(ht, n_ht, ongoing_play)\\n if s > (1 - self.similarity_epsilon):\\n trimmed_hs_data.append((n_ht, ht))\\n else:\\n n_remaining_hts.append(n_ht)\\n\\n remaining_hts = n_remaining_hts\\n\\n return (kept_hs, trimmed_hs_data)\",\n \"def strip_profiles_copy(profiles):\\n return strip_profiles(lambda x: x['operation'] == 'copy', profiles)\",\n \"def crop_data(vol):\\n\\n thres = 250\\n\\n num_x = vol.shape[0]\\n num_y = vol.shape[1]\\n num_z = vol.shape[2]\\n\\n \\n # set up starting positions\\n starts = []\\n\\n # front and back\\n for i in range(num_x):\\n for j in range(num_z):\\n starts.append( (i, 0, j) )\\n starts.append( (i, num_y-1, j) )\\n\\n # left and right\\n for i in range(num_y):\\n for j in range(num_z):\\n starts.append( (0, i, j) )\\n starts.append( (num_x-1, i, j) )\\n\\n # DFS\\n seenpositions = set()\\n currentpositions = set(starts)\\n\\n while currentpositions:\\n nextpositions = set()\\n for p in currentpositions:\\n seenpositions.add(p)\\n succ = possiblesuccessors(vol, p, thres)\\n for np in succ:\\n if np in seenpositions: continue\\n nextpositions.add(np)\\n\\n currentpositions = nextpositions\\n\\n print \\\"cropping %i (%i addional) voxels\\\" % (len(seenpositions), len(seenpositions) - len(starts))\\n\\n # crop visited voxels\\n for pos in seenpositions:\\n vol[pos[0], pos[1], pos[2]] = 0.0\\n\\n return vol\",\n \"def remove_jumps(self) -> None:\\n q_diff = np.diff(self.array, axis=0)\\n jumps = np.nonzero(np.where(np.linalg.norm(q_diff, axis=1)>1, 1, 0))[0]+1\\n if len(jumps) % 2:\\n jumps = np.append(jumps, [len(q_diff)+1])\\n jump_pairs = jumps.reshape((len(jumps)//2, 2))\\n for j in jump_pairs:\\n self.array[j[0]:j[1]] *= -1.0\",\n \"def clip_trips_to_window(trips):\\n\\tto_remove = []\\n\\tfor i, trip in enumerate(trips):\\n\\t\\tif ( # checking for GOOD trips \\n\\t\\t\\t# departs inside window\\n\\t\\t\\tconfig.window_start_time <= trip.depart.time() <= config.window_end_time \\n\\t\\t\\t# and departs within date range\\n\\t\\t\\tand trip.depart.date() >= config.window_start_date\\n\\t\\t\\tand trip.depart.date() <= config.window_end_date \\n\\t\\t): \\n\\t\\t\\tpass\\n\\t\\telse:\\n\\t\\t\\tto_remove.append(i)\\n\\tfor i in reversed(to_remove):\\n\\t\\tdel trips[i]\",\n \"def cleaned_list():\\n ws_oc = catalog.srcs.copy() # write-safe read copy for\\n # the GLEAM object catalog\\n cat = catalog.srcs.copy()\\n # we loop in reverse, to avoid concurrent mod. exceptions\\n for i in range(len(ws_oc) - 1, 0, -1):\\n # classic. The easiest way to check if a value is NaN:\\n # it won't equal itself\\n if ws_oc[i].alpha != ws_oc[i].alpha:\\n cat = np.delete(cat, i)\\n return cat\",\n \"def remove_4s_every_other_in_between(seq):\\n seq_copy = seq [4:-4:2]\\n return seq_copy\",\n \"def reduce_to_planar_3_coloring(G):\\n\\n if G.is_planar():\\n return G\\n\\n H = FalsePlanarGraph.from_graph(G)\\n\\n for e in H.false_edges:\\n u, v = e\\n\\n # set a combinatorial embedding in H\\n H.is_planar()\\n\\n # find the minimum crossing path from u to v\\n path = min_crossing_path(H, u, v)\\n\\n # apply the planar gadget to every crossing\\n uncross_edges(H, e, path)\\n\\n return H.planar_copy()\",\n \"def remove_disconnected_vertices(self):\\n if self.empty():\\n return Skeleton(\\n segid=self.id, \\n space=self.space, \\n extra_attributes=self.extra_attributes,\\n transform=self.transform,\\n )\\n\\n all_edges = fastremap.unique(self.edges.flat)\\n\\n if len(self.vertices) == all_edges.size:\\n return self.clone()\\n\\n idx_map = {}\\n for i, vert in enumerate(self.vertices):\\n idx_map[tuple(vert)] = i\\n\\n connected_verts = np.unique(self.vertices[ self.edges.flat ], axis=0)\\n\\n edge_map = np.zeros( (len(self.vertices),), dtype=self.edges.dtype)\\n vertex_remap = np.zeros( (len(self.vertices),), dtype=np.int32) - 1\\n for i, vert in enumerate(connected_verts):\\n reverse_idx = idx_map[tuple(vert)]\\n edge_map[reverse_idx] = i\\n vertex_remap[i] = reverse_idx\\n\\n edges = np.sort(edge_map[self.edges], axis=1)\\n vertex_remap = vertex_remap[ vertex_remap > -1 ]\\n\\n skel = Skeleton(\\n connected_verts, edges, \\n segid=self.id, \\n space=self.space,\\n extra_attributes=self.extra_attributes,\\n transform=self.transform,\\n )\\n\\n if len(self.extra_attributes) == 0:\\n return skel\\n\\n for attr in self.extra_attributes:\\n name = attr['id']\\n self_buf = getattr(self, name)\\n skel_buf = self_buf[vertex_remap]\\n setattr(skel, name, skel_buf)\\n \\n return skel\",\n \"def _filter_nonmonotone_data_points(xs, ys):\\n diffs = np.diff(xs)\\n xs_new = [xs[0]]\\n ys_new = [ys[0]]\\n middle = int(len(xs)/2)\\n sgn = 1 if xs[0] < xs[-1] else -1\\n for i, dx in enumerate(diffs):\\n if sgn*dx > 0.0:\\n xs_new.append(xs[i+1])\\n ys_new.append(ys[i+1])\\n elif i > middle:\\n xs_new[-1] = xs[i+1]\\n ys_new[-1] = ys[i+1]\\n return xs_new, ys_new\",\n \"def declutter(vector):\\n for key in vector:\\n clutter_values = [value for value in vector[key] if vector[key][value]<2] # gather everything with a value less than two and save it in a list\\n for feature in clutter_values: # remove everything in the clutter values from a dictionary\\n vector[key].pop(feature,None)\\n return vector\",\n \"def clip_polygon(subject, clipper, operation = 'difference'):\\n Subject = Polygon()\\n Clipper = Polygon()\\n\\n for s in subject:\\n Subject.add(Vertex(s))\\n\\n for c in clipper:\\n Clipper.add(Vertex(c))\\n\\n clipped = Clipper.difference(Subject)\\\\\\n if operation == 'reversed-diff'\\\\\\n else Subject.__getattribute__(operation)(Clipper)\\n\\n clipped = [(ext.points,[hole.points for hole in holes]) for ext,holes in clipped]\\n return clipped\",\n \"def main(self, data, quant_factor=None):\\n\\n if not data[\\\"linestrings\\\"]:\\n data[\\\"junctions\\\"] = self.junctions\\n return data\\n\\n # quantize linestrings before comparing\\n # if set to None or a value < 1 (True equals 1) no quantizing is applied.\\n if quant_factor is not None:\\n if quant_factor > 1:\\n kx, ky, x0, y0 = self.prequantize(data[\\\"linestrings\\\"], quant_factor)\\n data[\\\"transform\\\"] = {\\\"scale\\\": [kx, ky], \\\"translate\\\": [x0, y0]}\\n\\n # create list with unique combinations of lines using a rdtree\\n line_combs = select_unique_combs(data[\\\"linestrings\\\"])\\n\\n # iterate over index combinations\\n for i1, i2 in line_combs:\\n g1 = data[\\\"linestrings\\\"][i1]\\n g2 = data[\\\"linestrings\\\"][i2]\\n\\n # check if geometry are equal\\n # being equal meaning the geometry object coincide with each other.\\n # a rotated polygon or reversed linestring are both considered equal.\\n if not g1.equals(g2):\\n # geoms are unique, let's find junctions\\n self.shared_segs(g1, g2)\\n\\n # self.segments are nested lists of LineStrings, get coordinates of each nest\\n s_coords = []\\n for segment in self.segments:\\n s_coords.extend(\\n [\\n [\\n (x.xy[0][y], x.xy[1][y])\\n for x in segment\\n for y in range(len(x.xy[0]))\\n ]\\n ]\\n )\\n # s_coords.extend([[y for x in segment for y in list(x.coords)]])\\n\\n # only keep junctions that appear only once in each segment (nested list)\\n # coordinates that appear multiple times are not junctions\\n for coords in s_coords:\\n self.junctions.extend(\\n [geometry.Point(i) for i in coords if coords.count(i) is 1]\\n )\\n\\n # junctions can appear multiple times in multiple segments, remove duplicates\\n self.junctions = [\\n loads(xy) for xy in list(set([x.wkb for x in self.junctions]))\\n ]\\n\\n # prepare to return object\\n data[\\\"junctions\\\"] = self.junctions\\n\\n return data\",\n \"def trim_occluded_throats(self):\\n occluded_ts = list(self.throats()[self[\\\"throat.area\\\"]==0])\\n #occluded_throats = np.asarray(occluded_throats)\\n if len(occluded_ts) > 0:\\n self.trim(throats=occluded_ts)\\n \\\"Also get rid of isolated pores\\\"\\n isolated_ps = self.check_network_health()['isolated_pores']\\n if len(isolated_ps) > 0:\\n self.trim(isolated_ps)\",\n \"def trim(self):\\n while np.any(self.vertex_valance <= 1):\\n edge_to_keep = np.all(self.vertex_valance[self.edges] > 1,\\n axis=1).tolist();\\n self.raw_wires.filter_edges(edge_to_keep);\\n vertex_to_keep = [len(self.get_vertex_neighbors(i)) > 0 for i in\\n range(self.num_vertices)];\\n self.raw_wires.filter_vertices(vertex_to_keep);\\n\\n self.__initialize_wires();\\n if len(self.vertices) == 0:\\n raise RuntimeError(\\\"Zero vertices left after trimming.\\\");\",\n \"def trim(self):\\n for i in range(len(self)):\\n if self[i] != TRIT_ZERO:\\n return self.__class__(self[i:])\\n return self.__class__([])\",\n \"def crossing_minimization(self):\\n self.layer_sweep()\",\n \"def get_corner_node_prune(lcurve):\\r\\n rho, eta = np.zeros(len(lcurve)), np.zeros(len(lcurve))\\r\\n for lia in range(len(lcurve)):\\r\\n rho[lia] = lcurve[lia][0]\\r\\n eta[lia] = lcurve[lia][1]\\r\\n\\r\\n if len(rho) != len(eta):\\r\\n raise ValueError(\\\"both arrays must have the same size\\\")\\r\\n fin = np.isfinite(rho + eta)\\r\\n nzr = np.array([False]*len(rho))\\r\\n nzr[np.nonzero(rho*eta)[0]] = True\\r\\n keep = fin & nzr\\r\\n if len(keep) < 1:\\r\\n raise ValueError(\\\"To few accepted data found\\\")\\r\\n if len(keep) < len(rho):\\r\\n print(\\\"I had to trim the data due to NaN/Inf or zero values\\\")\\r\\n rho = rho[keep]\\r\\n eta = eta[keep]\\r\\n if np.any(rho[:-1] < rho[1:]) or np.any(eta[:-1] > eta[1:]):\\r\\n print(\\\"Warning: L-curve lacks monotonicity\\\")\\r\\n nP = len(rho) # number of points\\r\\n P = np.log10(np.array([rho, eta])).T # Coordinates of the loglog L-curve\\r\\n V = P[1:, :] - P[:-1, :] # The vectors defined by these coord\\r\\n v = np.sqrt(np.sum(V**2, axis=1)) # length of the vectors\\r\\n # W = V/np.tile(v, (1, 2)); # Normalized vectors.\\r\\n W = np.zeros(V.shape)\\r\\n W[:, 0] = V[:, 0]/v\\r\\n W[:, 1] = V[:, 1]/v\\r\\n clist = [] # list of condidates\\r\\n p = np.min([5, nP]) # number of vectors in pruned L-curve\\r\\n # convex = 0 # Are the pruned L-curves convex\\r\\n Ind = np.argsort(v)[::-1] # Sort lengths decending\\r\\n while p < (nP-1)*2:\\r\\n elmts = np.sort(Ind[:np.min([p, nP-1])])\\r\\n candidate = Angles(W[elmts, :], elmts)\\r\\n # print(\\\"candidate p={}, {}\\\".format(p, candidate))\\r\\n if candidate not in clist:\\r\\n clist.append(candidate)\\r\\n candidate = Global_Behaviour(P, W[elmts, :], elmts)\\r\\n if candidate not in clist:\\r\\n clist.append(candidate)\\r\\n p = p*2\\r\\n # print(clist)\\r\\n if 0 not in clist:\\r\\n clist.insert(0, 0)\\r\\n clist = np.sort(clist)\\r\\n\\r\\n vz = np.argwhere(np.diff(P[clist, 1]) >= np.abs(np.diff(P[clist, 0])))\\r\\n if len(vz) > 1:\\r\\n if vz[0] == 0:\\r\\n vz = vz[1:]\\r\\n elif len(vz) == 1:\\r\\n if vz[0] == 0:\\r\\n vz = []\\r\\n if vz == [] or len(vz) == 0:\\r\\n # if vz.size <= 0:\\r\\n index = clist[-1]\\r\\n else:\\r\\n vects = np.array([P[clist[1:], 0] - P[clist[:-1], 0], P[clist[1:], 1] - P[clist[:-1], 1]]).T\\r\\n vects = np.dot(np.diag(1/np.sqrt(np.sum(vects**2, 1))), vects)\\r\\n delta = vects[:-1, 0] * vects[1:, 1] - vects[1:, 0] * vects[:-1, 1]\\r\\n vv = np.argwhere(delta[vz-1] <= 0)\\r\\n # print(vv)\\r\\n # print(vz)\\r\\n if vv == [] or len(vv) == 0:\\r\\n # if vv.size <= 0:\\r\\n index = clist[vz[-1]]\\r\\n else:\\r\\n index = clist[vz[vv[0]]]\\r\\n\\r\\n try:\\r\\n retval = int(index)\\r\\n except TypeError:\\r\\n print(\\\"index!!!!: {}\\\".format(index))\\r\\n retval = int(index[0])\\r\\n return retval\",\n \"def all_notes_line_up(a_list, b_list):\\n a_list = [x for x in a_list if not x.is_rest] # copy NoteList to list\\n b_list = [x for x in b_list if not x.is_rest] # copy NoteList to list\\n\\n # remove matched notes\\n for a_note in a_list[:]:\\n for b_note in b_list[:]:\\n if (a_note.start, a_note.end) == (b_note.start, b_note.end):\\n # remove the matched pair from their respective lists\\n a_list.remove(a_note)\\n b_list.remove(b_note)\\n break\\n\\n return a_list, b_list\",\n \"def _repartition(self, v, radius, contribute=False):\\n # =============== PRE-ALLOCATION ===============\\n # Compute on non-masked sources :\\n xyz = self.xyz[~self.data.mask]\\n # Get sign of the x coordinate :\\n xsign = np.sign(xyz[:, 0]).reshape(1, -1)\\n # Corticale repartition :\\n repartition = np.ma.zeros((v.shape[0], v.shape[1]), dtype=np.int)\\n\\n # For each triangle :\\n for k in range(3):\\n # =============== EUCLIDIAN DISTANCE ===============\\n eucl = cdist(v[:, k, :], xyz).astype(np.float32)\\n mask = eucl <= radius\\n # Contribute :\\n if not contribute:\\n # Get vertices signn :\\n vsign = np.sign(v[:, k, 0]).reshape(-1, 1)\\n # Find where vsign and xsign are equals :\\n isign = np.logical_and(vsign != xsign, xsign != 0)\\n mask[isign] = False\\n\\n # =============== REPARTITION ===============\\n # Sum over sources dimension :\\n sm = np.sum(mask, 1, dtype=np.int)\\n smmask = np.invert(sm.astype(bool))\\n repartition[:, k] = np.ma.masked_array(sm, mask=smmask)\\n\\n return repartition\",\n \"def cross_route(current: Solution, rnd_state: Generator) -> Solution:\\n problem = Problem()\\n destroyed = deepcopy(current)\\n\\n customers = set(range(problem.num_customers))\\n removed = SetList()\\n\\n while len(removed) < customers_to_remove():\\n candidate = rnd_state.choice(tuple(customers))\\n\\n route_candidate = destroyed.find_route(candidate)\\n _remove(destroyed, candidate, removed, customers)\\n\\n # Find the nearest customer that is not yet removed and in a different\\n # route, and remove it and its neighbours as well.\\n for other in problem.nearest_customers[candidate]:\\n if other not in route_candidate and other not in removed:\\n _remove(destroyed, other, removed, customers)\\n break\\n\\n destroyed.unassigned = removed.to_list()\\n\\n return destroyed\",\n \"def simplify(self):\\n state_copy = copy.deepcopy(self)\\n state_copy.space.spacecrafts = [state_copy.spacecraft] + state_copy.space.close_spacecrafts_to(\\n state_copy.spacecraft, self.PERCEPTION_DISTANCE)\\n\\n return state_copy\",\n \"def clean_junctions(seqlst, proteins, escores, models, mutate_cutoff=0.38,\\n mutate_gap=0, primer=\\\"GTCTTGATTCGCTTGACGCTGCTG\\\",\\n max_mutate_count=2):\\n # loop through each sequence in seqlst\\n for i in range(len(seqlst)):\\n seq = seqlst[i]\\n # if there is not sequence, don't do anything\\n if seq == \\\"\\\":\\n continue\\n es_preds = {}\\n model_preds = {}\\n es_preds_primer = {}\\n model_preds_primer = {}\\n es_preds_primer = {}\\n model_preds_primer = {}\\n d = {\\\"sequence\\\": [seq]}\\n df = pd.DataFrame.from_dict(d)\\n d_primer = {\\\"sequence\\\": [seq + primer]}\\n df_primer = pd.DataFrame.from_dict(d_primer)\\n # check for forward orientation\\n for protein in proteins:\\n # predict sequence without primer\\n es_preds[protein] = escores[protein].predict_sequences(df)[\\\"sequence1\\\"]\\n model_preds[protein] = models[protein].predict_sequences(df)[\\\"sequence1\\\"]\\n # predict sequence with primer\\n es_preds_primer[protein] = escores[protein].predict_sequences(df_primer)[\\\"sequence1\\\"]\\n model_preds_primer[protein] = models[protein].predict_sequences(df_primer)[\\\"sequence1\\\"]\\n seq_bs = Sequence(es_preds, model_preds, proteins, escores, mutate_cutoff, mutate_gap)\\n seq_primer_bs = Sequence(es_preds_primer, model_preds_primer, proteins,\\n escores, mutate_cutoff, mutate_gap)\\n # theres a sequence with less bsites with primer. why?\\n if seq_bs.site_count_all() > seq_primer_bs.site_count_all():\\n print(\\\"Number of bsites with primer should not be less than without\\\")\\n seqlst[i] = \\\"\\\"\\n if seq_bs.site_count_all() < seq_primer_bs.site_count_all():\\n new_seq = clean_junction_seq(ori_seq=seq,\\n proteins=proteins,\\n mutate_cutoff=mutate_cutoff,\\n escores=escores,\\n max_mutate_count=2)\\n if new_seq == seq:\\n seqlst[i] = \\\"\\\"\\n\\n # check reverse complement\\n for i in range(len(seqlst)):\\n # get the sequence\\n seq = seqlst[i]\\n # get the reverse complement of the primer\\n primer_obj = Seq(primer)\\n rev_primer = str(primer_obj.reverse_complement())\\n # if there is not sequence, don't do anything\\n if seq == \\\"\\\":\\n continue\\n\\n es_preds = {}\\n model_preds = {}\\n es_preds_primer = {}\\n model_preds_primer = {}\\n\\n d = {\\\"sequence\\\": [seq]}\\n df = pd.DataFrame.from_dict(d)\\n d_primer = {\\\"sequence\\\": [rev_primer + seq]}\\n df_primer = pd.DataFrame.from_dict(d_primer)\\n\\n # check for reverse complement\\n for protein in proteins:\\n # predict sequence without primer\\n es_preds[protein] = escores[protein].predict_sequences(df)[\\\"sequence1\\\"]\\n model_preds[protein] = models[protein].predict_sequences(df)[\\\"sequence1\\\"]\\n # predict reverse complement of sequence with primer\\n es_preds_primer[protein] = escores[protein].predict_sequences(df_primer)[\\\"sequence1\\\"]\\n model_preds_primer[protein] = models[protein].predict_sequences(df_primer)[\\\"sequence1\\\"]\\n seq_bs = Sequence(es_preds, model_preds, proteins, escores, mutate_cutoff, mutate_gap)\\n seq_primer_bs = Sequence(es_preds_primer, model_preds_primer, proteins,\\n escores, mutate_cutoff, mutate_gap)\\n if seq_bs.site_count_all() > seq_primer_bs.site_count_all():\\n print(\\\"Number of bsites with primer should not be less than without\\\")\\n seqlst[i] = \\\"\\\"\\n if seq_bs.site_count_all() < seq_primer_bs.site_count_all():\\n new_seq = clean_junction_rev_seq(ori_seq=seq,\\n proteins=proteins,\\n mutate_cutoff=mutate_cutoff,\\n escores=escores,\\n max_mutate_count=2)\\n if new_seq == seq:\\n seqlst[i] = \\\"\\\"\\n\\n else:\\n seqlst[i] = seqlst[i] + primer\\n\\n # if wild type is empty, return false\\n if seqlst[0] == \\\"\\\":\\n return [], False\\n\\n # otherwise, return the new seqlist\\n return seqlst, True\",\n \"def unchanging(sv):\\r\\n for nod in sv.Object.values():\\r\\n clauselist=[] # initialize new clause list \\r\\n for cond, vlu in nod.clauses:\\r\\n if cond[0]==Change: # look for change condition\\r\\n if is_fixed(cond[1][0]): continue # ignore clause \\r\\n if cond[1][0]==nod.name: continue # ignore clause \\r\\n clauselist+=[(cond, vlu)] # accept clause\\r\\n nod.clauses=clauselist\",\n \"def trim2(self, starttime=None, endtime=None, reftime=None, check_npts=True, **kwargs):\\n # same as in rf package + mid possibility\\n for tr in self.traces:\\n st = tr.stats\\n ref = (st.starttime + 0.5 * (st.endtime - st.starttime)\\n if reftime in ('mid', 'middle') else reftime)\\n t1 = _seconds2utc(tr, starttime, reftime=ref)\\n t2 = _seconds2utc(tr, endtime, reftime=ref)\\n tr.trim(t1, t2, **kwargs)\\n if check_npts:\\n npts = int(round(np.median([len(tr) for tr in self.traces])))\\n self.traces = [tr for tr in self.traces if len(tr) >= npts]\\n for tr in self.traces:\\n tr.data = tr.data[:npts]\\n return self\",\n \"def smart_concat(strokes):\\n\\n # compute the average of spaces between connected points\\n total_length = 0\\n for stroke in strokes:\\n length, _ = stroke.euclidian_length()\\n total_length += length\\n space = total_length / float(len(strokes) * 7 + 0.00001)\\n\\n i = 0\\n while len(strokes[i + 1:]) > 0:\\n test = False\\n stroke = strokes[i]\\n indice = i\\n for stroke_i in strokes[i + 1:]:\\n\\n indice += 1\\n x11 = stroke.get_x()[-1]\\n x21 = stroke_i.get_x()[0]\\n y11 = stroke.get_y()[-1]\\n y21 = stroke_i.get_y()[0]\\n\\n x12 = stroke.get_x()[-2]\\n x22 = stroke_i.get_x()[1]\\n y12 = stroke.get_y()[-2]\\n y22 = stroke_i.get_y()[1]\\n dist = np.sqrt((x11 - x21) ** 2 + (y11 - y21) ** 2)\\n\\n dx1 = x11 - x12\\n dx2 = x21 - x11\\n dx3 = x22 - x21\\n dx = [dx1, dx2, dx3]\\n # print dx\\n\\n dy1 = y11 - y12\\n dy2 = y21 - y11\\n dy3 = y22 - y21\\n dy = [dy1, dy2, dy3]\\n # print dy\\n\\n good_angle = False\\n \\\"\\\"\\\"if dx1*dx3<0 and dy1*dy3<0:\\n good_angle = True\\\"\\\"\\\"\\n\\n if max(dx) * min(dx) > -10 and max(dy) * min(dy) > -10:\\n good_angle = True\\n\\n if dist < space and good_angle:\\n test = True\\n strokes[i] = concat([stroke, stroke_i])\\n strokes[indice:-1] = strokes[indice + 1:]\\n strokes = strokes[:-1]\\n break\\n if not test:\\n i += 1\\n\\n return strokes\",\n \"def trim_data(data, xy, p = 0.1):\\n if xy is False:\\n length = len(data)\\n num = int(length * (p/2))\\n return data[num:length - num]\\n X, Y = data\\n length = len(X)\\n num = int(length * (p/2))\\n return X[num:length - num], Y[num:length - num]\",\n \"def connect_points(clipped, side1, side2, window):\\n edge = side1\\n while edge != side2:\\n clipped.append(window.points[0][edge])\\n edge = (edge - 1) % 4\",\n \"def copy_triangle(tri):\\n return [[peg for peg in row] for row in tri]\",\n \"def _strip(self, mols):\\n\\n # The order of operations is important here as stripping atom map\\n # numbers first will lead to total removal of the molecules.\\n return self._strip_map(self._strip_env(mols))\",\n \"def smart_split(strokes):\\n\\n splited = []\\n for stroke in strokes:\\n splited += stroke.split_non_differentiable_points()\\n return splited\",\n \"def Trim(self, *args):\\n return _Adaptor3d.Adaptor3d_Curve_Trim(self, *args)\",\n \"def remove_projection(X, w):\\n return [remove_projection_from_vector(x_i, w) for x_i in X]\",\n \"def proc_sw_only_morphs(forward_pairs, morphs, backward_pairs):\\n sandwich_pairs = []\\n if not backward_pairs:\\n forward_pairs[-1].morphs.extend(morphs)\\n elif len(morphs) == 1:\\n morph = morphs[0]\\n morph_str = str(morph)\\n if morph_str in ['이/VCP', '하/VX'] and backward_pairs[0].morphs[0].tag.startswith('E'):\\n # '이' 긍정지정사나 '하' 보조용언 뒤에 어미가 나올 경우\\n backward_pairs[0].morphs.insert(0, morphs[0])\\n del morphs[:]\\n elif morph_str == '에/JKB' and backward_pairs[0].morphs[0].tag == 'JX':\\n # '에' 부사격조사 뒤에 보조사가 나올 경우\\n backward_pairs[0].morphs.insert(0, morphs[0])\\n del morphs[:]\\n elif morph_str == 'ᆯ/ETM' and forward_pairs[-1].morphs[-1].tag.startswith('V'):\\n # 'ㄹ' 관형형전성어미 앞에 용언이 나올 경우\\n forward_pairs[-1].morphs.append(morphs[0])\\n del morphs[:]\\n elif morph.tag in ['EC', 'EF'] and forward_pairs[-1].morphs[-1].tag.startswith('V'):\\n # 연결어미나 종결어미 앞에 용언이 나올 경우\\n forward_pairs[-1].morphs.append(morphs[0])\\n del morphs[:]\\n elif morph.tag.startswith('XS'):\\n # append suffixes to the end of forward pair list\\n forward_pairs[-1].morphs.append(morphs[0])\\n del morphs[:]\\n else:\\n raise AlignError()\\n else:\\n morphs_str = ' + '.join([str(morph) for morph in morphs])\\n if morphs_str == '(/SS + 대북/NNG + (/SS + 대북/NNG + )/SS + )/SS' and forward_pairs[-1].word_str == u'대북':\\n del morphs[:]\\n elif morphs_str == '(/SS + 동경/NNP + )/SS' and forward_pairs[-1].word_str == u'도쿄':\\n del morphs[:]\\n else:\\n raise AlignError()\\n return sandwich_pairs\",\n \"def cut_ppl_off(self, G):\\r\\n for pre, node in list(G.edges):\\r\\n ew = G.edges[pre, node]['weight']\\r\\n if ew <= -.95:\\r\\n G.remove_edge(pre, node)\\r\\n elif ew >= 1:\\r\\n G.edges[pre, node]['weight'] = 1.0\\r\\n else:\\r\\n continue\\r\\n return G\",\n \"def remove_gap_traces(st):\\n # Check 1:\\n gaps = st.get_gaps()\\n for i in range(len(gaps)):\\n for tr in st.select(network=gaps[i][0], station=gaps[i][1], location=gaps[i][2], channel=gaps[i][3]):\\n st.remove(tr)\\n # Check 2:\\n masked = [np.ma.is_masked(tr.data) for tr in st]\\n for i, tr in enumerate(st):\\n if masked[i]:\\n st.remove(tr)\\n return st\",\n \"def get_clipped_pointcloud(pointcloud, boundary):\\r\\n\\tassert (pointcloud.shape[0]>=2)\\r\\n\\tpointcloud = pointcloud[:,np.logical_and(pointcloud[0,:]<boundary[1], pointcloud[0,:]>boundary[0])]\\r\\n\\tpointcloud = pointcloud[:,np.logical_and(pointcloud[1,:]<boundary[3], pointcloud[1,:]>boundary[2])]\\r\\n\\treturn pointcloud\",\n \"def remove_constant_points(path):\\n z = path\\n while \\\"UD\\\" in z or \\\"DU\\\" in z or \\\"LR\\\" in z or \\\"RL\\\" in z:\\n z = z.replace(\\\"UD\\\", \\\"\\\")\\n z = z.replace(\\\"DU\\\", \\\"\\\")\\n z = z.replace(\\\"LR\\\", \\\"\\\")\\n z = z.replace(\\\"RL\\\", \\\"\\\")\\n return z\",\n \"def translateSweep(self, vect, epsilon=COMPARISON_EPSILON):\\n return self.sweep(lambda c: (c[0] + vect.x,\\n c[1] + vect.y,\\n c[2] + vect.z),\\n epsilon)\",\n \"def zzX_strip(f):\\n if poly_univariate_p(f):\\n return zzx_strip(f)\\n\\n if zzX_zero_p(f):\\n return f\\n\\n k = 0\\n\\n for coeff in f:\\n if not zzX_zero_p(coeff):\\n break\\n else:\\n k += 1\\n\\n if k == len(f):\\n return zzX_zero_of(f)\\n else:\\n return f[k:]\",\n \"def simplify_plaquettes(self, model, dataset=None):\\n for x in self.xvals():\\n for y in self.yvals():\\n p = self.get_plaquette(x, y)\\n if p is not None:\\n p.simplify_circuits(model, dataset)\",\n \"def cutPoly(self,geom,startPt,endPt,debug=False):\\r\\n #if we have disjoint Multi geometry as geom to split we need to iterate over its parts\\r\\n splittedGeoms=[]\\r\\n leftFragments=[]\\r\\n rightFragments=[]\\r\\n #if self.debug: print \\\"Number of geoms when slicing: \\\",str(len(geom.asGeometryCollection()))\\r\\n for geomPart in geom.asGeometryCollection():\\r\\n #split the actual part by cut line defined by startPt,endPt\\r\\n (res,splittedGeomsPart,topo)=geomPart.splitGeometry([startPt,endPt],False)\\r\\n splittedGeoms+=splittedGeomsPart\\r\\n #Add the remaining geomPart to the rightFragments or letfFragments\\r\\n #depending on distance\\r\\n d=self.signedDistCentroidFromLine(geomPart,startPt,endPt)\\r\\n if d>0:\\r\\n rightFragments.append(geomPart)\\r\\n else:\\r\\n leftFragments.append(geomPart)\\r\\n #if self.debug: print j,splittedGeoms\\r\\n\\r\\n for fragment in splittedGeoms:\\r\\n \\\"\\\"\\\"\\r\\n calculate signed distance of centroid of fragment and the splitline\\r\\n if signed distance is below zero, the point is to the left of the line\\r\\n if above zero the point is to the right of the line\\r\\n \\\"\\\"\\\"\\r\\n d=self.signedDistCentroidFromLine(fragment,startPt,endPt)\\r\\n #if debug==True:\\r\\n #if self.debug: print d\\r\\n\\r\\n if d>0:\\r\\n rightFragments.append(fragment)\\r\\n else:\\r\\n leftFragments.append(fragment)\\r\\n\\r\\n #if self.debug: print \\\"Left frags:\\\",len(leftFragments),\\\"Right frags:\\\",len(rightFragments)\\r\\n leftGeom=self.buildMultiPolygon(leftFragments)\\r\\n rightGeom=self.buildMultiPolygon(rightFragments)\\r\\n return leftGeom,rightGeom\",\n \"def prune_path(self, path):\\n while len(path.poses) >= 2:\\n pose0 = pose322(r2g(path.poses[0].pose))\\n pose1 = pose322(r2g(path.poses[1].pose))\\n d0 = np.linalg.norm(g2n(pose0.between(self.current_frame.pose)))\\n d1 = np.linalg.norm(g2n(pose1.between(self.current_frame.pose)))\\n if d1 < d0:\\n path.poses.pop(0)\\n else:\\n break\\n return path\",\n \"def get_layer_trimmed(self, layername: str):\\n\\n lyr = self.get_layer_by_name(layername)\\n notnan = ~np.isnan(lyr)\\n rows = np.any(notnan, axis=1)\\n cols = np.any(notnan, axis=0)\\n rmin, rmax = np.where(rows)[0][[0, -1]]\\n cmin, cmax = np.where(cols)[0][[0, -1]]\\n\\n rmax += 1\\n cmax += 1\\n\\n return lyr[rmin:rmax, cmin:cmax], [rmin, cmin], [rmax, cmax]\",\n \"def destroy(\\n start: int, cycle: List[int], destroy_fraction: float\\n) -> Tuple[List[int], Set[int]]:\\n n = len(cycle)\\n to_destroy = int(destroy_fraction * n)\\n\\n removed_vertices = set(cycle[start : start + to_destroy])\\n cycle[start : start + to_destroy] = []\\n\\n if start + to_destroy > n:\\n removed_vertices.update(cycle[0 : start + to_destroy - n])\\n cycle[0 : start + to_destroy - n] = []\\n\\n return cycle, removed_vertices\",\n \"def truncate(self,G):\\n return {(v,w):{(v,u) for u in G[v] if u != w} | {(w,v)}\\n for v in G for w in G[v]}\",\n \"def clean(self):\\n if self.reloading:\\n self.cleaned = pd.concat(\\n [self.raw[0: self.brkIdx1+1],\\n self.raw[self.brkIdx3+1: self.brkIdx4+1]])\\n else:\\n self.cleaned = self.raw[0: self.brkIdx1+1]\\n self.cleaned.reset_index(drop=True, inplace=True) # update idx\\n # -- Cubic spline that passes through the data\\n sigmaLog = np.log10(self.cleaned['stress'][1:])\\n cs = CubicSpline(x=sigmaLog, y=self.cleaned['e'][1:])\\n self.eSigmaV = float(cs(np.log10(self.sigmaV))) # void ratio at sigmaV\\n return\",\n \"def left_guard_separated(self) -> Sequence[np.poly1d]:\\n l_fit = np.copy(self.fit)\\n l_fit[-1] += self.tolerance * self.image.dpmm\\n if not self._separate_leaves:\\n return [\\n np.poly1d(l_fit),\\n ]\\n else:\\n other_fit = copy.copy(l_fit)\\n mag_factor = self.image.sid / 1000\\n l_fit[-1] += self._nominal_gap * mag_factor / 2 * self.image.dpmm\\n other_fit[-1] -= self._nominal_gap * mag_factor / 2 * self.image.dpmm\\n return [np.poly1d(l_fit), np.poly1d(other_fit)]\",\n \"def VTrim(self, *args):\\n return _Adaptor3d.Adaptor3d_Surface_VTrim(self, *args)\",\n \"def trim(self, start, end):\",\n \"def copy(self):\\n return Segment([p.copy() for p in self.endpoints])\",\n \"def clean():\\n filter_phase_data()\\n combine_phase_data()\\n remove_duplicates_phase_data()\",\n \"def stage_three_preprocessing(data: pd.Series) -> pd.Series:\\n data_ = data.dropna()\\n data_ = shrink_whitespace(data_)\\n #data_ = lemmatize(data_)\\n return data_\",\n \"def trimap(adata: AnnData, *args, **kwargs):\\n return scatters(adata, \\\"trimap\\\", *args, **kwargs)\",\n \"def delaunay(cls,\\n points: Sequence[Point],\\n context: Context) -> 'Triangulation':\\n points = sorted(points)\\n result = [cls._initialize_triangulation(points[start:stop],\\n context)\\n for start, stop in pairwise(accumulate(\\n chain((0,), coin_change(len(points), _base_cases))))]\\n for _ in repeat(None, ceil_log2(len(result))):\\n parts_to_merge_count = len(result) // 2 * 2\\n result = ([result[offset]._merge(result[offset + 1])\\n for offset in range(0, parts_to_merge_count, 2)]\\n + result[parts_to_merge_count:])\\n return result[0]\",\n \"def ltrim1 (l,proportiontocut,tail='right'):\\r\\n if tail == 'right':\\r\\n lowercut = 0\\r\\n uppercut = len(l) - int(proportiontocut*len(l))\\r\\n elif tail == 'left':\\r\\n lowercut = int(proportiontocut*len(l))\\r\\n uppercut = len(l)\\r\\n return l[lowercut:uppercut]\",\n \"def makeSparse(self):\\n center = self.center\\n l = []\\n for point in self.points:\\n angle = Vector.createFromTwoPoints(point, center).angle\\n l.append((angle, copy.deepcopy(point)))\\n l = sorted(l, key=lambda x: x[0])\\n for i in range(len(l)):\\n self.points[i].set(l[i][1])\",\n \"def remove_projection_from_vector(v, w):\\n return vector_subtract(v, project(v, w))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6545068","0.6061567","0.56634015","0.55024093","0.5485883","0.5218839","0.51911056","0.51615465","0.50686365","0.50194067","0.50190455","0.4984925","0.49776727","0.49476588","0.49237248","0.49079263","0.48954168","0.48850134","0.48548362","0.483178","0.48298508","0.48249128","0.4802121","0.479603","0.47880903","0.47811392","0.47770697","0.4770902","0.47693467","0.47588426","0.4757569","0.47478858","0.47445196","0.473501","0.47341362","0.47338298","0.47235262","0.47049218","0.47005245","0.46938992","0.46921873","0.46848366","0.4683852","0.46746323","0.46741974","0.46681798","0.46596098","0.46398467","0.46379805","0.4630566","0.46272686","0.46142432","0.46139973","0.46102524","0.4603904","0.4603166","0.4599708","0.45947847","0.45936045","0.45871398","0.45853743","0.4584212","0.45822388","0.4561939","0.45558223","0.45527625","0.45525086","0.45434374","0.45404178","0.45384312","0.45382002","0.45341682","0.453083","0.45253283","0.45240504","0.4522857","0.45222816","0.45221007","0.4522093","0.451101","0.4509537","0.4509532","0.45001054","0.44988748","0.44976828","0.44921735","0.4491161","0.448893","0.4482284","0.4480153","0.44722214","0.44712377","0.4463958","0.4461247","0.44605148","0.44589671","0.4455919","0.4453439","0.44512898","0.44510275"],"string":"[\n \"0.6545068\",\n \"0.6061567\",\n \"0.56634015\",\n \"0.55024093\",\n \"0.5485883\",\n \"0.5218839\",\n \"0.51911056\",\n \"0.51615465\",\n \"0.50686365\",\n \"0.50194067\",\n \"0.50190455\",\n \"0.4984925\",\n \"0.49776727\",\n \"0.49476588\",\n \"0.49237248\",\n \"0.49079263\",\n \"0.48954168\",\n \"0.48850134\",\n \"0.48548362\",\n \"0.483178\",\n \"0.48298508\",\n \"0.48249128\",\n \"0.4802121\",\n \"0.479603\",\n \"0.47880903\",\n \"0.47811392\",\n \"0.47770697\",\n \"0.4770902\",\n \"0.47693467\",\n \"0.47588426\",\n \"0.4757569\",\n \"0.47478858\",\n \"0.47445196\",\n \"0.473501\",\n \"0.47341362\",\n \"0.47338298\",\n \"0.47235262\",\n \"0.47049218\",\n \"0.47005245\",\n \"0.46938992\",\n \"0.46921873\",\n \"0.46848366\",\n \"0.4683852\",\n \"0.46746323\",\n \"0.46741974\",\n \"0.46681798\",\n \"0.46596098\",\n \"0.46398467\",\n \"0.46379805\",\n \"0.4630566\",\n \"0.46272686\",\n \"0.46142432\",\n \"0.46139973\",\n \"0.46102524\",\n \"0.4603904\",\n \"0.4603166\",\n \"0.4599708\",\n \"0.45947847\",\n \"0.45936045\",\n \"0.45871398\",\n \"0.45853743\",\n \"0.4584212\",\n \"0.45822388\",\n \"0.4561939\",\n \"0.45558223\",\n \"0.45527625\",\n \"0.45525086\",\n \"0.45434374\",\n \"0.45404178\",\n \"0.45384312\",\n \"0.45382002\",\n \"0.45341682\",\n \"0.453083\",\n \"0.45253283\",\n \"0.45240504\",\n \"0.4522857\",\n \"0.45222816\",\n \"0.45221007\",\n \"0.4522093\",\n \"0.451101\",\n \"0.4509537\",\n \"0.4509532\",\n \"0.45001054\",\n \"0.44988748\",\n \"0.44976828\",\n \"0.44921735\",\n \"0.4491161\",\n \"0.448893\",\n \"0.4482284\",\n \"0.4480153\",\n \"0.44722214\",\n \"0.44712377\",\n \"0.4463958\",\n \"0.4461247\",\n \"0.44605148\",\n \"0.44589671\",\n \"0.4455919\",\n \"0.4453439\",\n \"0.44512898\",\n \"0.44510275\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.45522165"},"document_rank":{"kind":"string","value":"67"}}},{"rowIdx":93479,"cells":{"query":{"kind":"string","value":"Get an list of points and a connection network from a cVLS and orderOfSCsByValueByFrame; limit points between triple junctions (Applies GetCVLSWithLimitedPointsBetweenNodes and then GetXYListAndPolyListFromCVLS)"},"document":{"kind":"string","value":"def GetXYListAndPolyListWithLimitedPointsBetweenNodes_CVLS(\n cVLS,\n allValsByFrame,\n orderOfSCsByValueByFrame,\n splitLength=1,\n fixedNumInteriorPoints=None,\n interpolate=True,\n):\n cVLS2 = GetCVLSWithLimitedPointsBetweenNodes(\n cVLS,\n allValsByFrame,\n splitLength,\n fixedNumInteriorPoints,\n interpolate=interpolate,\n )\n return GetXYListAndPolyListFromCVLS(cVLS2, allValsByFrame, orderOfSCsByValueByFrame)"},"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 GetCVLSWithLimitedPointsBetweenNodes(\n cVLS, allValsByFrame, splitLength=1, fixedNumInteriorPoints=None, interpolate=True\n):\n allValues = list(set(tuple(flatten(allValsByFrame))))\n allPairs = sorted(\n list(set([tuple(c[0]) for cVLSByFrame in cVLS for c in cVLSByFrame]))\n ) # Value pairs...\n\n if fixedNumInteriorPoints:\n numInteriorPoints = {p: fixedNumInteriorPoints for p in allPairs}\n else:\n minLength = {}\n for p in allPairs:\n # minLength is the number of points of the shortest subcountour between cells p[0] and p[1] from all frames\n minLength[p] = min(\n [\n len(c[2])\n for cVLSByFrame in cVLS\n for c in cVLSByFrame\n if tuple(c[0]) == p\n ]\n )\n # length of subcontour\n numInteriorPoints = {}\n for p in allPairs:\n numInteriorPoints[p] = minLength[p] // splitLength\n\n cVLS2 = deepcopy(\n cVLS\n ) # otherwise, we'd also change the input argument cVLS in the outside world!\n limIntPtsFunc = (\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\n )\n\n for cvlsByFrame in cVLS2:\n for c in cvlsByFrame:\n c[2] = limIntPtsFunc(c[2], numInteriorPoints[tuple(c[0])])\n\n return cVLS2","def GetXYListAndPolyListFromCVLS(cVLS, allValsByFrame, orderOfSCsByValueByFrame):\n numFrames = len(cVLS)\n xyList = [\n sorted(list(set(tuple(pt) for c in cvlsByVal for pt in c[2])))\n for cvlsByVal in cVLS\n ]\n polyList = []\n\n for t in range(numFrames):\n polyList.append({})\n for v in allValsByFrame[t]:\n subContours = [\n (cVLS[t][-index][2][::-1] if index < 0 else cVLS[t][index][2])\n for index in orderOfSCsByValueByFrame[t][v]\n ] # reconstruct the sc's, flipping if index is negative\n polyList[-1][v] = [\n xyList[t].index(totuple(pt)) for sc in subContours for pt in sc[:-1]\n ]\n polyList[-1][v] = polyList[-1][v] + [\n polyList[-1][v][0]\n ] # Tack on the first point at the end to close the loop\n # VFMin doesn't like this format; make sure to remove this last point before saving to a file or passing to VFM...\n # polyList[-1][v] = removeDuplicates(polyList[-1][v])+[polyList[-1][v][0]] # Remove interior duplication...\n return xyList, polyList","def _calc_pp_pwl_points(ppc_pwl_points):\n\n def construct_list_of_list(row):\n arr = pts[row, ::2]\n arr = np.concatenate((arr[:1], np.repeat(arr[1:-1], 2), arr[-1:])).reshape((-1, 2))\n arr = np.c_[arr, c[row, :]]\n arr = arr[~np.isnan(arr[:, 2])]\n return arr.tolist()\n\n pts = ppc_pwl_points\n if not (pts.shape[1] % 2) == 0:\n raise ValueError(\"_calc_pp_pwl_points() expects ppc_pwl_points with shape[1] is \"\n f\"multiple of 2. However, ppc_pwl_points.shape[1]={ppc_pwl_points}.\")\n c = (pts[:, 3::2] - pts[:, 1:-2:2]) / (pts[:, 2::2] - pts[:, :-2:2])\n return [construct_list_of_list(row) for row in range(pts.shape[0])]","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def connected_components(self) -> List[list]:\n for n in self.dw_graph.get_all_v().values():\n n.distance=0.0\n mega_list = []\n for n in self.dw_graph.get_all_v().values():\n if n.distance!=-10:\n mega_list.append(self.connected_component(n.node_id))\n return mega_list","def point_list(self,res,llc,urc,direction):\n\t\tif direction == 2:\n\t\t\tZdist=urc[2]-llc[2]\n\t\t\tnumPoints=int(numpy.ceil(Zdist/res))\n\t\t\tdeltaZ=Zdist/numPoints\n\t\t\tpoints=[llc+numpy.array([0,0,deltaZ*i]) for i in range(numPoints)]\n\t\t\treturn points, points[0], points[-1]\n\t\tif direction == 1:\n\t\t\tZdist=urc[1]-llc[1]\n\t\t\tnumPoints=int(numpy.ceil(Zdist/res))\n\t\t\tdeltaZ=Zdist/numPoints\n\t\t\tpoints=[llc+numpy.array([0,deltaZ*i,0]) for i in range(numPoints)]\n\t\t\treturn points, points[0], points[-1]\n\t\tif direction == 0:\n\t\t\tZdist=urc[0]-llc[0]\n\t\t\tnumPoints=int(numpy.ceil(Zdist/res))\n\t\t\tdeltaZ=Zdist/numPoints\n\t\t\tpoints=[llc+numpy.array([deltaZ*i,0,0]) for i in range(numPoints)]\n\t\t\treturn points, points[0], points[-1]","def calculate_ctrl_pts(self) -> list[tuple]:\n ctrl_pts = []\n # Skip last point if path is non-cyclic\n point_inds = range(self.num_points) if self.is_cyclic else range(self.num_points - 1)\n for i in point_inds:\n z_i = self.points[i]\n z_j = self.points[(i + 1) % self.num_points]\n rho_coefficient = z_i.alpha * velocity(z_i.theta, z_j.phi)\n sigma_coefficient = z_j.beta * velocity(z_j.phi, z_i.theta)\n ctrl_pt_a = z_i + (1 / 3) * rho_coefficient * cmath.exp(complex(0, z_i.theta)) * (z_j - z_i)\n ctrl_pt_b = z_j - (1 / 3) * sigma_coefficient * cmath.exp(complex(0, -z_j.phi)) * (z_j - z_i)\n ctrl_pts.append((ctrl_pt_a.real, ctrl_pt_a.imag))\n ctrl_pts.append((ctrl_pt_b.real, ctrl_pt_b.imag))\n return ctrl_pts","def basicGetPointsGeodesic(self):\n\n # more geodesic, distance=2 (complicated because random)\n data = numpy.array([[0, 1, 1, 1, 2, 2, 2, 0],\n [0, 1, 1, 1, 2, 2, 2, 0],\n [0, 1, 1, 1, 2, 2, 2, 0]])\n labels = Labels(data=data)\n result = labels.getPoints(ids=[1], mode='geodesic', distance=2, \n connectivity=1)\n result = result.tolist()\n if len(result) == 5:\n desired = [[0, 1], [0, 3], [1, 2], [2, 1], [2, 3]]\n elif len(result) == 4:\n desired = [[0, 2], [1, 1], [1, 3], [2, 2]]\n elif len(result) == 3:\n if [1, 2] in result:\n if [0, 1] in result:\n desired = [[0, 1], [1, 2], [2, 3]] \n elif [0, 3] in result:\n desired = [[0, 3], [1, 2], [2, 1]]\n elif [0, 1] in result:\n if [0, 3] in result:\n desired = [[0, 1], [0, 3], [2, 2]]\n elif [2, 1] in result:\n desired = [[0, 1], [2, 1], [1, 3]]\n else:\n desired = [[0, 1], [1, 3], [2, 2]]\n elif [2, 3] in result:\n if [0, 3] in result:\n desired = [[0, 3], [1, 1], [2, 3]]\n elif [2, 1] in result:\n desired = [[0, 2], [2, 1], [2, 3]]\n else:\n desired = [[2, 3], [1, 1], [0, 2]] \n elif [0, 3] in result:\n desired = [[0, 3], [1, 1], [2, 2]]\n elif [2, 1] in result:\n desired = [[2, 1], [1, 3], [0, 2]]\n for des in desired:\n np_test.assert_equal(des in result, True)\n for res in result:\n np_test.assert_equal(res in desired, True)\n\n # mode geodesic, distance=3, inset\n labels = Labels(data=data[1:3, 2:8])\n labels.setInset([slice(1, 3), slice(2, 8)])\n result = labels.getPoints(ids=[2], mode='geodesic', distance=3, \n connectivity=1)\n result = result.tolist()\n if len(result) == 1:\n np_test.assert_equal(result[0][1], 5)\n elif len(result) == 2:\n desired = []\n if [1, 4] in result:\n desired = [[1, 4], [2, 6]]\n elif [2, 4] in result:\n desired = [[2, 4], [1, 6]]\n for des in desired: \n np_test.assert_equal(des in result, True)\n for res in result:\n np_test.assert_equal(res in desired, True)","def identify_lipid_leaflets_legacy(pts,vec,monolayer_cutoff,\n\tmonolayer_cutoff_retry=True,max_count_asymmetry=0.05,pbc_rewrap=True,\n\ttopologize_tolerance=None,topologize_time_limit=30):\n\t#---previous default was somewhat high, but typically came in from specs, and we reduced it incrementally\n\tif monolayer_cutoff==None: monolayer_cutoff = 2.0\n\t#---time limit on the tolerance checker\n\ttry:\n\t\twith time_limit(topologize_time_limit): \n\t\t\twrapper = topologize(pts,vec,\n\t\t\t\t**({'tol':topologize_tolerance} if topologize_tolerance else {}))\n\texcept TimeoutException: \n\t\tstatus('topologize failed to join the bilayer. '\n\t\t\t'if it is broken over PBCs e.g. a saddle, this is a serious error which may go undetected. '\n\t\t\t'make sure you always inspect the topology later.',tag='error')\n\t\twrapper = np.zeros((len(pts),3))\n\tfindframe = pts + wrapper*np.array(vec)\n\tstatus('this step is somewhat slow. it uses scipy.spatial.pdist.',tag='warning')\n\tpd = [scipy.spatial.distance.squareform(scipy.spatial.distance.pdist(findframe[:,d:d+1])) \n\t\tfor d in range(3)]\n\tif pbc_rewrap:\n\t\tpd3pbc = np.sqrt(np.sum(np.array([pd[d]-(pd[d]>vec[d]/2.)*vec[d]+(pd[d]<-1*vec[d]/2.)*vec[d] \n\t\t\tfor d in range(3)])**2,axis=0))\n\telse: pd3pbc = pd\n\tnbors = np.transpose(np.where(pd3pbc<monolayer_cutoff))\n\tnlipids = len(pts)\n\timono = np.zeros(nlipids)\n\tnlist = []\n\tfor i in range(nlipids):\n\t\tstatus('cataloging lipids',i=i,looplen=nlipids,tag='compute')\n\t\tnlist.append(nbors[np.where(nbors[:,0]==i)[0],1])\n\tiref = 0\n\tmono = np.zeros(nlipids)\n\tsearched = np.zeros(nlipids)\n\timono[iref],searched[iref] = 1,1\n\timono[nlist[iref]] = 1\n\twhile np.any(np.all((imono==1,searched==0),axis=0)):\n\t\tfor iref in np.where(np.all((imono==1,searched==0),axis=0))[0]: \n\t\t\timono[nlist[iref]] = 1\n\t\t\tsearched[iref] = 1\n\t#---check that the leaflets were properly distinguished by looking at the number in each monolayer\n\tif np.mean(imono)==0.5: \n\t\tstatus('[STATUS] perfect split is %0.5f'%np.mean(imono))\n\t\treturn imono\n\telif (monolayer_cutoff_retry and (np.all(np.array(imono)==0) or np.all(np.array(imono)==1) or \n\t\tnp.abs(np.mean(imono)-0.5)>=max_count_asymmetry)):\n\t\tstatus('[STATUS] split is %0.5f'%np.mean(imono))\n\t\tstatus('[STATUS] one side has %d'%np.sum(imono))\n\t\tstatus('[WARNING] leaflets were not distinguished')\n\t\tstatus('[COMPUTE] leaflets = '+str(np.sum(imono))+'/'+str(len(imono)))\n\t\tstatus('[WARNING] previous monolayer_cutoff = '+str(monolayer_cutoff))\n\t\traise Exception(\n\t\t\t'[ERROR] failed to identify leaflets so we are returning an exception to the LeafletFinder')\n\telse: status('[STATUS] some lipids might be flipped %d %.5f'%(np.sum(imono),np.mean(imono)))\n\treturn imono","def construct_fast_graph_connection(coord_list, radie):\n\n connection_distance = []\n connection = []\n coord_list_tree = scipy.spatial.cKDTree(coord_list)\n for j, data in enumerate(coord_list):\n '''save nodes which are in range'''\n connections_ckd = coord_list_tree.query_ball_point(data, radie)\n for i in connections_ckd:\n #only save upper half of the matrix\n if i > j:\n #save the connection\n connection.append([j, i])\n #save the relative distance of the nodes\n connection_distance.append(np.hypot(coord_list[i,0]-data[0], coord_list[i,1]-data[1]))\n\n connection_distance = np.array(connection_distance)\n connection = np.array(connection)\n\n\n return connection, connection_distance","def MakePolygonNetworkFromWaterSeg(\n waterArr, minSplit=30, allValsByFrame=None, cVLS=None\n):\n if allValsByFrame is None:\n allValsByFrame = [list(set(w.flat)) for w in waterArr]\n if cVLS is None:\n cVLS = GetContourValuesLengthsAndSubContoursByFrame(waterArr, allValsByFrame)\n allPtsList = []\n allSegsList = []\n for t in range(len(cVLS)):\n contours = [i[2] for i in cVLS[t]]\n nc = len(contours)\n lc = [len(i) for i in contours]\n div = [i // 30 for i in lc]\n sep = [(lc[i] if div[i] == 0 else lc[i] // div[i]) for i in range(nc)]\n # subPtsOld = [ ([] if div[i]==0 else contours[i][ ::(len(contours[i])//div[i]) ] )\n # for i in range(nc) ]\n inds = [\n (\n [0, lc[i] - 1]\n if (lc[i] - 1 < 2 * minSplit)\n else list(range(0, lc[i] - 2, sep[i])) + [lc[i] - 1]\n )\n for i in range(nc)\n ]\n\n subPts = [[tuple(contours[i][j]) for j in inds[i]] for i in range(nc)]\n allPts = sorted(list(set(flatten(subPts))))\n subPtsInds = [[allPts.index(j) for j in i] for i in subPts]\n allSegsInds = flatten([zip(i[:-1], i[1:]) for i in subPtsInds])\n allPtsList.append(allPts)\n allSegsList.append(allSegsInds)\n\n return allPtsList, allSegsList","def add_new_connections(session, cobj, conn_list, at_date):\n start_at = int(at_date.gps)\n data = []\n\n for conn in conn_list:\n cobj.connection(\n upstream_part=conn[0],\n up_part_rev=conn[1],\n downstream_part=conn[3],\n down_part_rev=conn[4],\n upstream_output_port=conn[2],\n downstream_input_port=conn[5],\n start_gpstime=start_at,\n stop_gpstime=None,\n )\n print(\"Starting connection {} at {}\".format(cobj, str(at_date)))\n data.append(\n [\n cobj.upstream_part,\n cobj.up_part_rev,\n cobj.downstream_part,\n cobj.down_part_rev,\n cobj.upstream_output_port,\n cobj.downstream_input_port,\n cobj.start_gpstime,\n \"upstream_part\",\n cobj.upstream_part,\n ]\n )\n data.append(\n [\n cobj.upstream_part,\n cobj.up_part_rev,\n cobj.downstream_part,\n cobj.down_part_rev,\n cobj.upstream_output_port,\n cobj.downstream_input_port,\n cobj.start_gpstime,\n \"up_part_rev\",\n cobj.up_part_rev,\n ]\n )\n data.append(\n [\n cobj.upstream_part,\n cobj.up_part_rev,\n cobj.downstream_part,\n cobj.down_part_rev,\n cobj.upstream_output_port,\n cobj.downstream_input_port,\n cobj.start_gpstime,\n \"downstream_part\",\n cobj.downstream_part,\n ]\n )\n data.append(\n [\n cobj.upstream_part,\n cobj.up_part_rev,\n cobj.downstream_part,\n cobj.down_part_rev,\n cobj.upstream_output_port,\n cobj.downstream_input_port,\n cobj.start_gpstime,\n \"down_part_rev\",\n cobj.down_part_rev,\n ]\n )\n data.append(\n [\n cobj.upstream_part,\n cobj.up_part_rev,\n cobj.downstream_part,\n cobj.down_part_rev,\n cobj.upstream_output_port,\n cobj.downstream_input_port,\n cobj.start_gpstime,\n \"upstream_output_port\",\n cobj.upstream_output_port,\n ]\n )\n data.append(\n [\n cobj.upstream_part,\n cobj.up_part_rev,\n cobj.downstream_part,\n cobj.down_part_rev,\n cobj.upstream_output_port,\n cobj.downstream_input_port,\n cobj.start_gpstime,\n \"downstream_input_port\",\n cobj.downstream_input_port,\n ]\n )\n data.append(\n [\n cobj.upstream_part,\n cobj.up_part_rev,\n cobj.downstream_part,\n cobj.down_part_rev,\n cobj.upstream_output_port,\n cobj.downstream_input_port,\n cobj.start_gpstime,\n \"start_gpstime\",\n cobj.start_gpstime,\n ]\n )\n with mc.MCSessionWrapper(session=session) as session:\n update_connection(session, data, True)","def cyclic_subgroups(C):\n ps = C.points()\n Gs = []\n \n for i in ps:\n P = Elliptic_Point(i[0],i[1],C)\n Gs.append(cyclic_subgroup(P))\n\n return Gs","def create_pf_coils(self) -> list:\n\n # from diagram\n lower_lefts = np.array(\n [\n (345.5429497568881, -788.0537547271744),\n (800.6482982171799, -703.3664235548353),\n (1160.9400324149108, -272.69381415451096),\n (1158.833063209076, 268.97622906537015),\n (798.5413290113453, 621.6369529983793),\n (345.5429497568881, 707.7795786061589),\n ]\n )\n\n top_rights = np.array(\n [\n (511.99351701782825, -690.4038357644516),\n (880.7131280388979, -611.8280659103187),\n (1222.0421393841166, -162.37506753106413),\n (1230.4700162074555, 379.2780929227446),\n (861.7504051863858, 681.9523230686117),\n (446.677471636953, 803.4508373851974),\n ]\n )\n\n outboard_pf_coils = []\n for counter, (top_right, lower_left) in enumerate(zip(top_rights, lower_lefts), 1):\n pf_coil = paramak.PoloidalFieldCoilFP(\n corner_points=(top_right, lower_left),\n rotation_angle=self.rotation_angle,\n name=f\"outboard_pf_coils_{counter}\",\n )\n outboard_pf_coils.append(pf_coil)\n\n x_inner, x_outer = 132.73905996758506, 202.26904376012968\n\n pf_coils_1 = paramak.RotateStraightShape(\n points=[\n (x_inner, -600),\n (x_outer, -600),\n (x_outer, -400),\n (x_inner, -400),\n ],\n rotation_angle=self.rotation_angle,\n name=\"pf_coil_1\",\n )\n\n pf_coils_2 = paramak.RotateStraightShape(\n points=[\n (x_inner, -400),\n (x_outer, -400),\n (x_outer, -200),\n (x_inner, -200),\n ],\n rotation_angle=self.rotation_angle,\n name=\"pf_coil_2\",\n )\n\n pf_coils_3 = paramak.RotateStraightShape(\n points=[\n (x_inner, -200),\n (x_outer, -200),\n (x_outer, 0),\n (x_inner, 0),\n ],\n rotation_angle=self.rotation_angle,\n name=\"pf_coil_3\",\n )\n\n pf_coils_4 = paramak.RotateStraightShape(\n points=[\n (x_inner, 0),\n (x_outer, 0),\n (x_outer, 200),\n (x_inner, 200),\n ],\n rotation_angle=self.rotation_angle,\n name=\"pf_coil_4\",\n )\n\n pf_coils_5 = paramak.RotateStraightShape(\n points=[\n (x_inner, 200),\n (x_outer, 200),\n (x_outer, 400),\n (x_inner, 400),\n ],\n rotation_angle=self.rotation_angle,\n name=\"pf_coil_5\",\n )\n\n pf_coils_6 = paramak.RotateStraightShape(\n points=[\n (x_inner, 400),\n (x_outer, 400),\n (x_outer, 600),\n (x_inner, 600),\n ],\n rotation_angle=self.rotation_angle,\n name=\"pf_coil_6\",\n )\n\n return outboard_pf_coils + [\n pf_coils_1,\n pf_coils_2,\n pf_coils_3,\n pf_coils_4,\n pf_coils_5,\n pf_coils_6,\n ]","def optionThree(catalog):\n ans = controller.pointsInterconnection(catalog)\n\n item_map = folium.Map(location=[25.557547, -24.568953], zoom_start=2)\n for landinpoint in lt.iterator(ans[0]):\n item = mp.get(catalog['landingpoints'], landinpoint)['value']['info']\n print('Nombre:', item['id'], '\\tLugar:', item['name'], '\\tIdentificador: ', item['landing_point_id'])\n\n tooltip = item['id']\n item_lat = float(item['latitude'])\n item_lon = float(item['longitude'])\n cables = mp.get(catalog['landingpoints'], landinpoint)['value']['lstcables']\n folium.Marker(location=[item_lat, item_lon], popup=\"<strong></strong>\", tooltip=tooltip, icon=folium.Icon(color='darkred', icon = 'cloud')).add_to(item_map)\n\n for cable in lt.iterator(mp.keySet(cables)): \n # * Markers y conectors entre el lp actual y todas sus conexiones\n\n cable = cable.split('-')[1:][0]\n cable_info = mp.get(catalog['landingpoints'], cable)['value']['info']\n cable_lat = float(cable_info['latitude'])\n cable_lon = float(cable_info['longitude'])\n tooltip_2 = cable_info['name']\n folium.Marker(location=[cable_lat, cable_lon], popup=\"<strong>Landpoint se connecta con Jakarta</strong>\", tooltip=tooltip_2,icon=folium.Icon(color='lightgray')).add_to(item_map)\n folium.PolyLine([(item_lat, item_lon), (cable_lat, cable_lon)],\n color='gray',\n weight=2,\n opacity=0.6).add_to(item_map)\n\n print('\\nHay', ans[1], 'cables conectados a dicho(s) landingpoints')\n item_map.save('Req 2.html')","def lagrangePoints(mu):\n \n # define l = 1-mu\n l = 1 - mu\n \n # collinear points\n def eqL1(x):\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)+mu-l)*x**2 + (mu**2*l**2+2*(l**2+mu**2))*x + mu**3-l**3\n #fval = gamma**5 - (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 + 2*mu*gamma - mu\n return fval\n sol_l1 = optimize.root(eqL1, 0.5, method='hybr')\n l1 = np.array([sol_l1.x[0] , 0, 0])\n \n def eqL2(x):\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)-(mu+l))*x**2 + (mu**2*l**2+2*(l**2-mu**2))*x - (mu**3+l**3)\n #fval = gamma**5 + (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 - 2*mu*gamma - mu\n return fval\n sol_l2 = optimize.root(eqL2, 1.5, method='hybr')\n l2 = np.array([sol_l2.x[0] , 0, 0])\n \n def eqL3(x):\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*mu*l+mu**2)*x**3 + (2*mu*l*(l-mu)+(l+mu))*x**2 + (mu**2*l**2+2*(mu**2-l**2))*x + l**3+mu**3\n return fval\n sol_l3 = optimize.root(eqL3, -1, method='hybr')\n l3 = np.array([sol_l3.x[0] , 0, 0])\n \n # equilateral points\n # L4\n l4 = np.array([np.cos(np.pi/3) - mu , np.sin(np.pi/3), 0])\n # L5\n l5 = np.array([np.cos(np.pi/3) - mu , -np.sin(np.pi/3), 0])\n \n return _lagrangePointsReturn(l1,l2,l3,l4,l5)","def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\n if not ls_FVS:\n set_nodes = set([])\n for t_link in lt_links:\n set_nodes.add(t_link[0])\n set_nodes.add(t_link[1])\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\n #if FVS nodes are already gained, pass this step\n \n llt_feedbacks = []\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\n for s_FVSnode in ls_FVS:\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\n for lt_downstream in llt_downstreams:\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\n \n lts_cyclesofFVS = get_all_cycles(ls_FVS)\n for ts_cycleofFVS in lts_cyclesofFVS:\n if len(ts_cycleofFVS) == 1:\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\n else:\n b_stopflag = False\n lllt_feedbackfragment = []\n for i in range(len(ts_cycleofFVS)-1):\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\n b_stopflag = True\n break\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\n b_stopflag = True\n if b_stopflag:\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\n \n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\n while lllt_feedbackfragment:\n llt_fragments_next = lllt_feedbackfragment.pop(0)\n llt_feedbacks_updated = []\n for lt_fragment in llt_feedbacks_specific_cycle:\n for lt_fragment_next in llt_fragments_next:\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\n if not set(ls_route).intersection(set(ls_route_next)):\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\n\n return llt_feedbacks","def nodesBetweenCriticalPoints(self, head: Optional[ListNode]) -> List[int]:\n critical = []\n pos = 1\n while head is not None and head.next is not None and head.next.next is not None:\n if head.val < head.next.val > head.next.next.val or head.val > head.next.val < head.next.next.val:\n critical.append(pos)\n head = head.next\n pos += 1\n if len(critical) <= 1:\n return [-1, -1]\n ret_min = pos\n ret_max = critical[-1] - critical[0]\n for i in range(1, len(critical)):\n ret = critical[i] - critical[i - 1]\n if ret < ret_min:\n ret_min = ret\n return [ret_min, ret_max]","def construct_graph_connection(coord_list, radie):\n\n connection_distance = []\n connection = []\n for j, data in enumerate(coord_list):\n '''Calculate the relative distance of the nodes'''\n distance = np.hypot(coord_list[:,0]-data[0], coord_list[:,1]-data[1])\n '''save nodes which are in range'''\n #for i, data in enumerate(distance):\n for i in range(j+1, len(distance)):\n data = distance[i]\n if data < radie:\n connection.append([j, i])\n connection_distance.append(data)\n\n\n connection_distance = np.array(connection_distance)\n connection = np.array(connection)\n return connection, connection_distance","def chercherChemin(self):\n\n \n liste=self._circuit.vue(self.x,self.y,self.rayonVision)\n \n listeSuppr=[]\n couche_vehicule= self._circuit.Couche_vehicules\n \n for case in liste :\n #on élimine les cases infranchissbles les cases qui ne sont pas sur le chemin à suivre \n\n if self._circuit.numeroWayPoint(case[0],case[1])==0 or ( self._circuit.numeroWayPoint(self.x,self.y)!=self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])<= self._circuit.numeroWayPoint(self.x,self.y)) or( self._circuit.numeroWayPoint(case[0],case[1])>= 5*self._circuit.numeroWayPoint(self.x,self.y) and self._circuit.numeroWayPoint(self.x,self.y)!=0) or ( self._circuit.numeroWayPoint(self.x,self.y)==self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])== self._circuit.numeroWayPoint(self.x,self.y)) or self._circuit.plateau[case[1],case[0],couche_vehicule]!=None:#on élimine les points derrière\n \n listeSuppr.append(case)\n\n \n for case in listeSuppr:\n \n liste.remove(case)\n \n if len(liste)>=1:\n l=liste[0]\n\n for nour in liste :\n \n if distance((self.x,self.y),(l[0],l[1])) > distance((self.x,self.y),(nour[0],nour[1])):\n l=nour\n pasx=0\n pasy=0\n if self.x<l[0] : \n pasx=1\n elif self.x>l[0] :\n pasx=-1\n if self.y<l[1] : \n pasy=1\n elif self.y>l[1] :\n pasy=-1\n debug.dprint(\" id {} {}:({},{}) Waypoint {} Point:({},{}) WayPoint {} vitesse :{} reservoir:{}\".format(self.id,self.typeV,self.x,self.y,self._circuit.numeroWayPoint(self.x,self.y),l[0],l[1],self._circuit.numeroWayPoint(l[0],l[1]),self.vitesse,self.reservoir))\n self.orientation=atan2(pasy,pasx)\n\n self.vitesse=1\n\n debug.dprint(self) \n \n super().deplacer()\n \n\n self.rayonVision=4\n else :# on augemente le rayon de vision au cas ou toutes les cases sont occupées ou non franchissables\n self.rayonVision*=3","def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def _retrieve_options(list_waypoints, current_waypoint):\n options = []\n for next_waypoint in list_waypoints:\n # this is needed because something we are linking to\n # the beggining of an intersection, therefore the\n # variation in angle is small\n next_next_waypoint = next_waypoint.next(3.0)[0]\n link = _compute_connection(current_waypoint, next_next_waypoint)\n options.append(link)\n\n return options","def cvx_inequality_time_graphical_lasso(\n S, K_init, max_iter, loss, C, theta, psi, gamma, tol\n ):\n\n if loss == 'LL':\n loss_function = neg_logl\n else:\n loss_function = dtrace\n\n T, p, _ = S.shape\n K = [cp.Variable(shape=(p, p), PSD=True) for t in range(T)]\n # Z_1 = [cp.Variable(shape=(p, p), PSD=True) for t in range(T-1)]\n # Z_2 = [cp.Variable(shape=(p, p), PSD=True) for t in range(T-1)]\n\n if psi == 'laplacian':\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \n (1 - theta) * cp.sum([cp.norm(K[t] - K[t-1], 'fro') for t in range(1, T)]))\n elif psi == 'l1':\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \n (1 - theta) * cp.sum([cp.sum(cp.norm1(K[t] - K[t-1], axis=1)) for t in range(1, T)]))\n elif psi == 'l2':\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \n (1 - theta) * cp.sum([cp.sum(cp.norm(K[t] - K[t-1], p=2, axis=1)) for t in range(1, T)]))\n elif psi == 'linf':\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \n (1 - theta) * cp.sum([cp.sum(cp.norm_inf(K[t] - K[t-1], axis=1)) for t in range(1, T)]))\n\n # if loss_function == neg_logl:\n constraints = [(cp.sum(cp.multiply(K[t], S[t])) - cp.log_det(K[t]) <= C[t]) for t in range(T)]\n # [(cp.trace(K[t] @ S[t]) - cp.log_det(K[t]) <= C[t]) for t in range(T)] # + \\\n # [(Z_1[t] == K[t]) for t in range(T-1)] + \\\n # [(Z_2[t] == K[t+1]) for t in range(T-1)]\n # else:\n # constraints = [(cp.trace(K[t] @ K[t] @ S[t]) - cp.trace(K[t]) <= C[t]) for t in range(T)] # + \\\n # # [(Z_1[t] == K[t]) for t in range(T-1)] + \\\n # # [(Z_2[t] == K[t+1]) for t in range(T-1)]\n\n prob = cp.Problem(objective, constraints)\n # prob.solve(solver=cp.SCS, max_iters=np.int(max_iter), eps=tol, verbose=True)\n prob.solve(solver=cp.MOSEK, verbose=True)\n\n print(prob.status)\n print(prob.value)\n\n K = np.array([k.value for k in K])\n covariance_ = np.array([linalg.pinvh(k) for k in K])\n return_list = [K, covariance_]\n return return_list","def api_get_crossing_proposals(\n self,\n request,\n o1,\n o2=None,\n left_filter: Optional[str] = None,\n right_filter: Optional[str] = None,\n cable_filter: Optional[str] = None,\n ):\n self.logger.info(\n \"Crossing proposals: %s:%s, %s:%s. Cable: %s\",\n o1,\n left_filter,\n o2,\n right_filter,\n cable_filter,\n )\n lo: Object = self.get_object_or_404(Object, id=o1)\n ro: Optional[Object] = None\n if o2:\n ro = self.get_object_or_404(Object, id=o2)\n id_ports_left = {}\n checking_ports = []\n lcs: List[Dict[str, Any]] = []\n cable: Optional[ObjectModel] = None\n # Getting cable\n cables = ObjectModel.objects.filter(data__length__length__gte=0)\n if cable_filter:\n cable = ObjectModel.get_by_name(cable_filter)\n for c in lo.model.connections:\n valid, disable_reason = True, \"\"\n if cable_filter:\n # If select cable_filter - check every connection to cable\n cable_connections = [\n c for c in lo.model.get_connection_proposals(c.name) if c[0] == cable.id\n ]\n valid = bool(cable_connections)\n elif ro and right_filter:\n rc = ro.model.get_model_connection(right_filter)\n if not rc:\n raise\n valid, disable_reason = lo.model.check_connection(c, rc)\n elif ro:\n valid = bool(\n [c for c in lo.model.get_connection_proposals(c.name) if c[0] == ro.model.id]\n )\n oc, oo, _ = lo.get_p2p_connection(c.name)\n left_id = f\"{smart_text(lo.id)}{c.name}\"\n is_employed = bool(oc)\n if is_employed:\n checking_ports.append(c)\n lcs += [\n self.get_cs_item(\n left_id,\n c.name,\n str(c.type.id),\n c.type.name,\n c.gender,\n c.direction,\n c.protocols,\n not is_employed,\n valid,\n disable_reason,\n lo,\n )\n ]\n id_ports_left[c.name] = left_id\n id_ports_right = {}\n rcs: List[Dict[str, Any]] = []\n if ro:\n for c in ro.model.connections:\n valid, disable_reason = True, \"\"\n if cable_filter:\n cable_connections = [\n c for c in ro.model.get_connection_proposals(c.name) if c[0] == cable.id\n ]\n valid = bool(cable_connections)\n elif left_filter:\n lc = lo.model.get_model_connection(left_filter)\n if not lc:\n raise\n valid, disable_reason = lo.model.check_connection(c, lc)\n else:\n valid = bool(\n [\n c\n for c in ro.model.get_connection_proposals(c.name)\n if c[0] == lo.model.id\n ]\n )\n oc, oo, _ = ro.get_p2p_connection(c.name)\n right_id = f\"{smart_text(ro.id)}{c.name}\"\n rcs += [\n self.get_cs_item(\n right_id,\n c.name,\n str(c.type.id),\n c.type.name,\n c.gender,\n c.direction,\n c.protocols,\n not bool(oc),\n valid,\n disable_reason,\n ro,\n )\n ]\n id_ports_right[c.name] = right_id\n wires = []\n device_left = {}\n device_right = {}\n if lcs and rcs:\n device_left[\"id\"] = smart_text(lo.id)\n device_left[\"name\"] = lo.name\n device_right[\"id\"] = smart_text(ro.id)\n device_right[\"name\"] = ro.name\n for p in checking_ports:\n remote = self.get_remote_slot(p, lo, ro)\n if remote:\n wires.append(\n {\n \"left\": {\"id\": id_ports_left.get(p.name, 0), \"name\": p.name},\n \"right\": {\n \"id\": id_ports_right.get(remote.connection, 0),\n \"name\": remote.connection,\n },\n }\n )\n # Forming cable\n return {\n \"left\": {\"connections\": lcs, \"device\": device_left},\n \"right\": {\"connections\": rcs, \"device\": device_right},\n \"cable\": [{\"name\": c.name, \"available\": True} for c in cables],\n \"valid\": lcs and rcs and left_filter and right_filter,\n \"wires\": wires,\n }","def create_conserved_pos_list(gpcr_pdb,gpcr_aa, i,my_pos, cons_pos_li, multiple_chains,chain_name):\n my_pos_bw=my_pos.split(\"x\")[0]\n add_chain_name=\"\"\n if multiple_chains:\n add_chain_name=\":\"+chain_name\n while i < len(cons_pos_li):\n cons_pos = cons_pos_li[i][0]\n cons_pos_bw=cons_pos[1:]\n cons_aa=cons_pos[0]\n if my_pos_bw==cons_pos_bw:\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\n if pos_range:\n cons_pos_li[i][2]=pos_range + add_chain_name\n (my_aa,chain)=gpcr_aa[my_pos]\n if my_aa != cons_aa:\n cons_pos_li[i][0]=cons_pos+my_aa\n i+=1","def generate_lcs(x, y, id, N, nspot_min=50, nspot_max=500, incl_min=0,\n incl_max=np.pi/4., amp_min=1, amp_max=100, pmin=.5,\n pmax=90, tau_min=5, tau_max=20):\n\n params = [nspot_min, nspot_max, incl_min, incl_max, amp_min*rvar,\n amp_max*rvar, pmin, pmax, tau_min, tau_max]\n nspots, incl, periods, amps, tau = injection_params(N, params)\n true_params = {'nspots': nspots, 'incl': incl, 'periods': periods,\n 'amps': amps, 'tau': tau}\n\n xarr = np.zeros((len(x), N))\n yarr = np.zeros((len(x), N))\n for i in range(N):\n print(i, \"of\", N)\n res0, res1 = mklc(x, nspot=nspots[i], incl=incl[i], tau=tau[i],\n p=periods[i])\n med = np.median(res1[2, :])\n ys = (res1[2, :] / med - 1) * amps[i] # median normalise and scale\n yarr[:, i] = ys + y\n xarr[:, i] = x\n if N == 1:\n return xarr.T[0], yarr.T[0], x, y, true_params\n\n # save the results\n np.savetxt(\"lcs.txt\", yarr.T)\n np.savetxt(\"xs.txt\", xarr.T)\n np.savetxt(\"truth.txt\", np.vstack((nspots, incl, periods, amps, tau)).T)\n\n return xarr, yarr, true_params","def find_conn_CXCY(atom, atom_list):\n le_list = []\n for element in identify_bonds(atom, atom_list):\n if ((element[0].atom_name == \"CX\") or (element[0].atom_name == \"CY\")):\n if (atom.z - element[0].z > 0):\n le_list.append([element[0], 1])\n else:\n le_list.append([element[0], -1])\n return le_list","def connect_points(clipped, side1, side2, window):\n edge = side1\n while edge != side2:\n clipped.append(window.points[0][edge])\n edge = (edge - 1) % 4","def findScalingCoeffsLimiter(self, PFC, lqCN, lqCF):\n # Get R and Z vectors at the midplane\n# R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\n R_omp_sol = self.map_R_psi(1.0,PFC)\n R_omp_min = R_omp_sol #this is a limited discharge so Rmin = Rlcfs\n if lqCN > lqCF:\n lqMax = lqCN\n else:\n lqMax = lqCF\n R_omp_max = R_omp_sol + 20.0*lqMax #already in m\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\n if R_omp_max > max(PFC.ep.g['R']):\n R_omp_max = max(PFC.ep.g['R']) #in meters now\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\n Z_omp = np.zeros(R_omp.shape)\n\n # Evaluate B at outboard midplane\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\n\n #Find coordinate transformation vector at midplane\n psiaxis = PFC.ep.g['psiAxis']\n psiedge = PFC.ep.g['psiSep']\n deltaPsi = np.abs(psiedge - psiaxis)\n gradPsi = Bp_omp*R_omp\n xfm = gradPsi / deltaPsi\n\n # transform hf width into flux space\n lqCN_hat = lqCN*xfm\n lqCF_hat = lqCF*xfm\n\n\n #Calculate flux at midplane using gfile\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\n psi = psiN*(psiedge - psiaxis) + psiaxis\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\n s_hat = psiN - PFC.psiMinLCFS\n\n\n print('psiMinLCFS: {:f}'.format(PFC.psiMinLCFS))\n# print('un-normalized psiMinLCFS: {:f}'.format(PFC.ep.psiFunc_noN.ev(R_omp_sol,0.0)))\n print('Minimum s_hat: {:f}'.format(s_hat.min()))\n\n\n #integral in flux space\n qCN_hat = np.exp(-s_hat / lqCN_hat)\n qCF_hat = np.exp(-s_hat / lqCF_hat)\n\n #note: simps integration will fail if x variable (psi) is not monotonic\n #reinke method\n #intCN = simps(qCN_hat / B_omp, psi)\n #intCF = simps(qCF_hat / B_omp, psi)\n #menard method\n intCN = simps(qCN_hat, psi)\n intCF = simps(qCF_hat, psi)\n\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF)\n #account for nonphysical power\n if P0 < 0: P0 = -P0\n #Scale to input power\n q0 = self.Psol/P0\n\n #old method left for reference\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF)\n\n return q0","def connected_component(self, id1: int) -> list:\n list1 = []\n list2 = []\n if id1 in self.dw_graph.nodes:\n list1 = self.bfs(id1, False)\n list2 = self.bfs(id1, True)\n\n list3 = []\n temp=set(list2)\n for value in list1 :\n if value in temp:\n list3.append(value)\n self.dw_graph.nodes[value].distance=-10\n list3.sort()\n return list3","def identify_leaflets_cluster(self,pts,vec,topologize_time_limit=30,max_count_asymmetry=0.05):\n\t\timport scipy\n\t\timport sklearn\n\t\timport sklearn.neighbors\n\t\timport sklearn.cluster\n\t\tnlipids = len(pts)\n\t\t#---time limit on the topologize function which joins broken bilayers e.g. a saddle that crosses PBCs\n\t\ttry:\n\t\t\twith time_limit(topologize_time_limit): \n\t\t\t\twrapper = topologize(pts,vec,\n\t\t\t\t\t**({'tol':self.topologize_tolerance} if self.topologize_tolerance else {}))\n\t\texcept TimeoutException: \n\t\t\tstatus('topologize failed to join the bilayer. '\n\t\t\t\t'if it is broken over PBCs e.g. a saddle, this is a serious error which may go undetected. '\n\t\t\t\t'make sure you always inspect the topology later.',tag='error')\n\t\t\twrapper = np.zeros((len(pts),3))\n\t\tfindframe = pts + wrapper*np.array(vec)\n\t\t#---ensure that all points are in the box\n\t\tfindframe += vec*(findframe<0) - vec*(findframe>vec)\n\t\t#---previous calculation of connectivity was done manually\n\t\tif False:\n\t\t\t#---conservative cutoff gets lots of nearby points\n\t\t\tcutoff = 10.0\n\t\t\tcutoff_short = 2.0\n\t\t\t#---make a K-D tree from the points\n\t\t\ttree = scipy.spatial.ckdtree.cKDTree(findframe,boxsize=np.concatenate((vec,vec))+0.*eps)\n\t\t\t#---find the nearest reference points for each instantaneous point\n\t\t\tclose,nns = tree.query(findframe,distance_upper_bound=cutoff,k=20)\n\t\t\t#---construct the neighbor list\n\t\t\tsubjects = np.where(np.all((close<cutoff,close>0),axis=0))\n\t\t\t#---get the pairs of neighbors\n\t\t\tsubjects,neighbors = subjects[0],nns[subjects]\n\t\t\tpds = np.ones((nlipids,nlipids))*0.0\n\t\t\tpds[tuple((np.arange(nlipids),np.arange(nlipids)))] = 0.0\n\t\t\tnears = np.where(np.all((close>0,close<=cutoff_short),axis=0))\n\t\t\tpds[tuple((nears[0],nns[nears]))] = 1.0#close[nears]\n\t\t\tpds[tuple((nns[nears],nears[0]))] = 1.0#close[nears]\n\t\tconnectivity = sklearn.neighbors.kneighbors_graph(findframe,\n\t\t\tn_neighbors=self.cluster_neighbors,include_self=False)\n\t\tward = sklearn.cluster.AgglomerativeClustering(n_clusters=2,\n\t\t\tconnectivity=connectivity,linkage='complete').fit(findframe)\n\t\timono = ward.labels_\n\t\tif np.mean(imono)==0.5: \n\t\t\tstatus('[STATUS] perfect split is %0.5f'%np.mean(imono))\n\t\telif (np.all(np.array(imono)==0) or np.all(np.array(imono)==1) or \n\t\t\tnp.abs(np.mean(imono)-0.5)>=max_count_asymmetry):\n\t\t\tstatus('[STATUS] split is %0.5f'%np.mean(imono))\n\t\t\tstatus('[STATUS] one side has %d'%np.sum(imono))\n\t\t\tstatus('[WARNING] leaflets were not distinguished')\n\t\t\traise Exception('[ERROR] failed to identify leaflets. '\n\t\t\t\t'DEVELOPMENT NOTE!? use legacy or a different cutoff?')\n\t\telse: status('[STATUS] some lipids might be flipped %d %.5f'%(np.sum(imono),np.mean(imono)))\n\t\treturn np.array(imono)","def findcc(self):\n for vertex in self.graph.vertices:\n if vertex not in self.preOrderNumbers:\n self.dfs(vertex)\n return self.scComponents","def __generate_connecticity_increasing_canidates(self,k=3):\n result = set()\n \n if k < 3:\n k = 3\n \n self.__logger.info(\"IMPROOVE_NETWORK: Try to seek {} nodes which are currently bad connected\".format(k))\n candidates = heapq.nlargest(3*k, self.__generate_all_shortest_paths(), key=itemgetter(0))\n\n for _, path in candidates:\n result.add(path[0])\n result.add(path[-1])\n\n self.__logger.info(\"IMPROOVE_NETWORK: Found {} candidates which are currently bad connected\".format(len(result))) \n if len(result) <= k:\n return list(result)\n self.__logger.info(\"IMPROOVE_NETWORK: Sample {} items from the candidates as was requested\".format(k))\n tmp = list(result)\n random.shuffle(tmp)\n return tmp[0:k]","def find_all_feedbacks_Tarjan(ls_nodenames, lt_links):\n \n ll_SCC = SCC_analysis.decompose_SCC(ls_nodenames, lt_links)\n ll_feedbacks = []\n for l_SCC in ll_SCC:\n lt_links_in_SCC = basic_topology_functions.extract_subnet_topology(lt_links, l_SCC)\n print(\"feedbacks are calculated in subnetwork with \",len(l_SCC),\" nodes\")\n \n dic_startnode_endnodes = {}\n for s_nodename in l_SCC:\n dic_startnode_endnodes[s_nodename] = []\n for t_link in lt_links_in_SCC:\n if t_link[0] == s_nodename:\n dic_startnode_endnodes[s_nodename].append(t_link[-1])\n #print(dic_startnode_endnodes)\n dic_node_counter = {}\n for s_nodename in l_SCC:\n dic_node_counter[s_nodename] = len(dic_startnode_endnodes[s_nodename])-1\n #print(dic_node_counter)\n for s_node_trajectorystart in dic_node_counter.keys():\n if dic_node_counter[s_node_trajectorystart] == -1: #this means that all feedback containing this node are all calculated\n continue\n else:\n l_trajectory = [s_node_trajectorystart]\n while l_trajectory:\n #print(l_trajectory)\n i_counter = dic_node_counter[l_trajectory[-1]]\n if i_counter == -1:\n dic_node_counter[l_trajectory[-1]] = len(dic_startnode_endnodes[l_trajectory[-1]])-1\n l_trajectory.pop()\n if l_trajectory:\n dic_node_counter[l_trajectory[-1]] -= 1\n else:\n s_node_next = dic_startnode_endnodes[l_trajectory[-1]][i_counter]\n if s_node_next == s_node_trajectorystart:\n ll_feedbacks.append(list(l_trajectory))\n if len(ll_feedbacks)%20000 == 0:\n print(\"calculated feedbacks are now \",len(ll_feedbacks))\n \n if s_node_next in l_trajectory:\n dic_node_counter[l_trajectory[-1]] -= 1\n else:\n l_trajectory.append(s_node_next)\n dic_startnode_endnodes[s_node_trajectorystart] = []\n dic_node_counter[s_node_trajectorystart] =-1\n \n return ll_feedbacks","def GetMatchedSubContourLists(\n scListRef,\n scList,\n allValsByFrame,\n orderOfSCsByValue,\n splitLength=1,\n fixedNumInteriorPoints=None,\n):\n ## NOT DONE! MERGE LATER??\n return simplifiedSCListRef, simplifiedSCList","def cheapCycling(SList,CList):\n N = len(CList)\n nodes= list(range(N))\n Udict = dict(zip(nodes,CList)) #dictionary nodes:neighbours\n queue = deque() #things to check\n checked = {} #checked nodes to avoid double checking\n stations=np.zeros((N,2))#node:arrival output\n\n min_arr = 1000000 #initialise fat value\n arr_node=-1\n \n min_dep = 1000000\n dep_node=-1\n\n while Udict:\n #node = Udict.pop(next(iter(Udict))) #extract first node\n node = next(iter(Udict)) #select first node\n queue.append(node) #add node to queue\n while queue: #while queue is non empty\n node = queue.popleft() #set/extract node to element of queue\n Udict.pop(node) #make sure is also removed from overarching dict\n for nb in CList[node]: #neighbours of node\n if nb not in checked:\n if SList[nb][0] <min_arr: #check if new minimum\n min_arr = SList[nb][0]\n arr_node = nb\n if SList[nb][1] <min_dep: #same but for departure\n min_dep = SList[nb][1]\n dep_node= nb\n queue.append(nb)\n checked[nb] = 1\n checked[node]=1\n \n stations[list(checked.keys()),0] = arr_node #dropping in the cheapest arr and dep nodes for all nodes in connected part\n stations[list(checked.keys()),1] = dep_node\n checked={} #reset checked to empty for new connected part IMPORTANT!\n min_arr=1000000 #reset minimum values\n min_dep=1000000 #reset min dep values\n\n return stations","def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\n # number of nodes\n nx = 5 # along x\n ny = 5 # along y\n\n # getting integration points\n nint = 4\n points, weights = get_points_weights(nint=nint)\n\n # geometry\n a = 3 # along x\n b = 3 # along y\n\n # material properties\n E = 200e9\n nu = 0.3\n laminaprop = (E, E, nu)\n stack = [0]\n h = 0.001\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\n\n # creating mesh\n x = np.linspace(0, a, nx)\n y = np.linspace(0, b, ny)\n xmesh, ymesh = np.meshgrid(x, y)\n\n # node coordinates and position in the global matrix\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\n nids = 1 + np.arange(ncoords.shape[0])\n nid_pos = dict(zip(nids, np.arange(len(nids))))\n\n # identifying nodal connectivity for plate elements\n # similar than Nastran's CQUAD4\n #\n # ^ y\n # |\n #\n # 4 ________ 3\n # | |\n # | | --> x\n # | |\n # |_______|\n # 1 2\n\n\n nids_mesh = nids.reshape(nx, ny)\n n1s = nids_mesh[:-1, :-1].flatten()\n n2s = nids_mesh[1:, :-1].flatten()\n n3s = nids_mesh[1:, 1:].flatten()\n n4s = nids_mesh[:-1, 1:].flatten()\n\n num_elements = len(n1s)\n print('num_elements', num_elements)\n\n N = DOF*nx*ny\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n init_k_KC0 = 0\n init_k_KG = 0\n\n plates = []\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\n plate = BFSPlate2D()\n plate.n1 = n1\n plate.n2 = n2\n plate.n3 = n3\n plate.n4 = n4\n plate.c1 = DOF*nid_pos[n1]\n plate.c2 = DOF*nid_pos[n2]\n plate.c3 = DOF*nid_pos[n3]\n plate.c4 = DOF*nid_pos[n4]\n plate.ABD = lam.ABD\n plate.lex = a/(nx - 1)\n plate.ley = b/(ny - 1)\n plate.init_k_KC0 = init_k_KC0\n plate.init_k_KG = init_k_KG\n update_KC0(plate, points, weights, Kr, Kc, Kv)\n init_k_KC0 += KC0_SPARSE_SIZE\n init_k_KG += KG_SPARSE_SIZE\n plates.append(plate)\n\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\n\n # applying boundary conditions\n\n # locating nodes\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\n\n x = ncoords[:, 0]\n y = ncoords[:, 1]\n\n # applying boundary conditions\n # simply supported\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\n bk[2::DOF] = check\n check = isclose(x, 0) | isclose(x, a)\n bk[3::DOF] = check\n # point supports\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\n bk[0::DOF] = check\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\n bk[1::DOF] = check\n\n # unconstrained nodes\n bu = ~bk # logical_not\n\n # defining external force vector\n fext = np.zeros(KC0.shape[0], dtype=float)\n\n # applying unitary load along u at x=a\n # nodes at vertices get 1/2 the force\n for plate in plates:\n pos1 = nid_pos[plate.n1]\n pos2 = nid_pos[plate.n2]\n pos3 = nid_pos[plate.n3]\n pos4 = nid_pos[plate.n4]\n if isclose(x[pos3], a):\n Nxx = -1\n xi = +1\n elif isclose(x[pos1], 0):\n Nxx = +1\n xi = -1\n else:\n continue\n lex = plate.lex\n ley = plate.ley\n indices = []\n c1 = DOF*pos1\n c2 = DOF*pos2\n c3 = DOF*pos3\n c4 = DOF*pos4\n cs = [c1, c2, c3, c4]\n for ci in cs:\n for i in range(DOF):\n indices.append(ci + i)\n fe = np.zeros(4*DOF, dtype=float)\n for j in range(nint):\n eta = points[j]\n plate.update_Nu(xi, eta)\n Nu = np.asarray(plate.Nu)\n fe += ley/2*weights[j]*Nu*Nxx\n fext[indices] += fe\n\n Kuu = KC0[bu, :][:, bu]\n fextu = fext[bu]\n\n # static solver\n uu = spsolve(Kuu, fextu)\n u = np.zeros(KC0.shape[0], dtype=float)\n u[bu] = uu\n\n if plot_static:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n uplot = u[0::DOF].reshape(nx, ny).T\n vplot = u[1::DOF].reshape(nx, ny).T\n print('u extremes', uplot.min(), uplot.max())\n print('v extremes', vplot.min(), vplot.max())\n levels = np.linspace(uplot.min(), uplot.max(), 300)\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n # eigenvalue solver\n\n # getting integration points\n for plate in plates:\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\n KGuu = KG[bu, :][:, bu]\n\n # solving modified generalized eigenvalue problem\n # Original: (KC0 + lambda*KG)*v = 0\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\n num_eigenvalues = 5\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\n tol=1e-6, sigma=1., mode='cayley')\n eigvals = -1./eigvals\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\n eigvecs[bu, :] = eigvecsu\n\n if plot_lb:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n mode = 0\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\n levels = np.linspace(wplot.min(), wplot.max(), 300)\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\n assert isclose(kc, 6.6, rtol=0.05)","def FindClumps_graph(self):\n # IMPORT STUFF\n import string\n # END IMPORT\n \n maxima = self['CL_LOC'].copy()\n maxima = num.where(maxima)\n maxima = (maxima[1],maxima[0])\n detectimg = self['STAMP'].copy()\n \n id = self._getGraphId()\n root = 'FindClumps_%s' % (id,)\n pngname = root + '.png' ; epsname = root + '.eps'\n jpgname = root + '.jpg'\n\n doStamp(detectimg,pngname,format='PNG')\n Convert(pngname,jpgname)\n \n Painted = Paint(jpgname)\n Painted.load()\n Painted.DrawCross(maxima,length=7,color='green')\n \n strpeaks = string.strip('%i'% (self['M_NUM_CL']))\n text = 'NC=%s' % strpeaks \n \n # Painted.Graffiti(text,commtextpos)\n \n Painted.save(jpgname)\n Painted.release()\n \n Convert(jpgname,epsname)\n os.system('rm %s %s' % (pngname,jpgname))\n self['figures']['FindClumps'] = epsname\n self['figcomms']['FindClumps'] = text","def limited_information_privacy_lb(P0: np.ndarray,\r\n P1: np.ndarray,\r\n initial_points: int = 1,\r\n max_iterations: int = 30,\r\n solver=cp.ECOS,\r\n debug=False):\r\n P0, P1 = sanity_check_probabilities(P0, P1)\r\n initial_points = int(initial_points) if initial_points >= 1 else 1\r\n max_iterations = initial_points if initial_points > max_iterations else int(\r\n max_iterations)\r\n\r\n na, ns = P0.shape[0], P0.shape[1]\r\n\r\n best_res, best_xi1, best_xi0 = np.inf, None, None\r\n # Compute KL divergences\r\n I = compute_KL_divergence_models(P0, P1)\r\n\r\n # Loop through initial points and return best result\r\n i = 0\r\n n = 0\r\n while i == 0 or (i < initial_points and n < max_iterations):\r\n n += 1\r\n gamma = cp.Variable(1)\r\n xi0 = cp.Variable((ns, na), nonneg=True)\r\n xi1 = cp.Variable((ns, na), nonneg=True)\r\n\r\n kl_div_statinary_dis = 0\r\n for s in range(ns):\r\n kl_div_statinary_dis += cp.entr(cp.sum(xi1[s, :]))\r\n\r\n # stationarity constraints\r\n stationarity_constraint = 0\r\n for a in range(na):\r\n stationarity_constraint += xi1[:, a].T @ (P1[a, :, :] - np.eye(ns))\r\n\r\n constraints = [stationarity_constraint == 0, cp.sum(xi1) == 1]\r\n\r\n # Privacy constraints\r\n privacy_constraint = 0\r\n for s in range(ns):\r\n constraints += [cp.sum(xi0[s, :]) == 1]\r\n for y in range(ns):\r\n privacy_constraint += cp.kl_div(\r\n xi1[s, :] @ P1[:, s, y], xi0[s, :] @ P0[:, s, y]) + (\r\n xi1[s, :] @ P1[:, s, y]) - (xi0[s, :] @ P0[:, s, y])\r\n\r\n constraints += [privacy_constraint <= gamma]\r\n objective = gamma + kl_div_statinary_dis\r\n\r\n # Solve problem\r\n problem = cp.Problem(cp.Minimize(objective), constraints)\r\n if not dccp.is_dccp(problem):\r\n raise Exception('Problem is not Concave with convex constraints!')\r\n try:\r\n result = problem.solve(\r\n method='dccp', ccp_times=1, verbose=debug, solver=solver)\r\n except Exception as err:\r\n continue\r\n\r\n # Check if results are better than previous ones\r\n if result[0] is not None:\r\n i += 1\r\n if result[0] < best_res:\r\n best_res, best_xi1, best_xi0 = result[0], xi1.value, xi0.value\r\n\r\n # Make sure to normalize the results\r\n best_xi0 += eps\r\n best_xi1 += eps\r\n best_xi0 /= np.sum(best_xi0) if not np.isclose(np.sum(best_xi0), 0) else 1.\r\n best_xi1 /= np.sum(best_xi1) if not np.isclose(np.sum(best_xi1), 0) else 1.\r\n return best_res, best_xi1, best_xi0","def cinters_circle(self, c):\r\n if self.__segments == None:\r\n self.__load_segments()\r\n \r\n result = []\r\n for segment in self.__segments:\r\n points = c.inters_segment(segment)\r\n for p in points:\r\n result.append(p) \r\n \r\n return result","def test_get_lcp(self):\n\n expected = [0, 6, 5, 0, 5, 4, 0, 4, 3, 0, 3, 2, 0, 2, 1, 0, 1, 0, 0, 0, 0]\n\n self.assertEqual(self.sf.get_lcp(), expected)","def find_endpoints(batch_trajectories):\n # empty lists to fill\n site_lats = []\n site_lons = []\n last_lats = []\n last_lons = []\n lats_150 = []\n lons_150 = [] \n last_times = []\n times_150 = []\n last_sst = []\n sst_150 = []\n \n # temporary lists as placeholders\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n for speed in range(len(batch_trajectories)):\n # working with one speed at a time means working with one nc file at\n # a time\n \n # reset temporary lists\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n # extract variables into lists\n lats = batch_trajectories[speed].variables['lat'][:]\n lons = batch_trajectories[speed].variables['lon'][:]\n lats150 = batch_trajectories[speed].variables['lat150'][:]\n lons150 = batch_trajectories[speed].variables['lon150'][:]\n times = batch_trajectories[speed].variables['time'][:]\n ssts = batch_trajectories[speed].variables['temp'][:]\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\n\n # if a particle is deleted before time is up, values are masked. \n # We'd like to get the last valid number.\n for trajectory in range(len(lats)):\n i = -1 # index for the last value\n while np.ma.is_masked(lats[trajectory][i]) is True:\n i -= 1 # if the value is masked, go to one value sooner\n \n j = i # use j for the 150m values\n while lats150[trajectory][j] > 0:\n # we want the first index where the latitude is recorded.\n # j is actually the last one where it's not recorded, so we\n # extract the information at index j+1\n j -= 1\n\n # once i and j are determined for a trajectory, we can extract the\n # variables and append them to temporary lists.\n temp_site_lats.append(lats[trajectory][0])\n temp_site_lons.append(lons[trajectory][0])\n temp_lats.append(lats[trajectory][i])\n temp_lons.append(lons[trajectory][i])\n temp_lats150.append(lats150[trajectory][j+1])\n temp_lons150.append(lons150[trajectory][j+1])\n temp_times.append(times[trajectory][i])\n temp_sst.append(ssts[trajectory][i])\n temp_sst150.append(ssts_150[trajectory][j+1])\n temp_times150.append(times[trajectory][j+1])\n \n # after the temporary lists are appended by sinking speed, they\n # are appended to the big lists that are returned by the function.\n # this keeps the structure of being separated by sinking speed.\n site_lats.append(temp_site_lats)\n site_lons.append(temp_site_lons)\n last_lats.append(temp_lats)\n last_lons.append(temp_lons)\n lats_150.append(temp_lats150)\n lons_150.append(temp_lons150)\n last_times.append(temp_times)\n times_150.append(temp_times150)\n last_sst.append(temp_sst)\n sst_150.append(temp_sst150)\n \n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\n last_times, times_150, last_sst, sst_150","def computesWingConnexions(self):\n logger.warning(\"!!! WARINING !!!!\")\n logger.warning(\"BE CERTAIN THAT CPACS FILE HAS THE HORIZONTAL TAIL\")\n logger.warning(\"DEFINED BEFORE THE VERTICAL TAIL!!!!\")\n if self.nWings <= 1:\n logger.info(\"No wing connexions needed\")\n elif self.nWings > 1 and self.nFuselage < 1:\n logger.error(\"Multiple wings with no fuselage! Mesh can not be computed\")\n sys.exit()\n else:\n ws_connextionsPoints = self.nWings + self.nFuselage - 1\n # if self.nFuselage > 0:\n # ws_connextionsPoints = self.nWings\n # else:\n # ws_connextionsPoints = self.nWings -1\n\n # ws: wings\n # d: distance\n # L: left, R: right, c: center\n connectedNodes = np.zeros((ws_connextionsPoints,5))\n for i in range(ws_connextionsPoints):\n \"\"\"\n for each wing there is 3 points that need to be taken into\n account:\n 1) Left tip position[0]\n 2) center [np.floor(nNodes/2))]\n WARNING: keep in mind that symmetric wings always have \n an odd number of points!\n 3) right tip position[-1]\n \"\"\"\n if self.nFuselage > 0:\n wingIndex = i+1\n else:\n wingIndex = i\n # logger.debug(\"Wing index = \"+str(wingIndex))\n # N = len(self.aircraftNodesPoints[i])\n currentWingNpoints = len(self.aircraftNodesPoints[wingIndex])\n if currentWingNpoints > 2:\n c = int(np.floor(len(self.aircraftNodesPoints[wingIndex])/2))\n else:\n c = 0\n # logger.debug(\"c = \"+str(c))\n ws_identifiers = np.empty((ws_connextionsPoints,5))\n\n for j in range(ws_connextionsPoints+1):\n logger.debug(\"wingIndex,j = \"+str(wingIndex)+\" \"+str(j))\n if wingIndex != j:\n # c: stands for current\n logger.debug(\"True with wingIndex,j = \"+str(wingIndex)+\" \"+str(j))\n # Computes the distances between all point\n dist_l = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][0], axis=1)\n if currentWingNpoints > 2:\n dist_c = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][c], axis=1)\n else:\n dist_c = dist_l\n dist_r = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][-1],axis=1)\n\n # Gets the index of the minimal distance between all point\n index_l = np.argmin(dist_l)\n if currentWingNpoints > 2:\n index_c = np.argmin(dist_c)\n else:\n index_c = index_l\n index_r = np.argmin(dist_r)\n indexes = np.array([index_l, index_c, index_r])\n\n # gets the minimal distance for each wing part\n minDist_l = dist_l[index_l]\n if currentWingNpoints > 2:\n minDist_c = dist_c[index_c]\n else:\n minDist_c = minDist_l\n minDist_r = dist_r[index_r]\n minDist = np.array([minDist_l,minDist_c,minDist_r])\n\n k = np.argmin(minDist)\n minimalDistance = minDist[k]\n m = indexes[k]\n r = len(self.aircraftNodesPoints[wingIndex])\n tab = np.array([0,c,r])\n k = tab[k]\n\n # minimalDistance: distance between both of these points\n identifier = np.array([wingIndex,j,k,m,minimalDistance])\n # logger.debug(\"Identifier \\n\"+str(identifier))\n if j < wingIndex:\n ws_identifiers[j] = identifier\n else:\n ws_identifiers[j-1] = identifier\n \n index2 = np.argmin(ws_identifiers[:,4])\n old = np.array([ws_identifiers[index2,2],\n ws_identifiers[index2,3],\n ws_identifiers[index2,0],\n ws_identifiers[index2,1],\n ws_identifiers[index2,4]])\n if old in connectedNodes and i > 1:\n logger.warning(\"Found a matching connexion\")\n logger.debug(old)\n logger.debug(ws_identifiers)\n ws_identifiers = np.delete(ws_identifiers,index2,0)\n logger.debug(ws_identifiers)\n index2 = np.argmin(ws_identifiers[:,4])\n connectedNodes[i] = ws_identifiers[index2]\n logger.debug(\"connected Nodes: \\n\"+str(connectedNodes[i]))\n # logger.debug(connectedNodes)\n \n self.aircraftConnectedNodes.append(connectedNodes)\n self.rigidNodesAdder()\n # sys.exit()","def get_data_lcc(data):\n data_lcc = deepcopy(data)\n edge_index_sparse = edge_index_2_csr(data.edge_index, data.num_nodes)\n lcc = largest_connected_components(edge_index_sparse)\n edge_index_lcc_sparse = edge_index_sparse[lcc][:, lcc].tocoo()\n data_lcc.edge_index = torch.stack(list(to_Variable(edge_index_lcc_sparse.row, edge_index_lcc_sparse.col))).long()\n\n data_lcc.x = data.x[lcc]\n data_lcc.y = data.y[lcc]\n data_lcc.train_mask = data.train_mask[lcc]\n data_lcc.val_mask = data.val_mask[lcc]\n data_lcc.test_mask = data.test_mask[lcc]\n return data_lcc","def read_pslg(file_name):\n with open(file_name, \"r\") as fp:\n components = fp.read().split(\"component: \")[1:]\n \n lpoints, lconnect_left, lconnect_right = [], [], []\n index = 0\n \n for component in components:\n raw_points = component.split(\"\\n\")[1:-1]\n points = [list(map(float, line.split()[1:3])) for line in raw_points]\n connect_left = np.roll(np.arange(index, index + len(raw_points), 1), -1)\n connect_right = np.roll(connect_left, 2)\n \n lpoints = lpoints + points\n lconnect_left.append(connect_left)\n lconnect_right.append(connect_right)\n \n index += len(raw_points)\n \n return np.array(lpoints), np.hstack(lconnect_left).astype(int), np.hstack(lconnect_right).astype(int)","def get_local_list_for_neuron(current_neuron_index=current_neuron_index,\n minx='',\n maxx='',\n acts=acts):\n current_neuron = acts.get_activations_for_neuron(current_neuron_index) # get the neuron's data\n x_data = current_neuron.vector # get the activations without classes\n if minx == '':\n minx = min(x_data) # this grabs all the points\n elif minx == 0:\n minx = min([x for x in x_data if x > 0.0])\n # grab everything above 0 - special case, we don't include 0\n # this changed grab_points_for_cluster from x >= 0 to x > 0\n if maxx == '':\n maxx =max(x_data)\n # grab your list of points\n local_list, selected_activations = grab_points_for_a_cluster(current_neuron_index,\n min_selected_x_data=minx,\n max_selected_x_data=maxx,\n acts=acts,\n x_data=x_data,\n verbose=verbose)\n return local_list, selected_activations, x_data","def pointListForCurve(x, y, type):\n\n\tif x < 10:\n\t\txString = \"0%d\" % x\n\telse:\n\t\txString = \"%d\" % x\n\n\tif x < 11:\n\t\txMString = \"0%d\" % (x - 1)\n\telse:\n\t\txMString = \"%d\" % (x - 1)\n\n\tif x < 9:\n\t\txPString = \"0%d\" % (x + 1)\n\telse:\n\t\txPString = \"%d\" % (x + 1)\n\n\tif x < 8:\n\t\txPPString = \"0%d\" % (x + 2)\n\telse:\n\t\txPPString = \"%d\" % (x + 2)\n\n\tif y < 11:\n\t\tyMString = \"0%d\" % (y - 1)\n\telse:\n\t\tyMString = \"%d\" % (y - 1)\n\n\tif y < 9:\n\t\tyPString = \"0%d\" % (y + 1)\n\telse:\n\t\tyPString = \"%d\" % (y + 1)\n\n\tif y < 8:\n\t\tyPPString = \"0%d\" % (y + 2)\n\telse:\n\t\tyPPString = \"%d\" % (y + 2)\n\n\tif y < 10:\n\t\tyString = \"0%d\" % y\n\telse:\n\t\tyString = \"%d\" % y\n\n\tinnerRadius = 54.0 / 64.0\n\touterRadius = 87.0 / 64.0\n\n\tslices = 10\n\n\t# Dots are numbered as xxyy[IO]z\n\t# The I means it is the inside trek, the O the outside\n\t# The z is which particular dot it is (0-9)\n\t# Note that all paths are marked as being inside the top-left square\n\t# Except for entrence and exit dots.\n\t# Curves are generated from star + 10 to end - 10\n\n\tif type == 8:\t\t\t# Bottom right\n\t\tcenterX = 25.0 / 64.0\n\t\tcenterY = 25.0 / 64.0\n\t\tstart = 0.0\n\t\tend = 90.0\n\n\t\tenterIn =\t[\"%s%sTL\" % (xPString, yString), 0.25, 0.25, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sBL\" % (xString, yPString), 0.25, 0.75, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sTL\" % (xString, yPString), 0.25, 0.25, [\"%s%sTR\" % (xMString, yPString)]]\n\t\texitOut =\t[\"%s%sTR\" % (xPString, yString), 0.75, 0.25, [\"%s%sBR\" % (xPString, yMString)]]\n\n\t\tendIn = \"%s%sTL\" % (xString, yPString)\n\t\tendOut = \"%s%sTR\" % (xPString, yString)\n\n\telif type == 9:\t\t\t# Bottom left\n\t\tcenterX = 103.0 / 64.0\n\t\tcenterY = 25.0 / 64.0\n\t\tstart = 90.0\n\t\tend = 180.0\n\n\t\tenterIn =\t[\"%s%sTR\" % (xPString, yPString), 0.75, 0.25, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sTR\" % (xString, yString), 0.75, 0.25, [\"%s%sBR\" % (xString, yMString)]]\n\t\texitOut =\t[\"%s%sBR\" % (xPString, yPString), 0.75, 0.75, [\"%s%sBL\" % (xPPString, yPString)]]\n\n\t\tendIn = \"%s%sTR\" % (xString, yString)\n\t\tendOut = \"%s%sBR\" % (xPString, yPString)\n\n\telif type == 10:\t\t# Top left\n\t\tcenterX = 103.0 / 64.0\n\t\tcenterY = 103.0 / 64.0\n\t\tstart = 180.0\n\t\tend = 270.0\n\n\t\tenterIn =\t[\"%s%sBR\" % (xString, yPString), 0.75, 0.75, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sTR\" % (xPString, yString), 0.75, 0.25, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sBR\" % (xPString, yString), 0.75, 0.75, [\"%s%sBL\" % (xPPString, yString)]]\n\t\texitOut =\t[\"%s%sBL\" % (xString, yPString), 0.25, 0.75, [\"%s%sTL\" % (xString, yPPString)]]\n\n\t\tendIn = \"%s%sBR\" % (xPString, yString)\n\t\tendOut = \"%s%sBL\" % (xString, yPString)\n\n\telse: # type == 11:\t\t# Top right\n\t\tcenterX = 25.0 / 64.0\n\t\tcenterY = 103.0 / 64.0\n\t\tstart = 270.0\n\t\tend = 360.0\n\n\t\tenterIn =\t[\"%s%sBL\" % (xString, yString), 0.25, 0.75, [\"%s%sI0\" % (xString, yString)]]\n\t\tenterOut =\t[\"%s%sBR\" % (xPString, yPString), 0.75, 0.75, [\"%s%sO0\" % (xString, yString)]]\n\t\texitIn =\t[\"%s%sBL\" % (xPString, yPString), 0.25, 0.75, [\"%s%sTL\" % (xPString, yPPString)]]\n\t\texitOut =\t[\"%s%sTL\" % (xString, yString), 0.25, 0.25, [\"%s%sTR\" % (xMString, yString)]]\n\n\t\tendIn = \"%s%sBL\" % (xPString, yPString)\n\t\tendOut = \"%s%sTL\" % (xString, yString)\n\n\tpointList = [enterIn, enterOut, exitIn, exitOut]\n\n\tstring = \"%s%s\" % (xString, yString)\n\tstep = ((end - 1) - (start + 1)) / float(slices)\n\n\tfor i in range(slices):\n\n\t\tangle = radians(start + step * i)\n\n\t\tif i < 9:\n\t\t\ttemp = [\"%sI%d\" % (string, i), centerX + cos(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[\"%sI%d\" % (string, i + 1)]]\n\t\telse:\n\t\t\ttemp = [\"%sI%d\" % (string, i), centerX + cos(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * innerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[endIn]]\n\n\t\tpointList.append(temp)\n\n\t\tangle = radians(start + step * (10 - i))\n\n\t\tif i < 9:\n\t\t\ttemp = [\"%sO%d\" % (string, i), centerX + cos(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[\"%sO%d\" % (string, i + 1)]]\n\t\telse:\n\t\t\ttemp = [\"%sO%d\" % (string, i), centerX + cos(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcenterY + sin(angle) * outerRadius,\n\t\t\t\t\t\t\t\t\t\t\t\t\t[endOut]]\n\n\t\tpointList.append(temp)\n\n\treturn pointList","def get_neighbors(point):\n pt = point.copy()\n output= [point.copy() for i in range(4)]\n output[0:2] = map(Point.setY, output[0:2], [pt.getY()+ i for i in range(-1,2,2)])\n output[2:4]= map(Point.setX, output[2:4], [pt.getX()+ i for i in range(-1,2,2)])\n return output","def avCDNC(CL,abovesize=nan,uppersize=nan,inst=\"FSSP96\",scan=0):\n if len(CL.times[\"verticloud\"])<=scan:\n print(\"[avCDNC] No vertical scan for this cloud.\")\n return nan\n else:\n ts=CL.times[\"verticloud\"][scan] # times of the vertical scan\n pos=[i for i,x in enumerate(CL.sd) if inst.lower() in x[\"Distname\"].lower()]; \n if len(pos)<=0: cancel=1; raise ValueError(\"This instrument name has not been found (inst=%s).\" % inst)\n else: pos=pos[0]\n calt=[i for i,x in enumerate(CL.dttl) if x == 'altitude']; calt=calt[0]\n ctim=[i for i,x in enumerate(CL.dttl) if x == 'time']; ctim=ctim[0]\n alt=CL.data[calt]\n tim=CL.data[ctim]\n clwc=[i for i,x in enumerate(CL.dttl) if x == 'LWC']; \n if len(clwc)>1: print(\"[avCDNC] Multiple LWC found.\"); lwc=np.ones((2,))*NaN; lwctime=ts # LWC found in the basic data\n elif len(clwc)==1: lwc=CL.data[clwc[0]]; lwctime=tim; \n else: # looking for LWC in the extradata\n posx=[] \n for i,L in enumerate(CL.extrattl): # for all extra datasets available\n posx=posx+[[i,j] for j,x in enumerate(L) if x.lower() == 'lwc'] # check all titles matching with LWC\n if len(posx)==1: \n lwc=CL.extradata[posx[0][0]][posx[0][1]] # loading the LWC data\n j=[j for j,x in enumerate(CL.extrattl[i]) if x.lower() == 'time'][0]\n lwctime=CL.extradata[posx[0][0]][j] # loading associated time stamp\n else: print(\"[avCDNC] No LWC (or multiple) was found in the basic data or the extra data.\"); return nan\n \n \n timtc=CL.sd[pos][\"time\"] # time corresponding to the concentration tc\n # find shortest common time stamp\n ta1=np.max([lwctime[0],tim[0],timtc[0],ts[0]]); ta2=np.min([lwctime[-1],tim[-1],timtc[-1],ts[1]]); \n taix=[nonzero((timtc>=ta1)*(timtc<=ta2))[0]]; \n usedtime=timtc[taix]\n if len(usedtime)==0: WA=nan # weighted average is not calculable (no data for the vertical scan)\n else:\n tc=samac.dNdlogDp2N(CL.sd[pos],abovesize,uppersize)[taix] # total concentration between above- and upper-size\n test=tim.__array__()==timtc\n if len(tim)==len(timtc): \n if (tim.__array__()==timtc).all()==True: alt=alt[taix]\n else:\n print(\"[avCDNC] nonequal times (although same length): altitude was interpolated.\")\n # interpolating on size distribution data.\n falt=interpolate.interp1d(tim,alt,kind='linear') \n alt=falt(usedtime); \n else:\n print(\"[avCDNC] nonequal times: altitude was interpolated.\")\n # interpolating on size distribution data.\n falt=interpolate.interp1d(tim,alt,kind='linear') \n alt=falt(usedtime); \n if len(lwctime)==len(timtc):\n if (lwctime.__array__()==timtc).all()==True: lwc=lwc[taix]\n else: flwc=interpolate.interp1d(lwctime,lwc,kind='linear'); lwc=flwc(usedtime)\n # integrating\n dalt=np.diff(alt);\n lwc=lwc[1:];\n tc=tc[1:];\n WA=abs(sum(tc*lwc*dalt))/(samac.lwp(CL)[scan][0]) # if inst conc is cm-3 (cm-3 lwc*meters / lwc*meters = cm-3)\n return WA","def get_obstList(self,X,Y,Z):\n #Pipe_1\n\tpipe_1 = np.array(np.where((X - 1)**2 + (Y - 4)**2 >= 0.5**2)).flatten()\n\tpipe_1_stop_z = np.array(np.where(Z <= 3.0)).flatten()\n\tpipe_1_stop_y = np.array(np.where(Y >= 3.25)).flatten()\n\tpipe_1_stop = np.intersect1d(pipe_1_stop_z[:],pipe_1_stop_y[:])\n\tpipe_1 = np.intersect1d(pipe_1[:],pipe_1_stop[:])\n\n\t#Turn_1\n\tturn_1 = np.array(np.where((0.75 - np.sqrt((Y - 3.25)**2 + (Z -3)**2))**2 + (X - 1)**2 >= 0.5**2)).flatten()\n\tturn_1_stop_z = np.array(np.where(Z >= 3.0)).flatten()\n\tturn_1_stop_y = np.array(np.where(Y>= 1.75)).flatten()\n\tturn_1_stop = np.intersect1d(turn_1_stop_z[:],turn_1_stop_y[:])\n\tturn_1 = np.intersect1d(turn_1[:],turn_1_stop[:])\n\n\t#Pipe_2\n\tpipe_2 = np.array(np.where((X - 1)**2 + (Y - 2.5)**2 >= 0.5**2)).flatten()\n\tpipe_2_start_z = np.array(np.where(Z >= 1.5)).flatten()\n\tpipe_2_start_y_up = np.array(np.where(Y <= 3.25)).flatten()\n\tpipe_2_start_y_down = np.array(np.where(Y >= 1.75)).flatten()\n\tpipe_2_start_y = np.intersect1d(pipe_2_start_y_up[:],pipe_2_start_y_down[:])\t\n\tpipe_2_start = np.intersect1d(pipe_2_start_z[:],pipe_2_start_y[:])\n\tpipe_2 = np.intersect1d(pipe_2[:],pipe_2_start[:])\n\tpipe_2_stop_z = np.array(np.where(Z <= 3.0)).flatten()\n\tpipe_2_stop_y = np.array(np.where(Y <= 3.25)).flatten()\n\tpipe_2_stop = np.intersect1d(pipe_2_stop_z[:],pipe_2_stop_y[:])\n\tpipe_2 = np.intersect1d(pipe_2[:],pipe_2_stop[:])\n\n\t#Turn_2\n\tturn_2 = np.array(np.where((0.75 - np.sqrt((Y - 1.75)**2 + (Z -1.5)**2))**2 + (X - 1)**2 >= 0.5**2)).flatten()\n\tturn_2_stop_z = np.array(np.where(Z <= 1.5)).flatten()\n\tturn_2_stop_y = np.array(np.where(Y <= 3.25)).flatten()\n\tturn_2_stop = np.intersect1d(turn_2_stop_z[:],turn_2_stop_y[:])\n\tturn_2 = np.intersect1d(turn_2[:],turn_2_stop[:])\n\t\n\t#Pipe_3\n\tpipe_3 = np.array(np.where((X - 1)**2 + (Y - 1.0)**2 >= 0.5**2)).flatten()\n\tpipe_3_start_z = np.array(np.where(Z >= 1.5)).flatten()\n\tpipe_3_start_y = np.array(np.where(Y <= 1.75)).flatten()\n\tpipe_3_start = np.intersect1d(pipe_3_start_z[:],pipe_3_start_y[:])\n\tpipe_3 = np.intersect1d(pipe_3[:],pipe_3_start[:])\t\n\n\t#Put the pieces together\n\n\tpipe = np.union1d(pipe_1[:],turn_1[:])\n\tpipe = np.union1d(pipe[:],pipe_2[:])\n\tpipe = np.union1d(pipe[:],turn_2[:])\t\n\tpipe = np.union1d(pipe[:],pipe_3[:])\n\n\tobst_list = pipe[:]\n\n \n return list(obst_list[:])","def hammer_points(neighbors = 3):\n tgtPts = cmds.ls(sl=True, fl=True)\n#---------------- add in soft selection? \n if not tgtPts:\n cmds.warning(\"Select one or more cvs\")\n return\n\n for tgtPt in tgtPts:\n\n #tgtPtPos = cmds.pointPosition(tgtPt)\n \n tgtNum = int(tgtPt.partition(\"[\")[2].rpartition(\"]\")[0])\n #tgtBase = tgtPt.partition(\"[\")[0]\n crv = tgtPts[0].partition(\".\")[0]\n \n ptPosListX = []\n ptPosListY = []\n ptPosListZ = []\n \n count = 0\n \n for x in range(-neighbors, neighbors+1):\n \n count += abs(x)\n \n if x != 0:\n origPt = \"{0}.cv[{1}]\".format(crv, tgtNum + x)\n origPtPos = cmds.pointPosition(origPt)\n \n for a in range(abs(x)):\n ptPosListX.append(origPtPos[0])\n ptPosListY.append(origPtPos[1])\n ptPosListZ.append(origPtPos[2])\n \n avgX = sum(ptPosListX)/(len(ptPosListX))\n avgY = sum(ptPosListY)/(len(ptPosListY))\n avgZ = sum(ptPosListZ)/(len(ptPosListZ))\n \n newPos = [avgX, avgY, avgZ]\n \n cmds.xform(tgtPt, ws=True, t=newPos)","def __get_points_lips(self, lips_points):\n uol = []\n uil = []\n lol = []\n lil = []\n for i in range(0, 14, 2):\n uol.append([int(lips_points[i]), int(lips_points[i + 1])])\n for i in range(12, 24, 2):\n lol.append([int(lips_points[i]), int(lips_points[i + 1])])\n lol.append([int(lips_points[0]), int(lips_points[1])])\n for i in range(24, 34, 2):\n uil.append([int(lips_points[i]), int(lips_points[i + 1])])\n for i in range(32, 40, 2):\n lil.append([int(lips_points[i]), int(lips_points[i + 1])])\n lil.append([int(lips_points[24]), int(lips_points[25])])\n return uol, uil, lol, lil","def stop_existing_connections_to_part(session, handling, conn_list, at_date):\n stop_at = int(at_date.gps)\n data = []\n\n for conn in conn_list:\n part = handling.get_dossier(conn[0], conn[1], at_date=at_date, exact_match=True)\n if len(part):\n key = cm_utils.make_part_key(conn[0], conn[1])\n x = None\n if conn[2].lower() in part[key].input_ports:\n x = part[key].connections.down[conn[2].upper()]\n elif conn[2].lower() in part[key].output_ports:\n x = part[key].connections.up[conn[2].upper()]\n if x is not None:\n print(\"Stopping connection {} at {}\".format(x, str(at_date)))\n stopping = [\n x.upstream_part,\n x.up_part_rev,\n x.downstream_part,\n x.down_part_rev,\n x.upstream_output_port,\n x.downstream_input_port,\n x.start_gpstime,\n \"stop_gpstime\",\n stop_at,\n ]\n data.append(stopping)\n with mc.MCSessionWrapper(session=session) as session:\n update_connection(session, data, False)","def create_conserved_motif_list(dyn_id,gpcr_pdb,gpcr_aa,j,my_pos,motifs,multiple_chains,chain_name):\n my_pos_bw=my_pos.split(\"x\")[0]\n (my_aa,chain)=gpcr_aa[my_pos]\n add_chain_name=\"\"\n if multiple_chains:\n add_chain_name=\":\"+chain_name \n while j < len(motifs):\n cons_pos = motifs[j][1]\n cons_pos_bw=cons_pos[1:]\n cons_aa=cons_pos[0]\n if my_pos_bw==cons_pos_bw:\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\n if pos_range:\n motifs[j][2]=True\n motifs[j][3]=pos_range + add_chain_name\n if cons_aa != \"x\" and my_aa != cons_aa:\n motifs[j][1]+=my_aa\n j+=1","def getLCLimits(*args):\n return args[0].Limit.LCLimit.lc_limit","def get_obstList(self,X,Y,Z):\n #Pipe in - find all points exterior of large pipe\n\tpipe_in = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_in/2)**2)).flatten()\n\tpipe_in_stop = np.array(np.where(Z <= 4)).flatten()\n\tpipe_in = np.intersect1d(pipe_in[:],pipe_in_stop[:])\n\n\t#Contraction - find all points exterior of contraction\n\tr_cone = self.diam_out\n\th_cone = self.diam_out\t\n\tcontraction = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (r_cone/h_cone)**2*(Z - (4 + h_cone))**2)).flatten()\n\tcontraction_start = np.array(np.where(Z >= 4)).flatten()\n\tcontraction_stop = np.array(np.where(Z <= 4 + .5*self.diam_out)).flatten()\n\tcontraction = np.intersect1d(contraction[:],contraction_start[:])\n\tcontraction = np.intersect1d(contraction[:],contraction_stop[:])\n\n\t#Pipe out - final all points exterior of smaller pipe\n\tpipe_out = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_out/2)**2)).flatten()\n\tpipe_out_start = np.array(np.where(Z >= 4 + .5*self.diam_out)).flatten()\n\tpipe_out = np.intersect1d(pipe_out[:],pipe_out_start[:])\n\n\n\t#Put the pieces together\n\n\t#pipe = pipe_in[:]\n\tpipe = np.union1d(contraction[:],pipe_in[:])\n\tpipe = np.union1d(pipe[:],pipe_out[:])\n\n\tobst_list = pipe[:]\n\n \n return list(obst_list[:])","def LimitPointsBetweenSubContourNodes(scList, numInteriorPointsDict, interpolate=True):\n limIntPtsFunc = (\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\n )\n for sc in scList:\n sc.points = limIntPtsFunc(sc.points, numInteriorPointsDict[tuple(sc.values)])","def allcJPDs(net,cond_node,cond_states):\r\n \r\n onodes = net.Outputnodes()\r\n onodes = sorted(onodes)\r\n combinations = [i for i in itertools.combinations(onodes,2)]\r\n JPDdatas = [] \r\n progress = 0\r\n for cs in cond_states:\r\n JPDdata = []\r\n for c in combinations:\r\n print 'Progress: ' +str(int(100*float(progress)/float(len(combinations)*len(cond_states))))+ ' %'\r\n priorA = getCondPrior(net,c[0],cond_node,cs)\r\n print priorA\r\n priorB = getCondPrior(net,c[1],cond_node,cs) \r\n print priorB\r\n JPD = cJPD(net,c,cond_node,cs)\r\n cov = Covariance (priorA,priorB,JPD)\r\n cor = Correlation (priorA,priorB,cov) \r\n JPDdata.append([c[0],c[1],JPD,cov,cor])\r\n progress+=1\r\n JPDdatas.append(JPDdata)\r\n return JPDdatas","def fixed_points(self, epsilon = 0.000001):\n # (a b) (z) = (Lz)\n # (c d) (1) ( L) \n\n # az + b = c z^2 + d z\n # 0 = c z^2 + (d-a)z - b\n # z = ((a-d) \\pm sqrt( (a-d)^2 + 4 bc )) / 2c\n\n a, b, c, d = self\n\n assert abs(c) > epsilon\n zp = ((a - d) + sqrt( (a - d)**2 + 4*b*c)) / 2*c\n zm = ((a - d) - sqrt( (a - d)**2 + 4*b*c)) / 2*c\n Lp = c*zp + d\n Lm = c*zm + d\n if abs(Lp) < abs(Lm):\n Ls = [Lp, Lm]\n out = [zp, zm]\n else:\n Ls = [Lm, Lp]\n out = [zm, zp] \n assert abs(Ls[0]) < 1 - epsilon and 1 + epsilon < abs(Ls[1])\n return [CP1((z,1)) for z in out]","def extract_labels_cps(scene: \"Scenemaker\") -> List[Tuple[int, np.ndarray]]:\r\n objects = utils.select_collection(scene.target_collection)\r\n boxes_list = []\r\n\r\n for obj in objects:\r\n objclass = obj.name.split(\".\")[0]\r\n cornermatrix = np.empty((8, 3))\r\n for j, corner in enumerate(obj.bound_box):\r\n cornermatrix[j] = corner\r\n\r\n boxes_list.append((scene.name2num[objclass], cornermatrix))\r\n\r\n return boxes_list","def _get_points_nd(clicks_lists, net_clicks_limit):\n total_clicks = []\n num_pos_clicks = [sum(x.is_positive for x in clicks_list) for clicks_list in clicks_lists]\n num_neg_clicks = [len(clicks_list) - num_pos for clicks_list, num_pos in zip(clicks_lists, num_pos_clicks)]\n num_max_points = max(num_pos_clicks + num_neg_clicks)\n\n if net_clicks_limit is not None:\n num_max_points = min(net_clicks_limit, num_max_points)\n num_max_points = max(1, num_max_points)\n\n for clicks_list in clicks_lists:\n clicks_list = clicks_list[:net_clicks_limit]\n pos_clicks = [click.coords for click in clicks_list if click.is_positive]\n pos_clicks = pos_clicks + (num_max_points - len(pos_clicks)) * [(-1, -1)]\n\n neg_clicks = [click.coords for click in clicks_list if not click.is_positive]\n neg_clicks = neg_clicks + (num_max_points - len(neg_clicks)) * [(-1, -1)]\n total_clicks.append(pos_clicks + neg_clicks)\n\n return np.array(total_clicks)","def getNodeList(x, y, type):\n\t\n\tif type == 0:\n\t\treturn pointListForGrass(x, y)\n\telif type == 1:\n\t\treturn pointListForHorizontal(x, y)\n\telif type == 2:\n\t\treturn pointListForVirticle(x, y)\n\telif type == 3:\n\t\treturn pointListForT(x, y, type)\n\telif type == 4:\n\t\treturn pointListForT(x, y, type)\n\telif type == 5:\n\t\treturn pointListForT(x, y, type)\n\telif type == 6:\n\t\treturn pointListForT(x, y, type)\n\telif type == 7:\n\t\treturn pointListForPlus(x, y)\n\telif type == 8:\n\t\treturn pointListForCurve(x, y, type)\n\telif type == 9:\n\t\treturn pointListForCurve(x, y, type)\n\telif type == 10:\n\t\treturn pointListForCurve(x, y, type)\n\telif type == 11:\n\t\treturn pointListForCurve(x, y, type)\n\telse:\n\t\treturn []","def add_pconn(self):\n self.use_pconn= True\n self.pconn = []\n for i,c in enumerate(self.conn):\n atoms_pconn = []\n atoms_image = []\n for ji, j in enumerate(c):\n # If an atom or vertex is connected to another one multiple times (in an image), this\n # will be visible in the self.conn attribute, where the same neighbour will be listed\n # multiple times.\n # Sometimes, the distances are a bit different from each other, and in this case, we\n # have to increase the threshold, until the get_distvec function will find all imgis.\n n_conns = c.count(j)\n t = 0.01\n while True:\n d,r,imgi = self.get_distvec(i,j,thresh=t)\n t += 0.01\n if n_conns == len(imgi):\n break\n if len(imgi) == 1:\n # only one neighbor .. all is fine\n atoms_pconn.append(images[imgi[0]])\n atoms_image.append(imgi[0])\n else:\n # we need to assign an image to each connection\n # if an atom is connected to another atom twice this means it must be another\n # image\n for ii in imgi:\n # test if this image is not used for this atom .. then we can use it\n if atoms_image.count(ii)==0:\n atoms_image.append(ii)\n atoms_pconn.append(images[ii])\n else:\n # ok, we have this image already\n use_it = True\n #print(c, \"=>\", j)\n #print(atoms_image)\n for k, iii in enumerate(atoms_image):\n #print('k',k)\n if (iii == ii) and (c[k] == j): use_it=False\n if use_it:\n atoms_image.append(ii)\n atoms_pconn.append(images[ii])\n self.pconn.append(atoms_pconn)\n #if len(atoms_pconn) != len(c): print(\"AOSUHDAPUFHPOUFHPWOUFHPOUDHSPUODHASIUDHAUSIDHSD\")\n return\n\n # 'na',lower(label),xyz,i,j)","def displacements_recursive(config, pointInds_toUse, pointInds_tracked, pointInds_tracked_tuple, positions_recursive,\n pts_spaced, color_tuples, relaxation_factor, session):\n\n ## Main loop to pull out displacements in each video\n ind_concat = 0\n fps = 0\n tic_fps = time.time()\n tic_all = time.time()\n\n optic = config['Optic']\n video = config['Video']\n\n vidNums_toUse = optic['vidNums_toUse']\n showVideo_pref = optic['showVideo_pref']\n fps_counterPeriod = video['fps_counterPeriod']\n printFPS_pref = video['printFPS_pref']\n remote = config['General']['remote']\n save_vid = video['save_demo']\n\n\n Fs = video['Fs']\n vid_width = video['width']\n vid_height = video['height']\n test_len = video['demo_len']\n save_pathFull = str(Path(config['Paths']['viz']) / 'optic_test.avi')\n\n numVids = session['num_vids']\n path_vid_allFiles = session['videos']\n \n lk_names = [key for key in optic['lk'].keys()]\n lk_params = {k: (tuple(optic['lk'][k]) if type(optic['lk'][k]) is list else optic['lk'][k]) \\\n for k in lk_names}\n \n\n # Define the codec and create VideoWriter object\n if showVideo_pref and (save_vid or remote):\n fourcc = cv2.VideoWriter_fourcc(*'MJPG')\n print(f'saving to file {save_pathFull}')\n out = cv2.VideoWriter(save_pathFull, fourcc, Fs, (np.int64(vid_width), np.int64(vid_height)))\n else:\n out = None\n\n vid_lens = []\n pointInds_old = pointInds_toUse\n for vidNum_iter in vidNums_toUse:\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\n # metadata = vid.get_meta_data()\n\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\n numFrames_rough = int(video.get(\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\n\n frameToSet = 0\n frame = vid.get_data(0) # Get a single frame to use as the first 'previous frame' in calculating optic flow\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n old_frame = new_frame_gray\n\n print(f'\\n Calculating displacement field: video # {vidNum_iter+1}/{numVids}')\n for iter_frame , new_frame in enumerate(tqdm(vid, total=numFrames_rough)):\n\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\n\n ##calculate optical flow\n # pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None, **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, np.single(pointInds_old),\n None,\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\n\n # diff = np.squeeze((pointInds_new - pointInds_old)) # this is the important variable. Simply the difference in the estimate\n \n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\n \n # pointInds_tracked = pointInds_tracked + (pointInds_new - pointInds_toUse) # calculate integrated position\n # pointInds_tracked = pointInds_tracked + diff[:,None,:] # calculate integrated position\n pointInds_tracked = pointInds_new - (pointInds_new -pointInds_toUse)*relaxation_factor # multiplied constant is the relaxation term\n\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter) \n if ind_concat ==0:\n positions_recursive[:,:,ind_concat] = np.zeros((pts_spaced.shape[0] ,2))\n else:\n # displacements[:,:,ind_concat] = np.single(np.squeeze((pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\n positions_recursive[:,:,ind_concat] = np.squeeze((pointInds_tracked)) # this is the important variable. Simply the difference in the estimate\n\n pointInds_old = pointInds_tracked\n\n ## below is just for visualization. Nothing calculated is maintained\n if showVideo_pref:\n\n pointInds = [pointInds_tracked, pointInds_tracked_tuple]\n counters = [iter_frame, vidNum_iter, ind_concat, fps]\n if (remote and iter_frame < test_len) or not remote:\n videos.visualize_progress(config, session, new_frame, pointInds, color_tuples, counters, out)\n\n if (save_vid or remote) and iter_frame == test_len:\n out.release()\n\n k = cv2.waitKey(1) & 0xff\n if k == 27: break\n\n ind_concat = ind_concat + 1\n\n if ind_concat % fps_counterPeriod == 0:\n elapsed = time.time() - tic_fps\n fps = fps_counterPeriod / elapsed\n if printFPS_pref:\n print(fps)\n tic_fps = time.time()\n vid_lens.append(iter_frame+1)\n\n ## Calculate how long calculation took\n elapsed = time.time() - tic_all\n helpers.print_time('video time elapsed:', elapsed)\n print(f'Capture rate: {round(ind_concat / elapsed, 3)} fps')\n\n numFrames_total = ind_concat\n cv2.destroyAllWindows()\n\n positions_recursive = positions_recursive[:, :, ~np.isnan(positions_recursive[0, 0, :])]\n displacements = np.zeros_like(positions_recursive)\n displacements[:,:,1:] = np.diff(positions_recursive , axis=2)\n\n return displacements, numFrames_total , positions_recursive, vid_lens","def get_obstList(self,X,Y,Z):\n #Pipe in - find all points exterior of small\n\tpipe_in = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_in/2)**2)).flatten()\n\tpipe_in_stop = np.array(np.where(Z <= 3 + 0.5*(self.diam_out - self.diam_in))).flatten()\n\tpipe_in = np.intersect1d(pipe_in[:],pipe_in_stop[:])\n\n\t#Expansion - find all points exterior of expansion\n\tr_cone = self.diam_in\n\th_cone = self.diam_in\t\n\texpansion = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (r_cone/h_cone)**2*(Z - 3)**2)).flatten()\n\texpansion_start = np.array(np.where(Z >= 3 + 0.5*(self.diam_out - self.diam_in)))\n\t#expansion_stop = np.array(np.where(Z <= 4)).flatten()\n\texpansion = np.intersect1d(expansion[:],expansion_start[:])\n\t#expansion = np.intersect1d(expansion[:],expansion_stop[:])\n\n\t#Pipe out - final all points exterior of smaller pipe\n\tpipe_out = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_out/2)**2)).flatten()\n\tpipe_out_start = np.array(np.where(Z >= 3 + 0.5*(self.diam_in - self.diam_out))).flatten()\n\tpipe_out = np.intersect1d(pipe_out[:],pipe_out_start[:])\n\n\n\t#Put the pieces together\n\n\tpipe = expansion[:]\n\tpipe = np.union1d(expansion[:],pipe_in[:])\n\tpipe = np.union1d(pipe[:],pipe_out[:])\n\n\tobst_list = pipe[:]\n\n \n return list(obst_list[:])","def initialize_lattice_cpa(risk_slim_settings, warmstart_settings, cplex_parameters, compute_loss_real, compute_loss_cut_real, bounds = None):\n warmstart_settings = dict(warmstart_settings)\n risk_slim_settings = dict(risk_slim_settings)\n #get_objval\n #check_feasible\n\n\n C_0 = np.array(risk_slim_settings['coef_set'].C_0j)\n L0_reg_ind = np.isnan(C_0)\n C_0[L0_reg_ind] = risk_slim_settings['C_0']\n C_0_nnz = C_0[L0_reg_ind]\n\n if bounds is None:\n bounds = {\n 'objval_min': 0.0,\n 'objval_max': CPX_INFINITY,\n 'loss_min': 0.0,\n 'loss_max': CPX_INFINITY,\n 'L0_min': 0,\n 'L0_max': risk_slim_settings['L0_max'],\n }\n warmstart_settings['type'] = 'cvx'\n risk_slim_settings.update(bounds)\n risk_slim_settings['relax_integer_variables'] = True\n\n #create RiskSLIM LP\n risk_slim_lp, risk_slim_lp_indices = create_risk_slim(risk_slim_settings)\n risk_slim_lp = set_cplex_mip_parameters(risk_slim_lp, cplex_parameters, display_cplex_progress = warmstart_settings['display_cplex_progress'])\n\n # solve risk_slim_lp LP using standard CPA\n cpa_stats, initial_cuts, cts_pool = cutting_plane_algorithm(risk_slim_lp,\n risk_slim_lp_indices,\n warmstart_settings,\n compute_loss_real,\n compute_loss_cut_real)\n\n # update bounds\n initial_bounds = chained_updates(bounds, C_0_nnz, new_objval_at_relaxation=cpa_stats['lowerbound'])\n initial_pool = SolutionPool(cts_pool.P)\n\n #remove redundant solutions, remove infeasible solutions, order solutions by objective value of RiskSLIMLP\n cts_pool = cts_pool.distinct().removeInfeasible(check_feasible).sort()\n\n if warmstart_settings['use_sequential_rounding']:\n initial_pool, _, _ = sequential_round_solution_pool(cts_pool,\n max_runtime=warmstart_settings['sequential_rounding_max_runtime'],\n max_solutions=warmstart_settings['sequential_rounding_max_solutions'],\n objval_cutoff=bounds['objval_max'],\n L0_min=bounds['L0_min'],\n L0_max=bounds['L0_max'])\n\n initial_pool = initial_pool.distinct().sort()\n bounds = chained_updates(bounds, C_0_nnz, new_objval_at_feasible=np.min(initial_pool.objvals))\n else:\n initial_pool, _, _ = round_solution_pool(cts_pool, constraints)\n\n initial_pool.computeObjvals(get_objval)\n if warmstart_settings['polishing_after'] and len(initial_pool) > 0:\n initial_pool, _, _ = discrete_descent_solution_pool(initial_pool,\n warmstart_settings['polishing_max_runtime'],\n warmstart_settings['polishing_max_solutions'])\n\n initial_pool = initial_pool.removeInfeasible(check_feasible).distinct().sort()\n\n if len(initial_pool) > 0:\n initial_bounds = chained_updates(bounds, C_0_nnz, new_objval_at_feasible=np.min(initial_pool.objvals))\n\n return initial_pool, initial_cuts, initial_pool","def add_ixp_links(self, ixps, c2p_factor, ixp_mode=0):\n\n print \"-> Get AS Connectivity\"\n c2p_connections = self.get_as_connectivity_fast(ixps)\n\n # loop through all ixp connections\n print \"-> Start Adding the Links\"\n i = 0\n\n pairs = itertools.combinations(ixps.keys(), 2)\n\n num_p2p_links = 0\n num_c2p_links = 0\n\n for pair in pairs:\n i += 1\n if i % 1000000 == 0:\n print \"--> Processed \" + str(i) + \" IXP links\"\n\n participant1 = int(pair[0])\n participant2 = int(pair[1])\n\n # check if those nodes actually exist\n if self.has_node(participant1) and self.has_node(participant2):\n p1_ixps = set(ixps[pair[0]])\n p2_ixps = set(ixps[pair[1]])\n ixp_intersect = p1_ixps.intersection(p2_ixps)\n if len(ixp_intersect) >= 1:\n if self.has_edge(participant1, participant2):\n self[participant1][participant2]['ixps'] = list(ixp_intersect)\n else:\n if participant1 in c2p_connections[participant2]:\n num_c2p_links += 1\n self.add_edge(participant2, participant1, relationship=-1,\n ixps=list(ixp_intersect), as1=participant1, as2=participant2)\n elif participant2 in c2p_connections[participant1]:\n num_c2p_links += 1\n self.add_edge(participant1, participant2, relationship=-1,\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\n else:\n # mode 0: by default add a p2p link, if there is no c2p connection between the two\n if ixp_mode == 0:\n num_p2p_links += 1\n self.add_edge(participant1, participant2, relationship=0,\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\n # mode 1: add by default a p2p link, if there is a c2p+ or the number of neighbors\n # differ in size more than X times\n else:\n num_neighbors_1 = float(nx.degree(self, participant1))\n num_neighbors_2 = float(nx.degree(self, participant2))\n\n if num_neighbors_1 == 0 or num_neighbors_2 == 0:\n print \"\\nERROR\"\n print \"Node \" + str(participant1) + \" has \" + str(num_neighbors_1) + \" neighbors\"\n print \"Node \" + str(participant2) + \" has \" + str(num_neighbors_2) + \" neighbors\"\n continue\n\n if num_neighbors_1/num_neighbors_2 >= c2p_factor:\n num_c2p_links += 1\n self.add_edge(participant1, participant2, relationship=-1,\n ixps=list(ixp_intersect), as1=participant1, as2=participant2)\n # update connection data structure\n c2p_connections[participant2] |= c2p_connections[participant1]\n c2p_connections[participant2].add(participant1)\n elif num_neighbors_2/num_neighbors_1 >= c2p_factor:\n num_c2p_links += 1\n self.add_edge(participant1, participant2, relationship=-1,\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\n # update connection data structure\n c2p_connections[participant1] |= c2p_connections[participant2]\n c2p_connections[participant1].add(participant2)\n else:\n num_p2p_links += 1\n self.add_edge(participant1, participant2, relationship=0,\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\n\n print \"--> Added a total of \" + str(num_c2p_links + num_p2p_links) + \" IXP links of which \" + \\\n str(num_c2p_links) + \" were c2p and \" + str(num_p2p_links) + \" were p2p\"","def power_points():\n next_reading = power_readings()\n stretch = []\n\n def next():\n nonlocal stretch, next_reading\n stretch.append(next_reading())\n if len(stretch) > XMAX + 1:\n stretch.pop(0)\n x = XMAX + 1 - len(stretch)\n points = []\n for y in stretch:\n points.append((x, y))\n points.append((x, 0))\n x += 1\n return points\n\n return next","def create_conserved_motif_list_otherclass(gpcr_pdb,gpcr_aa,j,my_pos,motifs,multiple_chains,chain_name):\n my_pos_bw=my_pos.split(\"x\")[0]\n (my_aa,chain)=gpcr_aa[my_pos]\n add_chain_name=\"\"\n if multiple_chains:\n add_chain_name=\":\"+chain_name \n while j < len(motifs):\n cons_pos_bw = motifs[j][4]\n if my_pos_bw==cons_pos_bw:\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\n if pos_range:\n motifs[j][2]=True\n motifs[j][3]=pos_range + add_chain_name\n j+=1","def get_ctrl_points(self) -> list[tuple]:\n self.calculate_d_vals()\n self.calculate_psi_vals()\n self.calculate_theta_vals()\n self.calculate_phi_vals()\n self.show_debug_msg()\n self.ctrl_pts = self.calculate_ctrl_pts()\n return self.ctrl_pts","def getAndSortFiducialPoints(self, center):\r\n # self.__registrationStatus.setText('Registration processing...')\r\n # pNode = self.parameterNode()\r\n # fixedAnnotationList = slicer.mrmlScene.GetNodeByID(pNode.GetParameter('fixedLandmarksListID'))\r\n # if fixedAnnotationList != None:\r\n # fixedAnnotationList.RemoveAllChildrenNodes()\r\n markerCenters = center\r\n nbCenter = len(center)\r\n for k in range(nbCenter):\r\n point = [0]\r\n for i in range(nbCenter):\r\n U,V,W = 0,0,0\r\n for j in range(nbCenter):\r\n d = 0\r\n if i != j and markerCenters[i]!=(0,0,0):\r\n d2 = (markerCenters[i][0]-markerCenters[j][0])**2+(markerCenters[i][1]-markerCenters[j][1])**2+(markerCenters[i][2]-markerCenters[j][2])**2\r\n d = d2**0.5\r\n # print markerCenters[i],markerCenters[j]\r\n #print d\r\n if d >=45 and d<=53:\r\n U += 1\r\n elif d >53 and d<60:\r\n V +=1\r\n elif d >=70 and d<80:\r\n W +=1\r\n #print U,V,W\r\n if U+V+W>=3:\r\n #print markerCenters[i]\r\n point.extend([i])\r\n point.remove(0)\r\n minX = [999,999,999,999]\r\n maxX = [-999,-999,-999,-999]\r\n sorted = [[0,0,0] for l in range(4)]\r\n sortedConverted = [[0,0,0] for l in range(4)]\r\n for i in range(2):\r\n for k in point:\r\n if markerCenters[k][0]<= minX[0]:\r\n minX[0] = markerCenters[k][0]\r\n minX[1] = k\r\n elif markerCenters[k][0]<= minX[2]:\r\n minX[2] = markerCenters[k][0]\r\n minX[3] = k\r\n if markerCenters[k][0]>= maxX[0]:\r\n maxX[0] = markerCenters[k][0]\r\n maxX[1] = k\r\n elif markerCenters[k][0]>= maxX[2]:\r\n maxX[2] = markerCenters[k][0]\r\n maxX[3] = k\r\n if markerCenters[minX[1]][1] < markerCenters[minX[3]][1]:\r\n sorted[0] = minX[1]\r\n sorted[1] = minX[3]\r\n else:\r\n sorted[0] = minX[3]\r\n sorted[1] = minX[1]\r\n if markerCenters[maxX[1]][1]>markerCenters[maxX[3]][1]:\r\n sorted[2] = maxX[1]\r\n sorted[3] = maxX[3]\r\n else:\r\n sorted[2] = maxX[3]\r\n sorted[3] = maxX[1]\r\n sorted2 = [0,0,0,0]\r\n if 1:#self.horizontalTemplate.isChecked():\r\n sorted2[0]=sorted[2]\r\n sorted2[2]=sorted[0]\r\n sorted2[1]=sorted[3]\r\n sorted2[3]=sorted[1]\r\n else:\r\n sorted2[0]=sorted[3]\r\n sorted2[2]=sorted[1]\r\n sorted2[1]=sorted[0]\r\n sorted2[3]=sorted[2]\r\n # logic = slicer.modules.annotations.logic()\r\n # logic.SetActiveHierarchyNodeID(pNode.GetParameter('fixedLandmarksListID'))\r\n # if pNode.GetParameter(\"Template\")=='4points':\r\n # nbPoints=4\r\n # elif pNode.GetParameter(\"Template\")=='3pointsCorners':\r\n # nbPoints=3\r\n l = slicer.modules.annotations.logic()\r\n l.SetActiveHierarchyNodeID(slicer.util.getNode('Fiducial List_fixed').GetID())\r\n for k in range(4) :\r\n fiducial = slicer.mrmlScene.CreateNodeByClass('vtkMRMLAnnotationFiducialNode')\r\n fiducial.SetReferenceCount(fiducial.GetReferenceCount()-1)\r\n fiducial.SetFiducialCoordinates(markerCenters[sorted2[k]])\r\n fiducial.SetName(str(k))\r\n fiducial.Initialize(slicer.mrmlScene)\r\n\r\n sRed = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNodeRed\")\r\n if sRed ==None :\r\n sRed = slicer.mrmlScene.GetNodeByID(\"vtkMRMLSliceNode1\")\r\n # sRed.SetSliceVisible(1)\r\n m= sRed.GetSliceToRAS()\r\n m.SetElement(0,3,sortedConverted[3][0])\r\n m.SetElement(1,3,sortedConverted[3][1])\r\n m.SetElement(2,3,sortedConverted[3][2])\r\n sRed.Modified()\r\n return sorted2","def approximate_circuit(\n self,\n circuit: Circuit,\n psols: list[list[tuple[Circuit, float]]],\n pts: list[CircuitPoint],\n ) -> list[Circuit]:\n num_blocks = len(pts)\n approx_threshold = self.approx_threshold or num_blocks / 10\n bounds = [[0, len(psol_list)] for psol_list in psols]\n\n psol_configs: list[list[int]] = []\n approx_circuits: list[Circuit] = []\n dists = [[psol[1] for psol in psol_list] for psol_list in psols]\n utrys = [\n [psol[0].get_unitary() for psol in psol_list]\n for psol_list in psols\n ]\n n_cxs = [\n [psol[0].count(CNOTGate()) for psol in psol_list]\n for psol_list in psols\n ]\n n_cx = sum(op.gate._circuit.count(CNOTGate()) for op in circuit) # type: ignore # noqa\n\n for _ in range(self.sample_size):\n x = []\n f = float('inf')\n for _ in range(3):\n result = dual_annealing(\n annealing_objective,\n args=(\n approx_threshold,\n n_cx,\n psol_configs,\n dists,\n utrys,\n n_cxs,\n self.pert,\n self.weit,\n ),\n x0=[0] * num_blocks,\n bounds=bounds,\n seed=int(time.time()),\n initial_temp=5e4,\n maxiter=10000,\n )\n\n if result.fun < f:\n x = result.x\n f = result.fun\n\n blocks = [int(x_e) for x_e in x]\n\n if blocks in psol_configs:\n _logger.debug('Generated a repeat approximate circuit.')\n break\n\n approx_dist = sum(\n psols[b][ind][1]\n for b, ind in enumerate(blocks)\n )\n\n if approx_dist > approx_threshold:\n _logger.debug('Approximate circuit has high distance.')\n break\n\n psol_configs.append(blocks)\n approx_circuit = self.assemble_circuit(circuit, blocks, psols, pts)\n approx_circuit.unfold_all()\n approx_circuits.append(approx_circuit)\n _logger.info(\n 'Generated approximate circuit with approximate distance:'\n f' {approx_dist}.',\n )\n _logger.info(\n f'Approximate circuit has {approx_circuit.count(CNOTGate())}'\n ' cnots.',\n )\n\n return approx_circuits","def build_csls_subgraphs(self):\n # Graph for calculating only score\n scores_s2t = self.build_eval_graph(\n \"ScoreS2T\", self.src_ten, self.tgt_ten, en_knn=False, en_mean=False\n )\n scores_t2s = self.build_eval_graph(\n \"ScoreT2S\", self.tgt_ten, self.src_ten, en_knn=False, en_mean=False\n )\n # Graphs for calculating average between source and target\n avg1_s2t = self.build_eval_graph(\"Avg1\", self.src_ten, self.tgt_ten, knn=10)\n avg2_s2t = self.build_eval_graph(\"Avg2\", self.tgt_ten, self.src_ten, knn=10)\n # Graph for selecting top 100 elements\n top100_matches = tf.nn.top_k(self.score_ph, 100)\n # Graph for selecting top 2 elements\n top2_matches = tf.nn.top_k(self.score_ph, 2)\n # Graph for calculating similarity\n csls_mean_score = self.build_sim_graph(\"SimGraph\")\n\n # Dictionary\n csls_graphs = {\n \"ScoreGraph\": scores_s2t,\n \"ScoreG_T2S\": scores_t2s,\n \"Avg1S2T\": avg1_s2t,\n \"Avg2S2T\": avg2_s2t,\n \"Top100\": top100_matches,\n \"Top2\": top2_matches,\n \"CSLS_Criteria\": csls_mean_score,\n }\n return csls_graphs","def auxmax_cc_piece(x,k_ind,m_ind):\n \n # Adding new linear function as a last function:\n # The first line. If k_ind = nomax-1, this is a new line, otherwise an old one.\n line_start=cfg.nfea*sum(cfg.jk[i] for i in range(k_ind))\n if cfg.jk[k_ind]==1 and k_ind==cfg.nomax-1: #\n print \"hihu0\"\n f_cc=np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\n return f_cc\n else:\n print \"hihu1\",line_start\n f_cc=np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\n \n cfg.min_line[k_ind,m_ind] = 0 # a global variable to save the smallest value.\n \n # Next lines\n line_start += cfg.nfea\n for j in range(1,cfg.jk[k_ind]-1): # Everything but the first and last.\n \n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\n \n # Minimum of lines\n if f_tmp <= f_cc:\n f_cc = f_tmp\n cfg.min_line[k_ind,m_ind] = j\n line_start += cfg.nfea\n \n \n # The last line.\n if k_ind==cfg.nomax-1:\n \n f_tmp = np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\n else: \n \n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\n \n # Minimum of lines\n if f_tmp <= f_cc:\n f_cc = f_tmp\n cfg.min_line[k_ind,m_ind] = cfg.jk[k_ind]-1 \n \n \n return f_cc","def create_conserved_pos_list_otherclass(gpcr_pdb,gpcr_aa, i,my_pos, cons_pos_li, multiple_chains,chain_name,gnum_classes_rel,dict_class,current_class):\n my_pos_bw=my_pos.split(\"x\")[0]\n add_chain_name=\"\"\n if multiple_chains:\n add_chain_name=\":\"+chain_name\n while i < len(cons_pos_li):\n cons_pos_bw_ourclass = cons_pos_li[i][1]\n if my_pos_bw==cons_pos_bw_ourclass:\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\n if pos_range:\n cons_pos_li[i][2]=pos_range + add_chain_name\n cons_pos_li[i][1]=\"Correspods to \"+cons_pos_bw_ourclass + current_class.lower()\n i+=1","def netmedic_param_search(entry_point, true_root_cause,\n pc_aggregate, pc_alpha, data_inwindow, data_head, dep_graph, window_start):\n result_list = []\n for hist_start in range(0, 200, 50):\n for hist_len in [50]:\n for current_start in range(200, 300, 50):\n for current_len in[50]:\n for bin_size in [5, 10, 15]:\n tic = time.time()\n prks, acc = test_netmedic(\n data_source=\"ibm_micro_service\",\n history_range=(hist_start, hist_start+hist_len),\n current_range=(\n current_start, current_start+current_len),\n bin_size=bin_size,\n affected_node=entry_point,\n true_root_cause=true_root_cause,\n verbose=0,\n runtime_debug=False,\n pc_aggregate=pc_aggregate,\n pc_alpha=pc_alpha,\n data=data_inwindow,\n data_head=data_head,\n disable_print=True,\n dep_graph=dep_graph,\n window_start=window_start\n )\n toc = time.time()-tic\n result_list.append({\n 'history_range': (hist_start, hist_start+hist_len),\n 'current_range': (current_start, current_start+current_len),\n 'bin_size': bin_size,\n 'time': toc,\n 'prks': prks,\n 'acc': acc\n })\n return result_list","def C(v,securite):\n to_return = set()\n x,y = l[v][0],l[v][1]\n a,b = id_case(x,y) #on recupere la case ou se trouve le disque qu'on test\n voisinage = set(cases[a,b]) #on recupere la liste du voisinage (pas forcement contact)\n #4\n #012\n #345\n #678 \n if a>100:\n voisinage = add_list(voisinage,cases[a-4*rayon,b]) #3\n if b>200:\n voisinage = add_list(voisinage,cases[a-4*rayon,b-4*rayon]) #0\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\n if b<600:\n voisinage = add_list(voisinage,cases[a-4*rayon,b+4*rayon]) #6\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\n if a<1100-4*rayon:\n voisinage = add_list(voisinage,cases[a+4*rayon,b]) #5\n if b>200:\n voisinage = add_list(voisinage,cases[a+4*rayon,b-4*rayon]) #2\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\n if b<600:\n voisinage = add_list(voisinage,cases[a+4*rayon,b+4*rayon]) #8\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\n \n #On ajoute plusieurs fois le meme a un ensemble -> pas grave\n for i in voisinage:\n xb,yb = l[i][0],l[i][1]\n if 0<sqrt((x-xb)**2+(y-yb)**2)<=2*rayon+securite:\n to_return.add(i)\n return to_return","def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\n return [\n [sc.cVLS() for sc in scList]\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\n ]","def getCriteriaSeries(mergedSegments,updatedSpeed,inversedIndex,WEIGHTS,minValidData):\n return pd.concat([getNeighboursCriteriaIndex(x,mergedSegments,updatedSpeed,inversedIndex,WEIGHTS,minValidData=MIN_VALID_DATA) for x in inversedIndex.values])","def get_contact_points(contact_points_path, json_name='contact_points.json',\n dataset_type='ycb', use_clustering=True,\n use_filter_penetration=True,\n inf_penetration_check=True, get_label=False):\n\n if osp.isdir(contact_points_path):\n contact_points_dict = load_multiple_contact_points(\n contact_points_path, json_name)\n else:\n contact_points_dict = json.load(open(contact_points_path, 'r'))\n contact_points = contact_points_dict['contact_points']\n\n\n\n if use_clustering:\n contact_points = cluster_contact_points(\n contact_points, min_samples=-1)\n get_label = False\n\n if use_filter_penetration:\n if inf_penetration_check:\n box_size = [100, 0.0001, 0.0001]\n else:\n box_size = [0.1, 0.0001, 0.0001]\n\n dirname = osp.dirname(contact_points_path)\n if dataset_type == 'ycb':\n contact_points, _ = filter_penetration(\n osp.join(dirname, 'base.urdf'),\n contact_points, box_size=box_size)\n else:\n contact_points, _ = filter_penetration(\n osp.join(dirname, urdf_name),\n contact_points, box_size=box_size)\n get_label = False\n\n if len(contact_points) == 0:\n print('num of hanging points: {}'.format(len(contact_points)))\n return None\n\n if get_label:\n labels = contact_points_dict['labels']\n return contact_points, labels\n else:\n return contact_points","def _draw_connections(plot, clusters, sp_cache):\n for path in sp_cache:\n clsts = [_find_cluster(clusters, step) for step in sp_cache[path]]\n plot.plot([c.centroid.x for c in clsts], [c.centroid.y for c in clsts], '-k', linewidth=0.09)","def layer_coords(label_lst): #full path\n \n #if a fundus then do this block\n gyrus_check = all(i.__contains__(\"fundus\") for i in label_lst)\n if gyrus_check:\n for layer in label_lst:\n #read data\n df_layer = pd.read_csv(layer)\n df_layer = df_layer.iloc[1:,0]\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\n\n #compute slope\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\n\n #split lam label into three\n split = math.floor(len(df_layer['X'].values)/3)\n df_layer_right = df_layer[0:split]\n df_layer_left = df_layer[-split:]\n df_layer_middle = df_layer[split:-split]\n\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000'\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\n plt.axis('off')\n plt.savefig('layer_contour.png')\n # plt.show()\n plt.close()\n\n #read, convert to grayscale, find edges\n layer_img = cv2.imread('layer_contour.png')\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\n\n #find contours\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n # cv2.imshow('contour', layer_edges)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\n \n #order contours\n contours = [np.squeeze(i) for i in contours]\n df_contours = pd.DataFrame(contours)\n contours_ord = df_contours.loc[6].values, df_contours.loc[4].values, \\\n df_contours.loc[3].values, df_contours.loc[2].values, \\\n df_contours.loc[1].values, df_contours.loc[0].values, \\\n df_contours.loc[5].values\n contours_ord = np.squeeze(contours_ord)\n \n\n #plot all layers and add coordinate data to dict \n lay_coords_dict = {}\n for laycon, i in zip(contours_ord, list(range(len(contours)))): \n #split coordinates into top and bottom edge\n if i == 0: #0 == pial\n c_idx = int(np.floor(len(laycon)/2))\n coords_top = np.array(list(reversed(laycon[:c_idx])))\n lay_coords_dict[i] = coords_top[10:]\n # print(coords_top)\n\n else:\n c_idx = int(np.floor(len(laycon)/2))\n coords_top = np.array(list(reversed(laycon[c_idx:])))\n lay_coords_dict[i] = coords_top[5:-7]\n\n \n #plot coords\n # for key, val in lay_coords_dict.items():\n # plt.plot([i[0] for i in val], [i[1] for i in val], lw=1.75)\n # plt.gca().invert_yaxis()\n # plt.show()\n # plt.close()\n # sys.exit()\n\n #delete edge detect image and return dict\n rm_img_cmd = \"rm layer_contour.png\"\n os.system(rm_img_cmd)\n return(lay_coords_dict)\n \n\n #for crown data do this block\n else:\n for layer in label_lst:\n #read data\n df_layer = pd.read_csv(layer)\n df_layer = df_layer.iloc[1:,0]\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\n\n #compute slope\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\n\n #split lam label into three\n split = math.floor(len(df_layer['X'].values)/3)\n df_layer_right = df_layer[0:split]\n df_layer_left = df_layer[-split:]\n df_layer_middle = df_layer[split:-split]\n\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000', lw=5\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\n plt.axis('off')\n plt.savefig('layer_contour.png')\n # plt.show()\n plt.close()\n\n #read, convert to grayscale, find edges\n layer_img = cv2.imread('layer_contour.png')\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\n\n #find contours\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n # cv2.imshow('contour', layer_edges)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\n \n\n #plot all layers and add coordinate data to dict\n lay_coords_dict = {}\n for laycon, i in zip(contours, list(range( len(contours) ) )[::-1] ):#7\n #split coordinates into top and bottom edge\n # print(laycon)\n coords_lst = [list(ii) for i in laycon for ii in i] # 0 == GWB\n # print(coords_lst)\n\n c_split = math.floor(len(coords_lst)/4)\n coords_top = coords_lst[:c_split][::-1] + coords_lst[-c_split:][::-1]\n lay_coords_dict[i] = coords_top\n df_coords = pd.DataFrame(coords_top, columns=['X', 'Y'])\n # print(df_coords)\n\n #plot using all coordinates\n plt.plot(df_coords['X'].values, df_coords['Y'].values, lw=3)\n plt.gca().invert_yaxis()\n # plt.show()\n plt.close()\n\n\n # use k means to get rid of extra coords on short lines\n for i in list(range(1,6)):\n # kMEANS clustering, separate short line bottom half\n df_short = pd.DataFrame(lay_coords_dict[i], columns=['X', 'Y']) #1=L1,\n # plt.scatter( df_short['X'].values, df_short['Y'].values, s=5 )\n # plt.gca().invert_yaxis()\n # plt.show()\n\n #scale data\n scaler = StandardScaler()\n scaler.fit( df_short[['X', 'Y']].values )\n short_scale = scaler.transform( df_short[['X', 'Y']].values )\n\n init = np.array([[0.514, -0.629], [-1.101, 1.344]])\n\n #predict\n # kmeans_classifier = KMeans(n_clusters=2, init=init) #fixed centroids\n kmeans_classifier = KMeans(n_clusters=2) \n\n y_kmeans = kmeans_classifier.fit_predict(short_scale)\n centroids = kmeans_classifier.cluster_centers_\n inertia = kmeans_classifier.inertia_\n\n\n #update df\n df_short.insert(2, column='kClass', value=y_kmeans)\n\n #df scaled\n df_short_scale = pd.DataFrame(short_scale, columns=['X', 'Y'])\n df_short_scale.insert(2, column='kClass', value=y_kmeans)\n \n\n \"\"\"\n #plot data points for k means, clusters\n colmap = {0: '#029386', 1: '#D2691E', 2: '#A52A2A'}\n for i in range(2):\n new_df = df_short_scale[df_short_scale['kClass']==i]\n plt.scatter(new_df['X'].values, new_df['Y'].values, s=20, \\\n label='cluster' + str(i+1), color=colmap[i])\n\n #plot centroids\n for i in range (2):\n plt.scatter(centroids[i][0], centroids[i][1], marker='x', s=500, \\\n label='centroid' + str(i+1), color=colmap[i])\n \n plt.legend()\n plt.gca().invert_yaxis()\n plt.show()\n \"\"\"\n\n\n #new df for clean data, take centroid with more data points\n num_class0 = len(df_short[df_short['kClass']==0])\n num_class1 = len(df_short[df_short['kClass']==1])\n\n if num_class0 > num_class1:\n \n df_short_clean = df_short[df_short['kClass']==0]\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\n df_short_clean['Y'].values)]\n else:\n df_short_clean = df_short[df_short['kClass']==1]\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\n df_short_clean['Y'].values)]\n\n #plot clean short line\n # plt.scatter(df_short_clean['X'].values, df_short_clean['Y'].values, s=20)\n # plt.gca().invert_yaxis()\n # plt.show()\n\n #delete edge detect image and return dict\n rm_img_cmd = \"rm layer_contour.png\"\n os.system(rm_img_cmd)\n return(lay_coords_dict)","def branches_library(point, dict_v, dict_e, list_v, kind_v, tuple_e):\n branches=[[point]] #unfinished branches\n lista=[] # finished branches, possible branches started in endpoint and ended in trunkpoint\n next_points = []\n while branches != []:\n for branch in branches:\n next_points = detect_next_points(branch[-1], branch[:-1], tuple_e)\n temp_list=list()\n \n if len(next_points)==0:\n branches.remove(branch)\n continue\n for pointn in next_points:\n temp_list.append(branch+[pointn])\n \n branches.remove(branch)\n\n for br in temp_list:\n if control_endpoint(br[-1],list_v, kind_v)==1:\n lista.append(br)\n else:\n branches.append(br)\n if len(lista)>10:\n return lista\n return lista","def get_l_interface(n_v,n_c, neighbours, vs, CV_matrix,L):\n h_j = np.empty((n_v, 3, 2))\n for i in range(3):\n h_j[:, i] = vs\n h_jp1 = np.dstack((roll_reverse(neighbours[:,:,0]),roll_reverse(neighbours[:,:,1])))\n l = np.mod(h_j - h_jp1 + L/2,L) - L/2\n l = np.sqrt(l[:,:,0]**2 + l[:,:,1]**2)\n LI = np.zeros((n_c,n_c),dtype=np.float32)\n for i in range(3):\n LI+= np.asfortranarray(l[:,i]*CV_matrix[:,:,i])@np.asfortranarray(CV_matrix[:,:,np.mod(i+2,3)].T)\n return LI","def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\n orderOfSCsByValueByFrame = [\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\n ]\n return scListByFrame, orderOfSCsByValueByFrame","def lcs(hh, vv):\n B=LCS.getB(hh,vv)\n trac=LCS.backtrack(B);\n cs=[ hh[h-1] for v,h,k in trac if k=='1' ]\n return cs","def crss(nds):\n cross_product = []\n nds = nodes[:, array(nds) - 1]\n for i, j, k, l in zip([2, 3, 1, 4, 6, 7, 5, 8], [4, 1, 3, 2, 8, 5, 7, 6], \n [5, 6, 8, 7, 1, 2, 4, 3], [1, 2, 4, 3, 5, 6, 8, 7]):\n p1 = nds[:, i - 1]\n p2 = nds[:, j - 1]\n p3 = nds[:, k - 1]\n p0 = nds[:, l - 1] \n u = p1 - p0\n v = p2 - p0\n w = p3 - p0 \n c = array([u[1]*v[2] - u[2]*v[1],\n u[2]*v[0] - u[0]*v[2],\n u[0]*v[1] - u[1]*v[0]])\n cross_product.append(dot(w, c)) \n \n for i in range(4, 8):\n cross_product[i] = - cross_product[i]\n \n return cross_product","def detect_coeff_knee(coeffs, n_min=10, limit_order_up=8, limit_order_down=5,\n threshold=0.05, min_window=4, window_ratio=0.01):\n coeffs = np.absolute(np.asarray(coeffs))\n max_coeff = coeffs.max()\n coeffs = coeffs[n_min:]\n coeffs = np.log10(coeffs)\n max_coeff = np.log10(max_coeff)\n N = len(coeffs)\n window = max(min_window, int(window_ratio*N))\n def f(i):\n return max(coeffs[i-window:i+window])\n wrange = lrange(window, N-window)\n best = min([max(coeffs[i-window:i+window]) for i in wrange])\n limit = min(best + limit_order_up, max_coeff - limit_order_down)\n start_idx = wrange[-1]\n while start_idx > wrange[0] and f(start_idx) < limit:\n start_idx -= 1\n if f(start_idx) >= limit and start_idx-window > 0:\n coeffs = coeffs[start_idx-window:]\n n_min += start_idx-window\n N = len(coeffs)\n wrange = range(window, N-window)\n worst = coeffs.max()\n def max_defect(i):\n # Return the maximum (normalized) distance of the *knee* to the\n # straight connection from 0 to i.\n a = np.asarray([0, worst/best])\n b = np.asarray([i/N, f(i)/best])\n def _defect(j):\n # Return the (normalized) distance of the point j to the\n # connecting line 0 to i.\n return f(j)/best - ((b[1]-a[1]) * float(j)/i + a[1])\n return max([0] + [_defect(j) for j in range(window, i-window, window)])\n # Search from the end to catch the highest resolution we might want to\n # keep.\n knee = next((i+n_min for i in reversed(wrange) if max_defect(i) < threshold), None)\n if knee + window > wrange[-1]:\n # We're below the threshold near the end already, so we should not\n # detect a knee at all.\n knee = None\n return knee","def get_verts(v_l, v_r):\n\n\t\tv_l = v_l%chain.length\n\t\tv_r = v_r%chain.length\n\n\t\tpoints = []\n\t\tcoords = list(chain.coords)\n\t\tif v_r > v_l:\n\n\t\t\tfor i in range(1, len(coords)):\n\t\t\t\n\t\t\t\tpd = LineString(coords[:i+1]).length\n\n\t\t\t\tif pd > v_l and pd < v_r:\n\t\t\t\t\tpoints.append(coords[i])\n\t\telse:\n\n\t\t\tfor i in range(1, len(coords)):\n\t\t\t\n\t\t\t\tpd = LineString(coords[:i+1]).length\n\n\t\t\t\tif pd > v_l:\n\t\t\t\t\tpoints.append(coords[i])\n\n\t\t\tfor i in range(1, len(coords)):\n\t\t\t\n\t\t\t\tpd = LineString(coords[:i+1]).length\n\n\t\t\t\tif pd < v_r:\n\t\t\t\t\tpoints.append(coords[i])\n\n\n\t\treturn points","def stop_connections(session, conn_list, at_date):\n stop_at = int(at_date.gps)\n data = []\n for conn in conn_list:\n print(\n \"Stopping connection {}:{}<{} - {}>{}:{} at {}\".format(\n conn[0], conn[1], conn[4], conn[2], conn[3], conn[5], str(at_date)\n )\n )\n this_one = []\n for cc in conn:\n this_one.append(cc)\n this_one.append(\"stop_gpstime\")\n this_one.append(stop_at)\n data.append(this_one)\n with mc.MCSessionWrapper(session=session) as session:\n update_connection(session, data, False)","def all_lcs(X, Y):\n return back_track_all(lcs_length(X, Y), X, Y, len(X), len(Y))","def predecessors(xi):\n X_K = xi.berkovich_line()\n if xi.is_limit_point():\n xi = xi.approximation()\n y = xi.parameter()\n v = xi.pseudovaluation_on_polynomial_ring()\n v_list = v.augmentation_chain()[1:-1]\n return [X_K.point_from_pseudovaluation_on_polynomial_ring(w, y)\n for w in v_list]","def diameter_clustering_vs_prob_ws(num_nodes, k):\r\n xdata = []\r\n ydata = []\r\n zdata = []\r\n prob = 0.0005\r\n while prob < 1:\r\n xdata += [prob]\r\n diameters = []\r\n coeffs = []\r\n for i in range(k):\r\n graph = make_ws_graph(num_nodes, 8, prob)\r\n diameters += [diameter(graph)]\r\n coeffs += [clustering_coefficient(graph)]\r\n ydata += [sum(diameters) / k / 19.0] #divide by 19 as this diameter of circle lattice\r\n zdata += [sum(coeffs) / k / 0.7] #divide by 0.7 as this is clustering coefficient of circle lattice\r\n prob = 1.2*prob\r\n return xdata, ydata, zdata","def _vertical_blindspot_network(x):\n skips = [x]\n\n n = x\n n = _vshifted_conv(n, 48, 'enc_conv0')\n n = _vshifted_conv(n, 48, 'enc_conv1')\n n = _vshifted_pool(n)\n skips.append(n)\n\n n = _vshifted_conv(n, 48, 'enc_conv2')\n n = _vshifted_pool(n)\n skips.append(n)\n\n n = _vshifted_conv(n, 48, 'enc_conv3')\n n = _vshifted_pool(n)\n skips.append(n)\n\n n = _vshifted_conv(n, 48, 'enc_conv4')\n n = _vshifted_pool(n)\n skips.append(n)\n\n n = _vshifted_conv(n, 48, 'enc_conv5')\n n = _vshifted_pool(n)\n n = _vshifted_conv(n, 48, 'enc_conv6')\n\n #-----------------------------------------------\n n = UpSampling2D(2)(n)\n n = Concatenate(axis=3)([n, skips.pop()])\n n = _vshifted_conv(n, 96, 'dec_conv5')\n n = _vshifted_conv(n, 96, 'dec_conv5b')\n\n n = UpSampling2D(2)(n)\n n = Concatenate(axis=3)([n, skips.pop()])\n n = _vshifted_conv(n, 96, 'dec_conv4')\n n = _vshifted_conv(n, 96, 'dec_conv4b')\n\n n = UpSampling2D(2)(n)\n n = Concatenate(axis=3)([n, skips.pop()])\n n = _vshifted_conv(n, 96, 'dec_conv3')\n n = _vshifted_conv(n, 96, 'dec_conv3b')\n\n n = UpSampling2D(2)(n)\n n = Concatenate(axis=3)([n, skips.pop()])\n n = _vshifted_conv(n, 96, 'dec_conv2')\n n = _vshifted_conv(n, 96, 'dec_conv2b')\n\n n = UpSampling2D(2)(n)\n n = Concatenate(axis=3)([n, skips.pop()])\n n = _vshifted_conv(n, 96, 'dec_conv1a')\n n = _vshifted_conv(n, 96, 'dec_conv1b')\n\n # final pad and crop for blind spot\n n = ZeroPadding2D([[1,0],[0,0]])(n)\n n = Cropping2D([[0,1],[0,0]])(n)\n\n return n","def GetListOfNextConnections(TimeTableList, TimeTableIndex, StationHourIndex, CurrentStation, \r\n\tabfahrt_std, abfahrt_min, WaitingTime):\r\n\tinterval_start = 60*abfahrt_std + abfahrt_min\r\n\tinterval_end = interval_start + WaitingTime\r\n\r\n\tFilteredTimeTable = []\r\n\thour = abfahrt_std\r\n\r\n\t# what if key does not exist (i.e. no connection in data set)\r\n\tif not StationHourIndex.has_key((CurrentStation, abfahrt_std)):\r\n\t\t# f.e. no connection found after 7.55 until 8:00\r\n\t\t\r\n\t\tif StationHourIndex.has_key((CurrentStation, abfahrt_std+1)):\r\n\t\t\thour += 1\r\n\t\telse:\r\n\t\t\treturn FilteredTimeTable\r\n\r\n\tfor i in range(StationHourIndex[(CurrentStation, hour)], len(TimeTableList)):\r\n\t\tif TimeTableIndex[i] <= interval_end and TimeTableList[i][ConnInfoInd['station_from']] == CurrentStation:\r\n\t\t\tif TimeTableIndex[i] >= interval_start:\r\n\t\t\t\tFilteredTimeTable.append(TimeTableList[i])\r\n\t\telse:\r\n\t\t\tbreak\r\n\treturn FilteredTimeTable","def dotAstroLc(lc, id, classname):\n lcs = []\n numlcs = 0\n data = lc\n soup = BeautifulSoup(data)\n try:\n ra = float(soup('position2d')[0]('value2')[0]('c1')[0]\n .renderContents())\n dec = float(soup('position2d')[0]('value2')[0]('c2')[0]\n .renderContents())\n except IndexError:\n print('position2d/value2/c1 or c2 tag not present in light curve file')\n ra, dec = [None, None]\n time_unit = []\n for timeunitfield in soup(ucd=\"time.epoch\"):\n time_unit.append(timeunitfield['unit'])\n\n for data_table in soup('tabledata'):\n\n epochs = []\n mags = []\n errs = []\n\n for row in data_table('tr'):\n tds = row(\"td\")\n epochs.append(float(tds[0].renderContents()))\n mags.append(float(tds[1].renderContents()))\n errs.append(float(tds[2].renderContents()))\n\n if len(epochs) > 0:\n lcs.append(lightCurve(epochs, mags, errs, ra, dec, id,\n time_unit[numlcs], classname))\n numlcs += 1\n\n return lcs","def _ppsc_gossip(self):\n for i in range(self.s):\n for edges in self.all_edges:\n # for each connected component\n selected_edge = random.choice(edges)\n self._ppsc_gossip_edge(selected_edge)","def allJPDs(net):\r\n \r\n onodes = net.Outputnodes()\r\n combinations = [i for i in itertools.combinations(onodes,2)]\r\n JPDdata = [] \r\n for c in combinations:\r\n priorA = getPrior(net,c[0])\r\n priorB = getPrior(net,c[1]) \r\n jpd = JPD(net,c)\r\n cov = Covariance (priorA,priorB,jpd)\r\n cor = Correlation (priorA,priorB,cov) \r\n JPDdata.append([c[0],c[1],jpd,cov,cor])\r\n return JPDdata","def FindCouplings():\n l1v = np.linspace(l1min, l1max, num=48)\n l2v = np.logspace(np.log10(l2min), np.log10(l2max), num=48)\n l3v = np.linspace(l3min, l3max, num=48)\n gxv = np.linspace(gxmin, gxmax, num=48)\n p = multiprocessing.Pool()\n f = open(file_name, 'w+')\n line = '|l1--l2--l3--gx--minima--mass1--mass2--stable|'\n f.write(line+'\\n')\n f.write('-'*90+'\\n')\n f.close()\n for l1 in l1v:\n for l2 in l2v:\n start_time_loop = time.time()\n params = cartesian((l1, -l2, l3v, gxv))\n print params.shape\n p.map(CheckCouplings, params)\n print(\"--- Loop has taken: %s seconds ---\" % (time.time() - start_time_loop))","def get_networks_from_multiplex_pajek(pajek):\n\n def _extract_intra_links(pajek):\n \"\"\"Return dictionary of intralayer `nx.Graph`s from input formatted pajek\"\"\"\n string_links = re.findall(r\"\\d+ \\d+ \\d+.*\", pajek.split(\"*Intra\")[1].split(\"*Inter\")[0])\n intra_links = [list(map(eval, link.split())) for link in string_links]\n G_arr_intra = defaultdict(lambda: nx.Graph)\n for l in intra_links:\n G_arr_intra[l[0]].add_edge(l[1], l[2])\n return G_arr_intra\n \n def _extract_intra_links_from_multiplex(pajek):\n \"\"\"Return dictionary of intralayer `nx.Graph`s from output formatted pajek\"\"\"\n string_links = re.findall(r\"\\d+ \\d+ \\d+ \\d+.*\", pajek.split(\"*multiplex\")[1])\n value_links = [list(map(eval, link.split())) for link in string_links]\n G_arr_intra = defaultdict(lambda: nx.Graph)\n for l in value_links:\n if l[0] == l[2]:\n G_arr_intra[l[0]].add_edge(l[1], l[3])\n return G_arr_intra\n \n if \"*Intra\" in pajek:\n return _extract_intra_links(pajek)\n if \"*multiplex\" in pajek:\n return _extract_intra_links_from_multiplex(pajek)\n \n raise ValueError(\"No intra links inside pajek\")"],"string":"[\n \"def GetCVLSWithLimitedPointsBetweenNodes(\\n cVLS, allValsByFrame, splitLength=1, fixedNumInteriorPoints=None, interpolate=True\\n):\\n allValues = list(set(tuple(flatten(allValsByFrame))))\\n allPairs = sorted(\\n list(set([tuple(c[0]) for cVLSByFrame in cVLS for c in cVLSByFrame]))\\n ) # Value pairs...\\n\\n if fixedNumInteriorPoints:\\n numInteriorPoints = {p: fixedNumInteriorPoints for p in allPairs}\\n else:\\n minLength = {}\\n for p in allPairs:\\n # minLength is the number of points of the shortest subcountour between cells p[0] and p[1] from all frames\\n minLength[p] = min(\\n [\\n len(c[2])\\n for cVLSByFrame in cVLS\\n for c in cVLSByFrame\\n if tuple(c[0]) == p\\n ]\\n )\\n # length of subcontour\\n numInteriorPoints = {}\\n for p in allPairs:\\n numInteriorPoints[p] = minLength[p] // splitLength\\n\\n cVLS2 = deepcopy(\\n cVLS\\n ) # otherwise, we'd also change the input argument cVLS in the outside world!\\n limIntPtsFunc = (\\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\\n )\\n\\n for cvlsByFrame in cVLS2:\\n for c in cvlsByFrame:\\n c[2] = limIntPtsFunc(c[2], numInteriorPoints[tuple(c[0])])\\n\\n return cVLS2\",\n \"def GetXYListAndPolyListFromCVLS(cVLS, allValsByFrame, orderOfSCsByValueByFrame):\\n numFrames = len(cVLS)\\n xyList = [\\n sorted(list(set(tuple(pt) for c in cvlsByVal for pt in c[2])))\\n for cvlsByVal in cVLS\\n ]\\n polyList = []\\n\\n for t in range(numFrames):\\n polyList.append({})\\n for v in allValsByFrame[t]:\\n subContours = [\\n (cVLS[t][-index][2][::-1] if index < 0 else cVLS[t][index][2])\\n for index in orderOfSCsByValueByFrame[t][v]\\n ] # reconstruct the sc's, flipping if index is negative\\n polyList[-1][v] = [\\n xyList[t].index(totuple(pt)) for sc in subContours for pt in sc[:-1]\\n ]\\n polyList[-1][v] = polyList[-1][v] + [\\n polyList[-1][v][0]\\n ] # Tack on the first point at the end to close the loop\\n # VFMin doesn't like this format; make sure to remove this last point before saving to a file or passing to VFM...\\n # polyList[-1][v] = removeDuplicates(polyList[-1][v])+[polyList[-1][v][0]] # Remove interior duplication...\\n return xyList, polyList\",\n \"def _calc_pp_pwl_points(ppc_pwl_points):\\n\\n def construct_list_of_list(row):\\n arr = pts[row, ::2]\\n arr = np.concatenate((arr[:1], np.repeat(arr[1:-1], 2), arr[-1:])).reshape((-1, 2))\\n arr = np.c_[arr, c[row, :]]\\n arr = arr[~np.isnan(arr[:, 2])]\\n return arr.tolist()\\n\\n pts = ppc_pwl_points\\n if not (pts.shape[1] % 2) == 0:\\n raise ValueError(\\\"_calc_pp_pwl_points() expects ppc_pwl_points with shape[1] is \\\"\\n f\\\"multiple of 2. However, ppc_pwl_points.shape[1]={ppc_pwl_points}.\\\")\\n c = (pts[:, 3::2] - pts[:, 1:-2:2]) / (pts[:, 2::2] - pts[:, :-2:2])\\n return [construct_list_of_list(row) for row in range(pts.shape[0])]\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def connected_components(self) -> List[list]:\\n for n in self.dw_graph.get_all_v().values():\\n n.distance=0.0\\n mega_list = []\\n for n in self.dw_graph.get_all_v().values():\\n if n.distance!=-10:\\n mega_list.append(self.connected_component(n.node_id))\\n return mega_list\",\n \"def point_list(self,res,llc,urc,direction):\\n\\t\\tif direction == 2:\\n\\t\\t\\tZdist=urc[2]-llc[2]\\n\\t\\t\\tnumPoints=int(numpy.ceil(Zdist/res))\\n\\t\\t\\tdeltaZ=Zdist/numPoints\\n\\t\\t\\tpoints=[llc+numpy.array([0,0,deltaZ*i]) for i in range(numPoints)]\\n\\t\\t\\treturn points, points[0], points[-1]\\n\\t\\tif direction == 1:\\n\\t\\t\\tZdist=urc[1]-llc[1]\\n\\t\\t\\tnumPoints=int(numpy.ceil(Zdist/res))\\n\\t\\t\\tdeltaZ=Zdist/numPoints\\n\\t\\t\\tpoints=[llc+numpy.array([0,deltaZ*i,0]) for i in range(numPoints)]\\n\\t\\t\\treturn points, points[0], points[-1]\\n\\t\\tif direction == 0:\\n\\t\\t\\tZdist=urc[0]-llc[0]\\n\\t\\t\\tnumPoints=int(numpy.ceil(Zdist/res))\\n\\t\\t\\tdeltaZ=Zdist/numPoints\\n\\t\\t\\tpoints=[llc+numpy.array([deltaZ*i,0,0]) for i in range(numPoints)]\\n\\t\\t\\treturn points, points[0], points[-1]\",\n \"def calculate_ctrl_pts(self) -> list[tuple]:\\n ctrl_pts = []\\n # Skip last point if path is non-cyclic\\n point_inds = range(self.num_points) if self.is_cyclic else range(self.num_points - 1)\\n for i in point_inds:\\n z_i = self.points[i]\\n z_j = self.points[(i + 1) % self.num_points]\\n rho_coefficient = z_i.alpha * velocity(z_i.theta, z_j.phi)\\n sigma_coefficient = z_j.beta * velocity(z_j.phi, z_i.theta)\\n ctrl_pt_a = z_i + (1 / 3) * rho_coefficient * cmath.exp(complex(0, z_i.theta)) * (z_j - z_i)\\n ctrl_pt_b = z_j - (1 / 3) * sigma_coefficient * cmath.exp(complex(0, -z_j.phi)) * (z_j - z_i)\\n ctrl_pts.append((ctrl_pt_a.real, ctrl_pt_a.imag))\\n ctrl_pts.append((ctrl_pt_b.real, ctrl_pt_b.imag))\\n return ctrl_pts\",\n \"def basicGetPointsGeodesic(self):\\n\\n # more geodesic, distance=2 (complicated because random)\\n data = numpy.array([[0, 1, 1, 1, 2, 2, 2, 0],\\n [0, 1, 1, 1, 2, 2, 2, 0],\\n [0, 1, 1, 1, 2, 2, 2, 0]])\\n labels = Labels(data=data)\\n result = labels.getPoints(ids=[1], mode='geodesic', distance=2, \\n connectivity=1)\\n result = result.tolist()\\n if len(result) == 5:\\n desired = [[0, 1], [0, 3], [1, 2], [2, 1], [2, 3]]\\n elif len(result) == 4:\\n desired = [[0, 2], [1, 1], [1, 3], [2, 2]]\\n elif len(result) == 3:\\n if [1, 2] in result:\\n if [0, 1] in result:\\n desired = [[0, 1], [1, 2], [2, 3]] \\n elif [0, 3] in result:\\n desired = [[0, 3], [1, 2], [2, 1]]\\n elif [0, 1] in result:\\n if [0, 3] in result:\\n desired = [[0, 1], [0, 3], [2, 2]]\\n elif [2, 1] in result:\\n desired = [[0, 1], [2, 1], [1, 3]]\\n else:\\n desired = [[0, 1], [1, 3], [2, 2]]\\n elif [2, 3] in result:\\n if [0, 3] in result:\\n desired = [[0, 3], [1, 1], [2, 3]]\\n elif [2, 1] in result:\\n desired = [[0, 2], [2, 1], [2, 3]]\\n else:\\n desired = [[2, 3], [1, 1], [0, 2]] \\n elif [0, 3] in result:\\n desired = [[0, 3], [1, 1], [2, 2]]\\n elif [2, 1] in result:\\n desired = [[2, 1], [1, 3], [0, 2]]\\n for des in desired:\\n np_test.assert_equal(des in result, True)\\n for res in result:\\n np_test.assert_equal(res in desired, True)\\n\\n # mode geodesic, distance=3, inset\\n labels = Labels(data=data[1:3, 2:8])\\n labels.setInset([slice(1, 3), slice(2, 8)])\\n result = labels.getPoints(ids=[2], mode='geodesic', distance=3, \\n connectivity=1)\\n result = result.tolist()\\n if len(result) == 1:\\n np_test.assert_equal(result[0][1], 5)\\n elif len(result) == 2:\\n desired = []\\n if [1, 4] in result:\\n desired = [[1, 4], [2, 6]]\\n elif [2, 4] in result:\\n desired = [[2, 4], [1, 6]]\\n for des in desired: \\n np_test.assert_equal(des in result, True)\\n for res in result:\\n np_test.assert_equal(res in desired, True)\",\n \"def identify_lipid_leaflets_legacy(pts,vec,monolayer_cutoff,\\n\\tmonolayer_cutoff_retry=True,max_count_asymmetry=0.05,pbc_rewrap=True,\\n\\ttopologize_tolerance=None,topologize_time_limit=30):\\n\\t#---previous default was somewhat high, but typically came in from specs, and we reduced it incrementally\\n\\tif monolayer_cutoff==None: monolayer_cutoff = 2.0\\n\\t#---time limit on the tolerance checker\\n\\ttry:\\n\\t\\twith time_limit(topologize_time_limit): \\n\\t\\t\\twrapper = topologize(pts,vec,\\n\\t\\t\\t\\t**({'tol':topologize_tolerance} if topologize_tolerance else {}))\\n\\texcept TimeoutException: \\n\\t\\tstatus('topologize failed to join the bilayer. '\\n\\t\\t\\t'if it is broken over PBCs e.g. a saddle, this is a serious error which may go undetected. '\\n\\t\\t\\t'make sure you always inspect the topology later.',tag='error')\\n\\t\\twrapper = np.zeros((len(pts),3))\\n\\tfindframe = pts + wrapper*np.array(vec)\\n\\tstatus('this step is somewhat slow. it uses scipy.spatial.pdist.',tag='warning')\\n\\tpd = [scipy.spatial.distance.squareform(scipy.spatial.distance.pdist(findframe[:,d:d+1])) \\n\\t\\tfor d in range(3)]\\n\\tif pbc_rewrap:\\n\\t\\tpd3pbc = np.sqrt(np.sum(np.array([pd[d]-(pd[d]>vec[d]/2.)*vec[d]+(pd[d]<-1*vec[d]/2.)*vec[d] \\n\\t\\t\\tfor d in range(3)])**2,axis=0))\\n\\telse: pd3pbc = pd\\n\\tnbors = np.transpose(np.where(pd3pbc<monolayer_cutoff))\\n\\tnlipids = len(pts)\\n\\timono = np.zeros(nlipids)\\n\\tnlist = []\\n\\tfor i in range(nlipids):\\n\\t\\tstatus('cataloging lipids',i=i,looplen=nlipids,tag='compute')\\n\\t\\tnlist.append(nbors[np.where(nbors[:,0]==i)[0],1])\\n\\tiref = 0\\n\\tmono = np.zeros(nlipids)\\n\\tsearched = np.zeros(nlipids)\\n\\timono[iref],searched[iref] = 1,1\\n\\timono[nlist[iref]] = 1\\n\\twhile np.any(np.all((imono==1,searched==0),axis=0)):\\n\\t\\tfor iref in np.where(np.all((imono==1,searched==0),axis=0))[0]: \\n\\t\\t\\timono[nlist[iref]] = 1\\n\\t\\t\\tsearched[iref] = 1\\n\\t#---check that the leaflets were properly distinguished by looking at the number in each monolayer\\n\\tif np.mean(imono)==0.5: \\n\\t\\tstatus('[STATUS] perfect split is %0.5f'%np.mean(imono))\\n\\t\\treturn imono\\n\\telif (monolayer_cutoff_retry and (np.all(np.array(imono)==0) or np.all(np.array(imono)==1) or \\n\\t\\tnp.abs(np.mean(imono)-0.5)>=max_count_asymmetry)):\\n\\t\\tstatus('[STATUS] split is %0.5f'%np.mean(imono))\\n\\t\\tstatus('[STATUS] one side has %d'%np.sum(imono))\\n\\t\\tstatus('[WARNING] leaflets were not distinguished')\\n\\t\\tstatus('[COMPUTE] leaflets = '+str(np.sum(imono))+'/'+str(len(imono)))\\n\\t\\tstatus('[WARNING] previous monolayer_cutoff = '+str(monolayer_cutoff))\\n\\t\\traise Exception(\\n\\t\\t\\t'[ERROR] failed to identify leaflets so we are returning an exception to the LeafletFinder')\\n\\telse: status('[STATUS] some lipids might be flipped %d %.5f'%(np.sum(imono),np.mean(imono)))\\n\\treturn imono\",\n \"def construct_fast_graph_connection(coord_list, radie):\\n\\n connection_distance = []\\n connection = []\\n coord_list_tree = scipy.spatial.cKDTree(coord_list)\\n for j, data in enumerate(coord_list):\\n '''save nodes which are in range'''\\n connections_ckd = coord_list_tree.query_ball_point(data, radie)\\n for i in connections_ckd:\\n #only save upper half of the matrix\\n if i > j:\\n #save the connection\\n connection.append([j, i])\\n #save the relative distance of the nodes\\n connection_distance.append(np.hypot(coord_list[i,0]-data[0], coord_list[i,1]-data[1]))\\n\\n connection_distance = np.array(connection_distance)\\n connection = np.array(connection)\\n\\n\\n return connection, connection_distance\",\n \"def MakePolygonNetworkFromWaterSeg(\\n waterArr, minSplit=30, allValsByFrame=None, cVLS=None\\n):\\n if allValsByFrame is None:\\n allValsByFrame = [list(set(w.flat)) for w in waterArr]\\n if cVLS is None:\\n cVLS = GetContourValuesLengthsAndSubContoursByFrame(waterArr, allValsByFrame)\\n allPtsList = []\\n allSegsList = []\\n for t in range(len(cVLS)):\\n contours = [i[2] for i in cVLS[t]]\\n nc = len(contours)\\n lc = [len(i) for i in contours]\\n div = [i // 30 for i in lc]\\n sep = [(lc[i] if div[i] == 0 else lc[i] // div[i]) for i in range(nc)]\\n # subPtsOld = [ ([] if div[i]==0 else contours[i][ ::(len(contours[i])//div[i]) ] )\\n # for i in range(nc) ]\\n inds = [\\n (\\n [0, lc[i] - 1]\\n if (lc[i] - 1 < 2 * minSplit)\\n else list(range(0, lc[i] - 2, sep[i])) + [lc[i] - 1]\\n )\\n for i in range(nc)\\n ]\\n\\n subPts = [[tuple(contours[i][j]) for j in inds[i]] for i in range(nc)]\\n allPts = sorted(list(set(flatten(subPts))))\\n subPtsInds = [[allPts.index(j) for j in i] for i in subPts]\\n allSegsInds = flatten([zip(i[:-1], i[1:]) for i in subPtsInds])\\n allPtsList.append(allPts)\\n allSegsList.append(allSegsInds)\\n\\n return allPtsList, allSegsList\",\n \"def add_new_connections(session, cobj, conn_list, at_date):\\n start_at = int(at_date.gps)\\n data = []\\n\\n for conn in conn_list:\\n cobj.connection(\\n upstream_part=conn[0],\\n up_part_rev=conn[1],\\n downstream_part=conn[3],\\n down_part_rev=conn[4],\\n upstream_output_port=conn[2],\\n downstream_input_port=conn[5],\\n start_gpstime=start_at,\\n stop_gpstime=None,\\n )\\n print(\\\"Starting connection {} at {}\\\".format(cobj, str(at_date)))\\n data.append(\\n [\\n cobj.upstream_part,\\n cobj.up_part_rev,\\n cobj.downstream_part,\\n cobj.down_part_rev,\\n cobj.upstream_output_port,\\n cobj.downstream_input_port,\\n cobj.start_gpstime,\\n \\\"upstream_part\\\",\\n cobj.upstream_part,\\n ]\\n )\\n data.append(\\n [\\n cobj.upstream_part,\\n cobj.up_part_rev,\\n cobj.downstream_part,\\n cobj.down_part_rev,\\n cobj.upstream_output_port,\\n cobj.downstream_input_port,\\n cobj.start_gpstime,\\n \\\"up_part_rev\\\",\\n cobj.up_part_rev,\\n ]\\n )\\n data.append(\\n [\\n cobj.upstream_part,\\n cobj.up_part_rev,\\n cobj.downstream_part,\\n cobj.down_part_rev,\\n cobj.upstream_output_port,\\n cobj.downstream_input_port,\\n cobj.start_gpstime,\\n \\\"downstream_part\\\",\\n cobj.downstream_part,\\n ]\\n )\\n data.append(\\n [\\n cobj.upstream_part,\\n cobj.up_part_rev,\\n cobj.downstream_part,\\n cobj.down_part_rev,\\n cobj.upstream_output_port,\\n cobj.downstream_input_port,\\n cobj.start_gpstime,\\n \\\"down_part_rev\\\",\\n cobj.down_part_rev,\\n ]\\n )\\n data.append(\\n [\\n cobj.upstream_part,\\n cobj.up_part_rev,\\n cobj.downstream_part,\\n cobj.down_part_rev,\\n cobj.upstream_output_port,\\n cobj.downstream_input_port,\\n cobj.start_gpstime,\\n \\\"upstream_output_port\\\",\\n cobj.upstream_output_port,\\n ]\\n )\\n data.append(\\n [\\n cobj.upstream_part,\\n cobj.up_part_rev,\\n cobj.downstream_part,\\n cobj.down_part_rev,\\n cobj.upstream_output_port,\\n cobj.downstream_input_port,\\n cobj.start_gpstime,\\n \\\"downstream_input_port\\\",\\n cobj.downstream_input_port,\\n ]\\n )\\n data.append(\\n [\\n cobj.upstream_part,\\n cobj.up_part_rev,\\n cobj.downstream_part,\\n cobj.down_part_rev,\\n cobj.upstream_output_port,\\n cobj.downstream_input_port,\\n cobj.start_gpstime,\\n \\\"start_gpstime\\\",\\n cobj.start_gpstime,\\n ]\\n )\\n with mc.MCSessionWrapper(session=session) as session:\\n update_connection(session, data, True)\",\n \"def cyclic_subgroups(C):\\n ps = C.points()\\n Gs = []\\n \\n for i in ps:\\n P = Elliptic_Point(i[0],i[1],C)\\n Gs.append(cyclic_subgroup(P))\\n\\n return Gs\",\n \"def create_pf_coils(self) -> list:\\n\\n # from diagram\\n lower_lefts = np.array(\\n [\\n (345.5429497568881, -788.0537547271744),\\n (800.6482982171799, -703.3664235548353),\\n (1160.9400324149108, -272.69381415451096),\\n (1158.833063209076, 268.97622906537015),\\n (798.5413290113453, 621.6369529983793),\\n (345.5429497568881, 707.7795786061589),\\n ]\\n )\\n\\n top_rights = np.array(\\n [\\n (511.99351701782825, -690.4038357644516),\\n (880.7131280388979, -611.8280659103187),\\n (1222.0421393841166, -162.37506753106413),\\n (1230.4700162074555, 379.2780929227446),\\n (861.7504051863858, 681.9523230686117),\\n (446.677471636953, 803.4508373851974),\\n ]\\n )\\n\\n outboard_pf_coils = []\\n for counter, (top_right, lower_left) in enumerate(zip(top_rights, lower_lefts), 1):\\n pf_coil = paramak.PoloidalFieldCoilFP(\\n corner_points=(top_right, lower_left),\\n rotation_angle=self.rotation_angle,\\n name=f\\\"outboard_pf_coils_{counter}\\\",\\n )\\n outboard_pf_coils.append(pf_coil)\\n\\n x_inner, x_outer = 132.73905996758506, 202.26904376012968\\n\\n pf_coils_1 = paramak.RotateStraightShape(\\n points=[\\n (x_inner, -600),\\n (x_outer, -600),\\n (x_outer, -400),\\n (x_inner, -400),\\n ],\\n rotation_angle=self.rotation_angle,\\n name=\\\"pf_coil_1\\\",\\n )\\n\\n pf_coils_2 = paramak.RotateStraightShape(\\n points=[\\n (x_inner, -400),\\n (x_outer, -400),\\n (x_outer, -200),\\n (x_inner, -200),\\n ],\\n rotation_angle=self.rotation_angle,\\n name=\\\"pf_coil_2\\\",\\n )\\n\\n pf_coils_3 = paramak.RotateStraightShape(\\n points=[\\n (x_inner, -200),\\n (x_outer, -200),\\n (x_outer, 0),\\n (x_inner, 0),\\n ],\\n rotation_angle=self.rotation_angle,\\n name=\\\"pf_coil_3\\\",\\n )\\n\\n pf_coils_4 = paramak.RotateStraightShape(\\n points=[\\n (x_inner, 0),\\n (x_outer, 0),\\n (x_outer, 200),\\n (x_inner, 200),\\n ],\\n rotation_angle=self.rotation_angle,\\n name=\\\"pf_coil_4\\\",\\n )\\n\\n pf_coils_5 = paramak.RotateStraightShape(\\n points=[\\n (x_inner, 200),\\n (x_outer, 200),\\n (x_outer, 400),\\n (x_inner, 400),\\n ],\\n rotation_angle=self.rotation_angle,\\n name=\\\"pf_coil_5\\\",\\n )\\n\\n pf_coils_6 = paramak.RotateStraightShape(\\n points=[\\n (x_inner, 400),\\n (x_outer, 400),\\n (x_outer, 600),\\n (x_inner, 600),\\n ],\\n rotation_angle=self.rotation_angle,\\n name=\\\"pf_coil_6\\\",\\n )\\n\\n return outboard_pf_coils + [\\n pf_coils_1,\\n pf_coils_2,\\n pf_coils_3,\\n pf_coils_4,\\n pf_coils_5,\\n pf_coils_6,\\n ]\",\n \"def optionThree(catalog):\\n ans = controller.pointsInterconnection(catalog)\\n\\n item_map = folium.Map(location=[25.557547, -24.568953], zoom_start=2)\\n for landinpoint in lt.iterator(ans[0]):\\n item = mp.get(catalog['landingpoints'], landinpoint)['value']['info']\\n print('Nombre:', item['id'], '\\\\tLugar:', item['name'], '\\\\tIdentificador: ', item['landing_point_id'])\\n\\n tooltip = item['id']\\n item_lat = float(item['latitude'])\\n item_lon = float(item['longitude'])\\n cables = mp.get(catalog['landingpoints'], landinpoint)['value']['lstcables']\\n folium.Marker(location=[item_lat, item_lon], popup=\\\"<strong></strong>\\\", tooltip=tooltip, icon=folium.Icon(color='darkred', icon = 'cloud')).add_to(item_map)\\n\\n for cable in lt.iterator(mp.keySet(cables)): \\n # * Markers y conectors entre el lp actual y todas sus conexiones\\n\\n cable = cable.split('-')[1:][0]\\n cable_info = mp.get(catalog['landingpoints'], cable)['value']['info']\\n cable_lat = float(cable_info['latitude'])\\n cable_lon = float(cable_info['longitude'])\\n tooltip_2 = cable_info['name']\\n folium.Marker(location=[cable_lat, cable_lon], popup=\\\"<strong>Landpoint se connecta con Jakarta</strong>\\\", tooltip=tooltip_2,icon=folium.Icon(color='lightgray')).add_to(item_map)\\n folium.PolyLine([(item_lat, item_lon), (cable_lat, cable_lon)],\\n color='gray',\\n weight=2,\\n opacity=0.6).add_to(item_map)\\n\\n print('\\\\nHay', ans[1], 'cables conectados a dicho(s) landingpoints')\\n item_map.save('Req 2.html')\",\n \"def lagrangePoints(mu):\\n \\n # define l = 1-mu\\n l = 1 - mu\\n \\n # collinear points\\n def eqL1(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)+mu-l)*x**2 + (mu**2*l**2+2*(l**2+mu**2))*x + mu**3-l**3\\n #fval = gamma**5 - (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 + 2*mu*gamma - mu\\n return fval\\n sol_l1 = optimize.root(eqL1, 0.5, method='hybr')\\n l1 = np.array([sol_l1.x[0] , 0, 0])\\n \\n def eqL2(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)-(mu+l))*x**2 + (mu**2*l**2+2*(l**2-mu**2))*x - (mu**3+l**3)\\n #fval = gamma**5 + (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 - 2*mu*gamma - mu\\n return fval\\n sol_l2 = optimize.root(eqL2, 1.5, method='hybr')\\n l2 = np.array([sol_l2.x[0] , 0, 0])\\n \\n def eqL3(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*mu*l+mu**2)*x**3 + (2*mu*l*(l-mu)+(l+mu))*x**2 + (mu**2*l**2+2*(mu**2-l**2))*x + l**3+mu**3\\n return fval\\n sol_l3 = optimize.root(eqL3, -1, method='hybr')\\n l3 = np.array([sol_l3.x[0] , 0, 0])\\n \\n # equilateral points\\n # L4\\n l4 = np.array([np.cos(np.pi/3) - mu , np.sin(np.pi/3), 0])\\n # L5\\n l5 = np.array([np.cos(np.pi/3) - mu , -np.sin(np.pi/3), 0])\\n \\n return _lagrangePointsReturn(l1,l2,l3,l4,l5)\",\n \"def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\\n if not ls_FVS:\\n set_nodes = set([])\\n for t_link in lt_links:\\n set_nodes.add(t_link[0])\\n set_nodes.add(t_link[1])\\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\\n #if FVS nodes are already gained, pass this step\\n \\n llt_feedbacks = []\\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\\n for s_FVSnode in ls_FVS:\\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\\n for lt_downstream in llt_downstreams:\\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\\n \\n lts_cyclesofFVS = get_all_cycles(ls_FVS)\\n for ts_cycleofFVS in lts_cyclesofFVS:\\n if len(ts_cycleofFVS) == 1:\\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\\n else:\\n b_stopflag = False\\n lllt_feedbackfragment = []\\n for i in range(len(ts_cycleofFVS)-1):\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\\n b_stopflag = True\\n break\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\\n b_stopflag = True\\n if b_stopflag:\\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\\n \\n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\\n while lllt_feedbackfragment:\\n llt_fragments_next = lllt_feedbackfragment.pop(0)\\n llt_feedbacks_updated = []\\n for lt_fragment in llt_feedbacks_specific_cycle:\\n for lt_fragment_next in llt_fragments_next:\\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\\n if not set(ls_route).intersection(set(ls_route_next)):\\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\\n\\n return llt_feedbacks\",\n \"def nodesBetweenCriticalPoints(self, head: Optional[ListNode]) -> List[int]:\\n critical = []\\n pos = 1\\n while head is not None and head.next is not None and head.next.next is not None:\\n if head.val < head.next.val > head.next.next.val or head.val > head.next.val < head.next.next.val:\\n critical.append(pos)\\n head = head.next\\n pos += 1\\n if len(critical) <= 1:\\n return [-1, -1]\\n ret_min = pos\\n ret_max = critical[-1] - critical[0]\\n for i in range(1, len(critical)):\\n ret = critical[i] - critical[i - 1]\\n if ret < ret_min:\\n ret_min = ret\\n return [ret_min, ret_max]\",\n \"def construct_graph_connection(coord_list, radie):\\n\\n connection_distance = []\\n connection = []\\n for j, data in enumerate(coord_list):\\n '''Calculate the relative distance of the nodes'''\\n distance = np.hypot(coord_list[:,0]-data[0], coord_list[:,1]-data[1])\\n '''save nodes which are in range'''\\n #for i, data in enumerate(distance):\\n for i in range(j+1, len(distance)):\\n data = distance[i]\\n if data < radie:\\n connection.append([j, i])\\n connection_distance.append(data)\\n\\n\\n connection_distance = np.array(connection_distance)\\n connection = np.array(connection)\\n return connection, connection_distance\",\n \"def chercherChemin(self):\\n\\n \\n liste=self._circuit.vue(self.x,self.y,self.rayonVision)\\n \\n listeSuppr=[]\\n couche_vehicule= self._circuit.Couche_vehicules\\n \\n for case in liste :\\n #on élimine les cases infranchissbles les cases qui ne sont pas sur le chemin à suivre \\n\\n if self._circuit.numeroWayPoint(case[0],case[1])==0 or ( self._circuit.numeroWayPoint(self.x,self.y)!=self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])<= self._circuit.numeroWayPoint(self.x,self.y)) or( self._circuit.numeroWayPoint(case[0],case[1])>= 5*self._circuit.numeroWayPoint(self.x,self.y) and self._circuit.numeroWayPoint(self.x,self.y)!=0) or ( self._circuit.numeroWayPoint(self.x,self.y)==self._circuit.lastWayPoint and self._circuit.numeroWayPoint(case[0],case[1])== self._circuit.numeroWayPoint(self.x,self.y)) or self._circuit.plateau[case[1],case[0],couche_vehicule]!=None:#on élimine les points derrière\\n \\n listeSuppr.append(case)\\n\\n \\n for case in listeSuppr:\\n \\n liste.remove(case)\\n \\n if len(liste)>=1:\\n l=liste[0]\\n\\n for nour in liste :\\n \\n if distance((self.x,self.y),(l[0],l[1])) > distance((self.x,self.y),(nour[0],nour[1])):\\n l=nour\\n pasx=0\\n pasy=0\\n if self.x<l[0] : \\n pasx=1\\n elif self.x>l[0] :\\n pasx=-1\\n if self.y<l[1] : \\n pasy=1\\n elif self.y>l[1] :\\n pasy=-1\\n debug.dprint(\\\" id {} {}:({},{}) Waypoint {} Point:({},{}) WayPoint {} vitesse :{} reservoir:{}\\\".format(self.id,self.typeV,self.x,self.y,self._circuit.numeroWayPoint(self.x,self.y),l[0],l[1],self._circuit.numeroWayPoint(l[0],l[1]),self.vitesse,self.reservoir))\\n self.orientation=atan2(pasy,pasx)\\n\\n self.vitesse=1\\n\\n debug.dprint(self) \\n \\n super().deplacer()\\n \\n\\n self.rayonVision=4\\n else :# on augemente le rayon de vision au cas ou toutes les cases sont occupées ou non franchissables\\n self.rayonVision*=3\",\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def _retrieve_options(list_waypoints, current_waypoint):\\n options = []\\n for next_waypoint in list_waypoints:\\n # this is needed because something we are linking to\\n # the beggining of an intersection, therefore the\\n # variation in angle is small\\n next_next_waypoint = next_waypoint.next(3.0)[0]\\n link = _compute_connection(current_waypoint, next_next_waypoint)\\n options.append(link)\\n\\n return options\",\n \"def cvx_inequality_time_graphical_lasso(\\n S, K_init, max_iter, loss, C, theta, psi, gamma, tol\\n ):\\n\\n if loss == 'LL':\\n loss_function = neg_logl\\n else:\\n loss_function = dtrace\\n\\n T, p, _ = S.shape\\n K = [cp.Variable(shape=(p, p), PSD=True) for t in range(T)]\\n # Z_1 = [cp.Variable(shape=(p, p), PSD=True) for t in range(T-1)]\\n # Z_2 = [cp.Variable(shape=(p, p), PSD=True) for t in range(T-1)]\\n\\n if psi == 'laplacian':\\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \\n (1 - theta) * cp.sum([cp.norm(K[t] - K[t-1], 'fro') for t in range(1, T)]))\\n elif psi == 'l1':\\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \\n (1 - theta) * cp.sum([cp.sum(cp.norm1(K[t] - K[t-1], axis=1)) for t in range(1, T)]))\\n elif psi == 'l2':\\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \\n (1 - theta) * cp.sum([cp.sum(cp.norm(K[t] - K[t-1], p=2, axis=1)) for t in range(1, T)]))\\n elif psi == 'linf':\\n objective = cp.Minimize(theta * cp.sum([cp.norm(K[t] - cp.diag(cp.diag(K[t])), 1) for t in range(T)]) + \\n (1 - theta) * cp.sum([cp.sum(cp.norm_inf(K[t] - K[t-1], axis=1)) for t in range(1, T)]))\\n\\n # if loss_function == neg_logl:\\n constraints = [(cp.sum(cp.multiply(K[t], S[t])) - cp.log_det(K[t]) <= C[t]) for t in range(T)]\\n # [(cp.trace(K[t] @ S[t]) - cp.log_det(K[t]) <= C[t]) for t in range(T)] # + \\\\\\n # [(Z_1[t] == K[t]) for t in range(T-1)] + \\\\\\n # [(Z_2[t] == K[t+1]) for t in range(T-1)]\\n # else:\\n # constraints = [(cp.trace(K[t] @ K[t] @ S[t]) - cp.trace(K[t]) <= C[t]) for t in range(T)] # + \\\\\\n # # [(Z_1[t] == K[t]) for t in range(T-1)] + \\\\\\n # # [(Z_2[t] == K[t+1]) for t in range(T-1)]\\n\\n prob = cp.Problem(objective, constraints)\\n # prob.solve(solver=cp.SCS, max_iters=np.int(max_iter), eps=tol, verbose=True)\\n prob.solve(solver=cp.MOSEK, verbose=True)\\n\\n print(prob.status)\\n print(prob.value)\\n\\n K = np.array([k.value for k in K])\\n covariance_ = np.array([linalg.pinvh(k) for k in K])\\n return_list = [K, covariance_]\\n return return_list\",\n \"def api_get_crossing_proposals(\\n self,\\n request,\\n o1,\\n o2=None,\\n left_filter: Optional[str] = None,\\n right_filter: Optional[str] = None,\\n cable_filter: Optional[str] = None,\\n ):\\n self.logger.info(\\n \\\"Crossing proposals: %s:%s, %s:%s. Cable: %s\\\",\\n o1,\\n left_filter,\\n o2,\\n right_filter,\\n cable_filter,\\n )\\n lo: Object = self.get_object_or_404(Object, id=o1)\\n ro: Optional[Object] = None\\n if o2:\\n ro = self.get_object_or_404(Object, id=o2)\\n id_ports_left = {}\\n checking_ports = []\\n lcs: List[Dict[str, Any]] = []\\n cable: Optional[ObjectModel] = None\\n # Getting cable\\n cables = ObjectModel.objects.filter(data__length__length__gte=0)\\n if cable_filter:\\n cable = ObjectModel.get_by_name(cable_filter)\\n for c in lo.model.connections:\\n valid, disable_reason = True, \\\"\\\"\\n if cable_filter:\\n # If select cable_filter - check every connection to cable\\n cable_connections = [\\n c for c in lo.model.get_connection_proposals(c.name) if c[0] == cable.id\\n ]\\n valid = bool(cable_connections)\\n elif ro and right_filter:\\n rc = ro.model.get_model_connection(right_filter)\\n if not rc:\\n raise\\n valid, disable_reason = lo.model.check_connection(c, rc)\\n elif ro:\\n valid = bool(\\n [c for c in lo.model.get_connection_proposals(c.name) if c[0] == ro.model.id]\\n )\\n oc, oo, _ = lo.get_p2p_connection(c.name)\\n left_id = f\\\"{smart_text(lo.id)}{c.name}\\\"\\n is_employed = bool(oc)\\n if is_employed:\\n checking_ports.append(c)\\n lcs += [\\n self.get_cs_item(\\n left_id,\\n c.name,\\n str(c.type.id),\\n c.type.name,\\n c.gender,\\n c.direction,\\n c.protocols,\\n not is_employed,\\n valid,\\n disable_reason,\\n lo,\\n )\\n ]\\n id_ports_left[c.name] = left_id\\n id_ports_right = {}\\n rcs: List[Dict[str, Any]] = []\\n if ro:\\n for c in ro.model.connections:\\n valid, disable_reason = True, \\\"\\\"\\n if cable_filter:\\n cable_connections = [\\n c for c in ro.model.get_connection_proposals(c.name) if c[0] == cable.id\\n ]\\n valid = bool(cable_connections)\\n elif left_filter:\\n lc = lo.model.get_model_connection(left_filter)\\n if not lc:\\n raise\\n valid, disable_reason = lo.model.check_connection(c, lc)\\n else:\\n valid = bool(\\n [\\n c\\n for c in ro.model.get_connection_proposals(c.name)\\n if c[0] == lo.model.id\\n ]\\n )\\n oc, oo, _ = ro.get_p2p_connection(c.name)\\n right_id = f\\\"{smart_text(ro.id)}{c.name}\\\"\\n rcs += [\\n self.get_cs_item(\\n right_id,\\n c.name,\\n str(c.type.id),\\n c.type.name,\\n c.gender,\\n c.direction,\\n c.protocols,\\n not bool(oc),\\n valid,\\n disable_reason,\\n ro,\\n )\\n ]\\n id_ports_right[c.name] = right_id\\n wires = []\\n device_left = {}\\n device_right = {}\\n if lcs and rcs:\\n device_left[\\\"id\\\"] = smart_text(lo.id)\\n device_left[\\\"name\\\"] = lo.name\\n device_right[\\\"id\\\"] = smart_text(ro.id)\\n device_right[\\\"name\\\"] = ro.name\\n for p in checking_ports:\\n remote = self.get_remote_slot(p, lo, ro)\\n if remote:\\n wires.append(\\n {\\n \\\"left\\\": {\\\"id\\\": id_ports_left.get(p.name, 0), \\\"name\\\": p.name},\\n \\\"right\\\": {\\n \\\"id\\\": id_ports_right.get(remote.connection, 0),\\n \\\"name\\\": remote.connection,\\n },\\n }\\n )\\n # Forming cable\\n return {\\n \\\"left\\\": {\\\"connections\\\": lcs, \\\"device\\\": device_left},\\n \\\"right\\\": {\\\"connections\\\": rcs, \\\"device\\\": device_right},\\n \\\"cable\\\": [{\\\"name\\\": c.name, \\\"available\\\": True} for c in cables],\\n \\\"valid\\\": lcs and rcs and left_filter and right_filter,\\n \\\"wires\\\": wires,\\n }\",\n \"def create_conserved_pos_list(gpcr_pdb,gpcr_aa, i,my_pos, cons_pos_li, multiple_chains,chain_name):\\n my_pos_bw=my_pos.split(\\\"x\\\")[0]\\n add_chain_name=\\\"\\\"\\n if multiple_chains:\\n add_chain_name=\\\":\\\"+chain_name\\n while i < len(cons_pos_li):\\n cons_pos = cons_pos_li[i][0]\\n cons_pos_bw=cons_pos[1:]\\n cons_aa=cons_pos[0]\\n if my_pos_bw==cons_pos_bw:\\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\\n if pos_range:\\n cons_pos_li[i][2]=pos_range + add_chain_name\\n (my_aa,chain)=gpcr_aa[my_pos]\\n if my_aa != cons_aa:\\n cons_pos_li[i][0]=cons_pos+my_aa\\n i+=1\",\n \"def generate_lcs(x, y, id, N, nspot_min=50, nspot_max=500, incl_min=0,\\n incl_max=np.pi/4., amp_min=1, amp_max=100, pmin=.5,\\n pmax=90, tau_min=5, tau_max=20):\\n\\n params = [nspot_min, nspot_max, incl_min, incl_max, amp_min*rvar,\\n amp_max*rvar, pmin, pmax, tau_min, tau_max]\\n nspots, incl, periods, amps, tau = injection_params(N, params)\\n true_params = {'nspots': nspots, 'incl': incl, 'periods': periods,\\n 'amps': amps, 'tau': tau}\\n\\n xarr = np.zeros((len(x), N))\\n yarr = np.zeros((len(x), N))\\n for i in range(N):\\n print(i, \\\"of\\\", N)\\n res0, res1 = mklc(x, nspot=nspots[i], incl=incl[i], tau=tau[i],\\n p=periods[i])\\n med = np.median(res1[2, :])\\n ys = (res1[2, :] / med - 1) * amps[i] # median normalise and scale\\n yarr[:, i] = ys + y\\n xarr[:, i] = x\\n if N == 1:\\n return xarr.T[0], yarr.T[0], x, y, true_params\\n\\n # save the results\\n np.savetxt(\\\"lcs.txt\\\", yarr.T)\\n np.savetxt(\\\"xs.txt\\\", xarr.T)\\n np.savetxt(\\\"truth.txt\\\", np.vstack((nspots, incl, periods, amps, tau)).T)\\n\\n return xarr, yarr, true_params\",\n \"def find_conn_CXCY(atom, atom_list):\\n le_list = []\\n for element in identify_bonds(atom, atom_list):\\n if ((element[0].atom_name == \\\"CX\\\") or (element[0].atom_name == \\\"CY\\\")):\\n if (atom.z - element[0].z > 0):\\n le_list.append([element[0], 1])\\n else:\\n le_list.append([element[0], -1])\\n return le_list\",\n \"def connect_points(clipped, side1, side2, window):\\n edge = side1\\n while edge != side2:\\n clipped.append(window.points[0][edge])\\n edge = (edge - 1) % 4\",\n \"def findScalingCoeffsLimiter(self, PFC, lqCN, lqCF):\\n # Get R and Z vectors at the midplane\\n# R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\\n R_omp_sol = self.map_R_psi(1.0,PFC)\\n R_omp_min = R_omp_sol #this is a limited discharge so Rmin = Rlcfs\\n if lqCN > lqCF:\\n lqMax = lqCN\\n else:\\n lqMax = lqCF\\n R_omp_max = R_omp_sol + 20.0*lqMax #already in m\\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\\n if R_omp_max > max(PFC.ep.g['R']):\\n R_omp_max = max(PFC.ep.g['R']) #in meters now\\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\\n Z_omp = np.zeros(R_omp.shape)\\n\\n # Evaluate B at outboard midplane\\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\\n\\n #Find coordinate transformation vector at midplane\\n psiaxis = PFC.ep.g['psiAxis']\\n psiedge = PFC.ep.g['psiSep']\\n deltaPsi = np.abs(psiedge - psiaxis)\\n gradPsi = Bp_omp*R_omp\\n xfm = gradPsi / deltaPsi\\n\\n # transform hf width into flux space\\n lqCN_hat = lqCN*xfm\\n lqCF_hat = lqCF*xfm\\n\\n\\n #Calculate flux at midplane using gfile\\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\\n psi = psiN*(psiedge - psiaxis) + psiaxis\\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\\n s_hat = psiN - PFC.psiMinLCFS\\n\\n\\n print('psiMinLCFS: {:f}'.format(PFC.psiMinLCFS))\\n# print('un-normalized psiMinLCFS: {:f}'.format(PFC.ep.psiFunc_noN.ev(R_omp_sol,0.0)))\\n print('Minimum s_hat: {:f}'.format(s_hat.min()))\\n\\n\\n #integral in flux space\\n qCN_hat = np.exp(-s_hat / lqCN_hat)\\n qCF_hat = np.exp(-s_hat / lqCF_hat)\\n\\n #note: simps integration will fail if x variable (psi) is not monotonic\\n #reinke method\\n #intCN = simps(qCN_hat / B_omp, psi)\\n #intCF = simps(qCF_hat / B_omp, psi)\\n #menard method\\n intCN = simps(qCN_hat, psi)\\n intCF = simps(qCF_hat, psi)\\n\\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF)\\n #account for nonphysical power\\n if P0 < 0: P0 = -P0\\n #Scale to input power\\n q0 = self.Psol/P0\\n\\n #old method left for reference\\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF)\\n\\n return q0\",\n \"def connected_component(self, id1: int) -> list:\\n list1 = []\\n list2 = []\\n if id1 in self.dw_graph.nodes:\\n list1 = self.bfs(id1, False)\\n list2 = self.bfs(id1, True)\\n\\n list3 = []\\n temp=set(list2)\\n for value in list1 :\\n if value in temp:\\n list3.append(value)\\n self.dw_graph.nodes[value].distance=-10\\n list3.sort()\\n return list3\",\n \"def identify_leaflets_cluster(self,pts,vec,topologize_time_limit=30,max_count_asymmetry=0.05):\\n\\t\\timport scipy\\n\\t\\timport sklearn\\n\\t\\timport sklearn.neighbors\\n\\t\\timport sklearn.cluster\\n\\t\\tnlipids = len(pts)\\n\\t\\t#---time limit on the topologize function which joins broken bilayers e.g. a saddle that crosses PBCs\\n\\t\\ttry:\\n\\t\\t\\twith time_limit(topologize_time_limit): \\n\\t\\t\\t\\twrapper = topologize(pts,vec,\\n\\t\\t\\t\\t\\t**({'tol':self.topologize_tolerance} if self.topologize_tolerance else {}))\\n\\t\\texcept TimeoutException: \\n\\t\\t\\tstatus('topologize failed to join the bilayer. '\\n\\t\\t\\t\\t'if it is broken over PBCs e.g. a saddle, this is a serious error which may go undetected. '\\n\\t\\t\\t\\t'make sure you always inspect the topology later.',tag='error')\\n\\t\\t\\twrapper = np.zeros((len(pts),3))\\n\\t\\tfindframe = pts + wrapper*np.array(vec)\\n\\t\\t#---ensure that all points are in the box\\n\\t\\tfindframe += vec*(findframe<0) - vec*(findframe>vec)\\n\\t\\t#---previous calculation of connectivity was done manually\\n\\t\\tif False:\\n\\t\\t\\t#---conservative cutoff gets lots of nearby points\\n\\t\\t\\tcutoff = 10.0\\n\\t\\t\\tcutoff_short = 2.0\\n\\t\\t\\t#---make a K-D tree from the points\\n\\t\\t\\ttree = scipy.spatial.ckdtree.cKDTree(findframe,boxsize=np.concatenate((vec,vec))+0.*eps)\\n\\t\\t\\t#---find the nearest reference points for each instantaneous point\\n\\t\\t\\tclose,nns = tree.query(findframe,distance_upper_bound=cutoff,k=20)\\n\\t\\t\\t#---construct the neighbor list\\n\\t\\t\\tsubjects = np.where(np.all((close<cutoff,close>0),axis=0))\\n\\t\\t\\t#---get the pairs of neighbors\\n\\t\\t\\tsubjects,neighbors = subjects[0],nns[subjects]\\n\\t\\t\\tpds = np.ones((nlipids,nlipids))*0.0\\n\\t\\t\\tpds[tuple((np.arange(nlipids),np.arange(nlipids)))] = 0.0\\n\\t\\t\\tnears = np.where(np.all((close>0,close<=cutoff_short),axis=0))\\n\\t\\t\\tpds[tuple((nears[0],nns[nears]))] = 1.0#close[nears]\\n\\t\\t\\tpds[tuple((nns[nears],nears[0]))] = 1.0#close[nears]\\n\\t\\tconnectivity = sklearn.neighbors.kneighbors_graph(findframe,\\n\\t\\t\\tn_neighbors=self.cluster_neighbors,include_self=False)\\n\\t\\tward = sklearn.cluster.AgglomerativeClustering(n_clusters=2,\\n\\t\\t\\tconnectivity=connectivity,linkage='complete').fit(findframe)\\n\\t\\timono = ward.labels_\\n\\t\\tif np.mean(imono)==0.5: \\n\\t\\t\\tstatus('[STATUS] perfect split is %0.5f'%np.mean(imono))\\n\\t\\telif (np.all(np.array(imono)==0) or np.all(np.array(imono)==1) or \\n\\t\\t\\tnp.abs(np.mean(imono)-0.5)>=max_count_asymmetry):\\n\\t\\t\\tstatus('[STATUS] split is %0.5f'%np.mean(imono))\\n\\t\\t\\tstatus('[STATUS] one side has %d'%np.sum(imono))\\n\\t\\t\\tstatus('[WARNING] leaflets were not distinguished')\\n\\t\\t\\traise Exception('[ERROR] failed to identify leaflets. '\\n\\t\\t\\t\\t'DEVELOPMENT NOTE!? use legacy or a different cutoff?')\\n\\t\\telse: status('[STATUS] some lipids might be flipped %d %.5f'%(np.sum(imono),np.mean(imono)))\\n\\t\\treturn np.array(imono)\",\n \"def findcc(self):\\n for vertex in self.graph.vertices:\\n if vertex not in self.preOrderNumbers:\\n self.dfs(vertex)\\n return self.scComponents\",\n \"def __generate_connecticity_increasing_canidates(self,k=3):\\n result = set()\\n \\n if k < 3:\\n k = 3\\n \\n self.__logger.info(\\\"IMPROOVE_NETWORK: Try to seek {} nodes which are currently bad connected\\\".format(k))\\n candidates = heapq.nlargest(3*k, self.__generate_all_shortest_paths(), key=itemgetter(0))\\n\\n for _, path in candidates:\\n result.add(path[0])\\n result.add(path[-1])\\n\\n self.__logger.info(\\\"IMPROOVE_NETWORK: Found {} candidates which are currently bad connected\\\".format(len(result))) \\n if len(result) <= k:\\n return list(result)\\n self.__logger.info(\\\"IMPROOVE_NETWORK: Sample {} items from the candidates as was requested\\\".format(k))\\n tmp = list(result)\\n random.shuffle(tmp)\\n return tmp[0:k]\",\n \"def find_all_feedbacks_Tarjan(ls_nodenames, lt_links):\\n \\n ll_SCC = SCC_analysis.decompose_SCC(ls_nodenames, lt_links)\\n ll_feedbacks = []\\n for l_SCC in ll_SCC:\\n lt_links_in_SCC = basic_topology_functions.extract_subnet_topology(lt_links, l_SCC)\\n print(\\\"feedbacks are calculated in subnetwork with \\\",len(l_SCC),\\\" nodes\\\")\\n \\n dic_startnode_endnodes = {}\\n for s_nodename in l_SCC:\\n dic_startnode_endnodes[s_nodename] = []\\n for t_link in lt_links_in_SCC:\\n if t_link[0] == s_nodename:\\n dic_startnode_endnodes[s_nodename].append(t_link[-1])\\n #print(dic_startnode_endnodes)\\n dic_node_counter = {}\\n for s_nodename in l_SCC:\\n dic_node_counter[s_nodename] = len(dic_startnode_endnodes[s_nodename])-1\\n #print(dic_node_counter)\\n for s_node_trajectorystart in dic_node_counter.keys():\\n if dic_node_counter[s_node_trajectorystart] == -1: #this means that all feedback containing this node are all calculated\\n continue\\n else:\\n l_trajectory = [s_node_trajectorystart]\\n while l_trajectory:\\n #print(l_trajectory)\\n i_counter = dic_node_counter[l_trajectory[-1]]\\n if i_counter == -1:\\n dic_node_counter[l_trajectory[-1]] = len(dic_startnode_endnodes[l_trajectory[-1]])-1\\n l_trajectory.pop()\\n if l_trajectory:\\n dic_node_counter[l_trajectory[-1]] -= 1\\n else:\\n s_node_next = dic_startnode_endnodes[l_trajectory[-1]][i_counter]\\n if s_node_next == s_node_trajectorystart:\\n ll_feedbacks.append(list(l_trajectory))\\n if len(ll_feedbacks)%20000 == 0:\\n print(\\\"calculated feedbacks are now \\\",len(ll_feedbacks))\\n \\n if s_node_next in l_trajectory:\\n dic_node_counter[l_trajectory[-1]] -= 1\\n else:\\n l_trajectory.append(s_node_next)\\n dic_startnode_endnodes[s_node_trajectorystart] = []\\n dic_node_counter[s_node_trajectorystart] =-1\\n \\n return ll_feedbacks\",\n \"def GetMatchedSubContourLists(\\n scListRef,\\n scList,\\n allValsByFrame,\\n orderOfSCsByValue,\\n splitLength=1,\\n fixedNumInteriorPoints=None,\\n):\\n ## NOT DONE! MERGE LATER??\\n return simplifiedSCListRef, simplifiedSCList\",\n \"def cheapCycling(SList,CList):\\n N = len(CList)\\n nodes= list(range(N))\\n Udict = dict(zip(nodes,CList)) #dictionary nodes:neighbours\\n queue = deque() #things to check\\n checked = {} #checked nodes to avoid double checking\\n stations=np.zeros((N,2))#node:arrival output\\n\\n min_arr = 1000000 #initialise fat value\\n arr_node=-1\\n \\n min_dep = 1000000\\n dep_node=-1\\n\\n while Udict:\\n #node = Udict.pop(next(iter(Udict))) #extract first node\\n node = next(iter(Udict)) #select first node\\n queue.append(node) #add node to queue\\n while queue: #while queue is non empty\\n node = queue.popleft() #set/extract node to element of queue\\n Udict.pop(node) #make sure is also removed from overarching dict\\n for nb in CList[node]: #neighbours of node\\n if nb not in checked:\\n if SList[nb][0] <min_arr: #check if new minimum\\n min_arr = SList[nb][0]\\n arr_node = nb\\n if SList[nb][1] <min_dep: #same but for departure\\n min_dep = SList[nb][1]\\n dep_node= nb\\n queue.append(nb)\\n checked[nb] = 1\\n checked[node]=1\\n \\n stations[list(checked.keys()),0] = arr_node #dropping in the cheapest arr and dep nodes for all nodes in connected part\\n stations[list(checked.keys()),1] = dep_node\\n checked={} #reset checked to empty for new connected part IMPORTANT!\\n min_arr=1000000 #reset minimum values\\n min_dep=1000000 #reset min dep values\\n\\n return stations\",\n \"def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\\n # number of nodes\\n nx = 5 # along x\\n ny = 5 # along y\\n\\n # getting integration points\\n nint = 4\\n points, weights = get_points_weights(nint=nint)\\n\\n # geometry\\n a = 3 # along x\\n b = 3 # along y\\n\\n # material properties\\n E = 200e9\\n nu = 0.3\\n laminaprop = (E, E, nu)\\n stack = [0]\\n h = 0.001\\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\\n\\n # creating mesh\\n x = np.linspace(0, a, nx)\\n y = np.linspace(0, b, ny)\\n xmesh, ymesh = np.meshgrid(x, y)\\n\\n # node coordinates and position in the global matrix\\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\\n nids = 1 + np.arange(ncoords.shape[0])\\n nid_pos = dict(zip(nids, np.arange(len(nids))))\\n\\n # identifying nodal connectivity for plate elements\\n # similar than Nastran's CQUAD4\\n #\\n # ^ y\\n # |\\n #\\n # 4 ________ 3\\n # | |\\n # | | --> x\\n # | |\\n # |_______|\\n # 1 2\\n\\n\\n nids_mesh = nids.reshape(nx, ny)\\n n1s = nids_mesh[:-1, :-1].flatten()\\n n2s = nids_mesh[1:, :-1].flatten()\\n n3s = nids_mesh[1:, 1:].flatten()\\n n4s = nids_mesh[:-1, 1:].flatten()\\n\\n num_elements = len(n1s)\\n print('num_elements', num_elements)\\n\\n N = DOF*nx*ny\\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n init_k_KC0 = 0\\n init_k_KG = 0\\n\\n plates = []\\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\\n plate = BFSPlate2D()\\n plate.n1 = n1\\n plate.n2 = n2\\n plate.n3 = n3\\n plate.n4 = n4\\n plate.c1 = DOF*nid_pos[n1]\\n plate.c2 = DOF*nid_pos[n2]\\n plate.c3 = DOF*nid_pos[n3]\\n plate.c4 = DOF*nid_pos[n4]\\n plate.ABD = lam.ABD\\n plate.lex = a/(nx - 1)\\n plate.ley = b/(ny - 1)\\n plate.init_k_KC0 = init_k_KC0\\n plate.init_k_KG = init_k_KG\\n update_KC0(plate, points, weights, Kr, Kc, Kv)\\n init_k_KC0 += KC0_SPARSE_SIZE\\n init_k_KG += KG_SPARSE_SIZE\\n plates.append(plate)\\n\\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\\n\\n # applying boundary conditions\\n\\n # locating nodes\\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\\n\\n x = ncoords[:, 0]\\n y = ncoords[:, 1]\\n\\n # applying boundary conditions\\n # simply supported\\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\\n bk[2::DOF] = check\\n check = isclose(x, 0) | isclose(x, a)\\n bk[3::DOF] = check\\n # point supports\\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\\n bk[0::DOF] = check\\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\\n bk[1::DOF] = check\\n\\n # unconstrained nodes\\n bu = ~bk # logical_not\\n\\n # defining external force vector\\n fext = np.zeros(KC0.shape[0], dtype=float)\\n\\n # applying unitary load along u at x=a\\n # nodes at vertices get 1/2 the force\\n for plate in plates:\\n pos1 = nid_pos[plate.n1]\\n pos2 = nid_pos[plate.n2]\\n pos3 = nid_pos[plate.n3]\\n pos4 = nid_pos[plate.n4]\\n if isclose(x[pos3], a):\\n Nxx = -1\\n xi = +1\\n elif isclose(x[pos1], 0):\\n Nxx = +1\\n xi = -1\\n else:\\n continue\\n lex = plate.lex\\n ley = plate.ley\\n indices = []\\n c1 = DOF*pos1\\n c2 = DOF*pos2\\n c3 = DOF*pos3\\n c4 = DOF*pos4\\n cs = [c1, c2, c3, c4]\\n for ci in cs:\\n for i in range(DOF):\\n indices.append(ci + i)\\n fe = np.zeros(4*DOF, dtype=float)\\n for j in range(nint):\\n eta = points[j]\\n plate.update_Nu(xi, eta)\\n Nu = np.asarray(plate.Nu)\\n fe += ley/2*weights[j]*Nu*Nxx\\n fext[indices] += fe\\n\\n Kuu = KC0[bu, :][:, bu]\\n fextu = fext[bu]\\n\\n # static solver\\n uu = spsolve(Kuu, fextu)\\n u = np.zeros(KC0.shape[0], dtype=float)\\n u[bu] = uu\\n\\n if plot_static:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n uplot = u[0::DOF].reshape(nx, ny).T\\n vplot = u[1::DOF].reshape(nx, ny).T\\n print('u extremes', uplot.min(), uplot.max())\\n print('v extremes', vplot.min(), vplot.max())\\n levels = np.linspace(uplot.min(), uplot.max(), 300)\\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n # eigenvalue solver\\n\\n # getting integration points\\n for plate in plates:\\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\\n KGuu = KG[bu, :][:, bu]\\n\\n # solving modified generalized eigenvalue problem\\n # Original: (KC0 + lambda*KG)*v = 0\\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\\n num_eigenvalues = 5\\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\\n tol=1e-6, sigma=1., mode='cayley')\\n eigvals = -1./eigvals\\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\\n eigvecs[bu, :] = eigvecsu\\n\\n if plot_lb:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n mode = 0\\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\\n levels = np.linspace(wplot.min(), wplot.max(), 300)\\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\\n assert isclose(kc, 6.6, rtol=0.05)\",\n \"def FindClumps_graph(self):\\n # IMPORT STUFF\\n import string\\n # END IMPORT\\n \\n maxima = self['CL_LOC'].copy()\\n maxima = num.where(maxima)\\n maxima = (maxima[1],maxima[0])\\n detectimg = self['STAMP'].copy()\\n \\n id = self._getGraphId()\\n root = 'FindClumps_%s' % (id,)\\n pngname = root + '.png' ; epsname = root + '.eps'\\n jpgname = root + '.jpg'\\n\\n doStamp(detectimg,pngname,format='PNG')\\n Convert(pngname,jpgname)\\n \\n Painted = Paint(jpgname)\\n Painted.load()\\n Painted.DrawCross(maxima,length=7,color='green')\\n \\n strpeaks = string.strip('%i'% (self['M_NUM_CL']))\\n text = 'NC=%s' % strpeaks \\n \\n # Painted.Graffiti(text,commtextpos)\\n \\n Painted.save(jpgname)\\n Painted.release()\\n \\n Convert(jpgname,epsname)\\n os.system('rm %s %s' % (pngname,jpgname))\\n self['figures']['FindClumps'] = epsname\\n self['figcomms']['FindClumps'] = text\",\n \"def limited_information_privacy_lb(P0: np.ndarray,\\r\\n P1: np.ndarray,\\r\\n initial_points: int = 1,\\r\\n max_iterations: int = 30,\\r\\n solver=cp.ECOS,\\r\\n debug=False):\\r\\n P0, P1 = sanity_check_probabilities(P0, P1)\\r\\n initial_points = int(initial_points) if initial_points >= 1 else 1\\r\\n max_iterations = initial_points if initial_points > max_iterations else int(\\r\\n max_iterations)\\r\\n\\r\\n na, ns = P0.shape[0], P0.shape[1]\\r\\n\\r\\n best_res, best_xi1, best_xi0 = np.inf, None, None\\r\\n # Compute KL divergences\\r\\n I = compute_KL_divergence_models(P0, P1)\\r\\n\\r\\n # Loop through initial points and return best result\\r\\n i = 0\\r\\n n = 0\\r\\n while i == 0 or (i < initial_points and n < max_iterations):\\r\\n n += 1\\r\\n gamma = cp.Variable(1)\\r\\n xi0 = cp.Variable((ns, na), nonneg=True)\\r\\n xi1 = cp.Variable((ns, na), nonneg=True)\\r\\n\\r\\n kl_div_statinary_dis = 0\\r\\n for s in range(ns):\\r\\n kl_div_statinary_dis += cp.entr(cp.sum(xi1[s, :]))\\r\\n\\r\\n # stationarity constraints\\r\\n stationarity_constraint = 0\\r\\n for a in range(na):\\r\\n stationarity_constraint += xi1[:, a].T @ (P1[a, :, :] - np.eye(ns))\\r\\n\\r\\n constraints = [stationarity_constraint == 0, cp.sum(xi1) == 1]\\r\\n\\r\\n # Privacy constraints\\r\\n privacy_constraint = 0\\r\\n for s in range(ns):\\r\\n constraints += [cp.sum(xi0[s, :]) == 1]\\r\\n for y in range(ns):\\r\\n privacy_constraint += cp.kl_div(\\r\\n xi1[s, :] @ P1[:, s, y], xi0[s, :] @ P0[:, s, y]) + (\\r\\n xi1[s, :] @ P1[:, s, y]) - (xi0[s, :] @ P0[:, s, y])\\r\\n\\r\\n constraints += [privacy_constraint <= gamma]\\r\\n objective = gamma + kl_div_statinary_dis\\r\\n\\r\\n # Solve problem\\r\\n problem = cp.Problem(cp.Minimize(objective), constraints)\\r\\n if not dccp.is_dccp(problem):\\r\\n raise Exception('Problem is not Concave with convex constraints!')\\r\\n try:\\r\\n result = problem.solve(\\r\\n method='dccp', ccp_times=1, verbose=debug, solver=solver)\\r\\n except Exception as err:\\r\\n continue\\r\\n\\r\\n # Check if results are better than previous ones\\r\\n if result[0] is not None:\\r\\n i += 1\\r\\n if result[0] < best_res:\\r\\n best_res, best_xi1, best_xi0 = result[0], xi1.value, xi0.value\\r\\n\\r\\n # Make sure to normalize the results\\r\\n best_xi0 += eps\\r\\n best_xi1 += eps\\r\\n best_xi0 /= np.sum(best_xi0) if not np.isclose(np.sum(best_xi0), 0) else 1.\\r\\n best_xi1 /= np.sum(best_xi1) if not np.isclose(np.sum(best_xi1), 0) else 1.\\r\\n return best_res, best_xi1, best_xi0\",\n \"def cinters_circle(self, c):\\r\\n if self.__segments == None:\\r\\n self.__load_segments()\\r\\n \\r\\n result = []\\r\\n for segment in self.__segments:\\r\\n points = c.inters_segment(segment)\\r\\n for p in points:\\r\\n result.append(p) \\r\\n \\r\\n return result\",\n \"def test_get_lcp(self):\\n\\n expected = [0, 6, 5, 0, 5, 4, 0, 4, 3, 0, 3, 2, 0, 2, 1, 0, 1, 0, 0, 0, 0]\\n\\n self.assertEqual(self.sf.get_lcp(), expected)\",\n \"def find_endpoints(batch_trajectories):\\n # empty lists to fill\\n site_lats = []\\n site_lons = []\\n last_lats = []\\n last_lons = []\\n lats_150 = []\\n lons_150 = [] \\n last_times = []\\n times_150 = []\\n last_sst = []\\n sst_150 = []\\n \\n # temporary lists as placeholders\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n for speed in range(len(batch_trajectories)):\\n # working with one speed at a time means working with one nc file at\\n # a time\\n \\n # reset temporary lists\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n # extract variables into lists\\n lats = batch_trajectories[speed].variables['lat'][:]\\n lons = batch_trajectories[speed].variables['lon'][:]\\n lats150 = batch_trajectories[speed].variables['lat150'][:]\\n lons150 = batch_trajectories[speed].variables['lon150'][:]\\n times = batch_trajectories[speed].variables['time'][:]\\n ssts = batch_trajectories[speed].variables['temp'][:]\\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\\n\\n # if a particle is deleted before time is up, values are masked. \\n # We'd like to get the last valid number.\\n for trajectory in range(len(lats)):\\n i = -1 # index for the last value\\n while np.ma.is_masked(lats[trajectory][i]) is True:\\n i -= 1 # if the value is masked, go to one value sooner\\n \\n j = i # use j for the 150m values\\n while lats150[trajectory][j] > 0:\\n # we want the first index where the latitude is recorded.\\n # j is actually the last one where it's not recorded, so we\\n # extract the information at index j+1\\n j -= 1\\n\\n # once i and j are determined for a trajectory, we can extract the\\n # variables and append them to temporary lists.\\n temp_site_lats.append(lats[trajectory][0])\\n temp_site_lons.append(lons[trajectory][0])\\n temp_lats.append(lats[trajectory][i])\\n temp_lons.append(lons[trajectory][i])\\n temp_lats150.append(lats150[trajectory][j+1])\\n temp_lons150.append(lons150[trajectory][j+1])\\n temp_times.append(times[trajectory][i])\\n temp_sst.append(ssts[trajectory][i])\\n temp_sst150.append(ssts_150[trajectory][j+1])\\n temp_times150.append(times[trajectory][j+1])\\n \\n # after the temporary lists are appended by sinking speed, they\\n # are appended to the big lists that are returned by the function.\\n # this keeps the structure of being separated by sinking speed.\\n site_lats.append(temp_site_lats)\\n site_lons.append(temp_site_lons)\\n last_lats.append(temp_lats)\\n last_lons.append(temp_lons)\\n lats_150.append(temp_lats150)\\n lons_150.append(temp_lons150)\\n last_times.append(temp_times)\\n times_150.append(temp_times150)\\n last_sst.append(temp_sst)\\n sst_150.append(temp_sst150)\\n \\n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\\\\n last_times, times_150, last_sst, sst_150\",\n \"def computesWingConnexions(self):\\n logger.warning(\\\"!!! WARINING !!!!\\\")\\n logger.warning(\\\"BE CERTAIN THAT CPACS FILE HAS THE HORIZONTAL TAIL\\\")\\n logger.warning(\\\"DEFINED BEFORE THE VERTICAL TAIL!!!!\\\")\\n if self.nWings <= 1:\\n logger.info(\\\"No wing connexions needed\\\")\\n elif self.nWings > 1 and self.nFuselage < 1:\\n logger.error(\\\"Multiple wings with no fuselage! Mesh can not be computed\\\")\\n sys.exit()\\n else:\\n ws_connextionsPoints = self.nWings + self.nFuselage - 1\\n # if self.nFuselage > 0:\\n # ws_connextionsPoints = self.nWings\\n # else:\\n # ws_connextionsPoints = self.nWings -1\\n\\n # ws: wings\\n # d: distance\\n # L: left, R: right, c: center\\n connectedNodes = np.zeros((ws_connextionsPoints,5))\\n for i in range(ws_connextionsPoints):\\n \\\"\\\"\\\"\\n for each wing there is 3 points that need to be taken into\\n account:\\n 1) Left tip position[0]\\n 2) center [np.floor(nNodes/2))]\\n WARNING: keep in mind that symmetric wings always have \\n an odd number of points!\\n 3) right tip position[-1]\\n \\\"\\\"\\\"\\n if self.nFuselage > 0:\\n wingIndex = i+1\\n else:\\n wingIndex = i\\n # logger.debug(\\\"Wing index = \\\"+str(wingIndex))\\n # N = len(self.aircraftNodesPoints[i])\\n currentWingNpoints = len(self.aircraftNodesPoints[wingIndex])\\n if currentWingNpoints > 2:\\n c = int(np.floor(len(self.aircraftNodesPoints[wingIndex])/2))\\n else:\\n c = 0\\n # logger.debug(\\\"c = \\\"+str(c))\\n ws_identifiers = np.empty((ws_connextionsPoints,5))\\n\\n for j in range(ws_connextionsPoints+1):\\n logger.debug(\\\"wingIndex,j = \\\"+str(wingIndex)+\\\" \\\"+str(j))\\n if wingIndex != j:\\n # c: stands for current\\n logger.debug(\\\"True with wingIndex,j = \\\"+str(wingIndex)+\\\" \\\"+str(j))\\n # Computes the distances between all point\\n dist_l = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][0], axis=1)\\n if currentWingNpoints > 2:\\n dist_c = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][c], axis=1)\\n else:\\n dist_c = dist_l\\n dist_r = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][-1],axis=1)\\n\\n # Gets the index of the minimal distance between all point\\n index_l = np.argmin(dist_l)\\n if currentWingNpoints > 2:\\n index_c = np.argmin(dist_c)\\n else:\\n index_c = index_l\\n index_r = np.argmin(dist_r)\\n indexes = np.array([index_l, index_c, index_r])\\n\\n # gets the minimal distance for each wing part\\n minDist_l = dist_l[index_l]\\n if currentWingNpoints > 2:\\n minDist_c = dist_c[index_c]\\n else:\\n minDist_c = minDist_l\\n minDist_r = dist_r[index_r]\\n minDist = np.array([minDist_l,minDist_c,minDist_r])\\n\\n k = np.argmin(minDist)\\n minimalDistance = minDist[k]\\n m = indexes[k]\\n r = len(self.aircraftNodesPoints[wingIndex])\\n tab = np.array([0,c,r])\\n k = tab[k]\\n\\n # minimalDistance: distance between both of these points\\n identifier = np.array([wingIndex,j,k,m,minimalDistance])\\n # logger.debug(\\\"Identifier \\\\n\\\"+str(identifier))\\n if j < wingIndex:\\n ws_identifiers[j] = identifier\\n else:\\n ws_identifiers[j-1] = identifier\\n \\n index2 = np.argmin(ws_identifiers[:,4])\\n old = np.array([ws_identifiers[index2,2],\\n ws_identifiers[index2,3],\\n ws_identifiers[index2,0],\\n ws_identifiers[index2,1],\\n ws_identifiers[index2,4]])\\n if old in connectedNodes and i > 1:\\n logger.warning(\\\"Found a matching connexion\\\")\\n logger.debug(old)\\n logger.debug(ws_identifiers)\\n ws_identifiers = np.delete(ws_identifiers,index2,0)\\n logger.debug(ws_identifiers)\\n index2 = np.argmin(ws_identifiers[:,4])\\n connectedNodes[i] = ws_identifiers[index2]\\n logger.debug(\\\"connected Nodes: \\\\n\\\"+str(connectedNodes[i]))\\n # logger.debug(connectedNodes)\\n \\n self.aircraftConnectedNodes.append(connectedNodes)\\n self.rigidNodesAdder()\\n # sys.exit()\",\n \"def get_data_lcc(data):\\n data_lcc = deepcopy(data)\\n edge_index_sparse = edge_index_2_csr(data.edge_index, data.num_nodes)\\n lcc = largest_connected_components(edge_index_sparse)\\n edge_index_lcc_sparse = edge_index_sparse[lcc][:, lcc].tocoo()\\n data_lcc.edge_index = torch.stack(list(to_Variable(edge_index_lcc_sparse.row, edge_index_lcc_sparse.col))).long()\\n\\n data_lcc.x = data.x[lcc]\\n data_lcc.y = data.y[lcc]\\n data_lcc.train_mask = data.train_mask[lcc]\\n data_lcc.val_mask = data.val_mask[lcc]\\n data_lcc.test_mask = data.test_mask[lcc]\\n return data_lcc\",\n \"def read_pslg(file_name):\\n with open(file_name, \\\"r\\\") as fp:\\n components = fp.read().split(\\\"component: \\\")[1:]\\n \\n lpoints, lconnect_left, lconnect_right = [], [], []\\n index = 0\\n \\n for component in components:\\n raw_points = component.split(\\\"\\\\n\\\")[1:-1]\\n points = [list(map(float, line.split()[1:3])) for line in raw_points]\\n connect_left = np.roll(np.arange(index, index + len(raw_points), 1), -1)\\n connect_right = np.roll(connect_left, 2)\\n \\n lpoints = lpoints + points\\n lconnect_left.append(connect_left)\\n lconnect_right.append(connect_right)\\n \\n index += len(raw_points)\\n \\n return np.array(lpoints), np.hstack(lconnect_left).astype(int), np.hstack(lconnect_right).astype(int)\",\n \"def get_local_list_for_neuron(current_neuron_index=current_neuron_index,\\n minx='',\\n maxx='',\\n acts=acts):\\n current_neuron = acts.get_activations_for_neuron(current_neuron_index) # get the neuron's data\\n x_data = current_neuron.vector # get the activations without classes\\n if minx == '':\\n minx = min(x_data) # this grabs all the points\\n elif minx == 0:\\n minx = min([x for x in x_data if x > 0.0])\\n # grab everything above 0 - special case, we don't include 0\\n # this changed grab_points_for_cluster from x >= 0 to x > 0\\n if maxx == '':\\n maxx =max(x_data)\\n # grab your list of points\\n local_list, selected_activations = grab_points_for_a_cluster(current_neuron_index,\\n min_selected_x_data=minx,\\n max_selected_x_data=maxx,\\n acts=acts,\\n x_data=x_data,\\n verbose=verbose)\\n return local_list, selected_activations, x_data\",\n \"def pointListForCurve(x, y, type):\\n\\n\\tif x < 10:\\n\\t\\txString = \\\"0%d\\\" % x\\n\\telse:\\n\\t\\txString = \\\"%d\\\" % x\\n\\n\\tif x < 11:\\n\\t\\txMString = \\\"0%d\\\" % (x - 1)\\n\\telse:\\n\\t\\txMString = \\\"%d\\\" % (x - 1)\\n\\n\\tif x < 9:\\n\\t\\txPString = \\\"0%d\\\" % (x + 1)\\n\\telse:\\n\\t\\txPString = \\\"%d\\\" % (x + 1)\\n\\n\\tif x < 8:\\n\\t\\txPPString = \\\"0%d\\\" % (x + 2)\\n\\telse:\\n\\t\\txPPString = \\\"%d\\\" % (x + 2)\\n\\n\\tif y < 11:\\n\\t\\tyMString = \\\"0%d\\\" % (y - 1)\\n\\telse:\\n\\t\\tyMString = \\\"%d\\\" % (y - 1)\\n\\n\\tif y < 9:\\n\\t\\tyPString = \\\"0%d\\\" % (y + 1)\\n\\telse:\\n\\t\\tyPString = \\\"%d\\\" % (y + 1)\\n\\n\\tif y < 8:\\n\\t\\tyPPString = \\\"0%d\\\" % (y + 2)\\n\\telse:\\n\\t\\tyPPString = \\\"%d\\\" % (y + 2)\\n\\n\\tif y < 10:\\n\\t\\tyString = \\\"0%d\\\" % y\\n\\telse:\\n\\t\\tyString = \\\"%d\\\" % y\\n\\n\\tinnerRadius = 54.0 / 64.0\\n\\touterRadius = 87.0 / 64.0\\n\\n\\tslices = 10\\n\\n\\t# Dots are numbered as xxyy[IO]z\\n\\t# The I means it is the inside trek, the O the outside\\n\\t# The z is which particular dot it is (0-9)\\n\\t# Note that all paths are marked as being inside the top-left square\\n\\t# Except for entrence and exit dots.\\n\\t# Curves are generated from star + 10 to end - 10\\n\\n\\tif type == 8:\\t\\t\\t# Bottom right\\n\\t\\tcenterX = 25.0 / 64.0\\n\\t\\tcenterY = 25.0 / 64.0\\n\\t\\tstart = 0.0\\n\\t\\tend = 90.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sTL\\\" % (xPString, yString), 0.25, 0.25, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sBL\\\" % (xString, yPString), 0.25, 0.75, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sTL\\\" % (xString, yPString), 0.25, 0.25, [\\\"%s%sTR\\\" % (xMString, yPString)]]\\n\\t\\texitOut =\\t[\\\"%s%sTR\\\" % (xPString, yString), 0.75, 0.25, [\\\"%s%sBR\\\" % (xPString, yMString)]]\\n\\n\\t\\tendIn = \\\"%s%sTL\\\" % (xString, yPString)\\n\\t\\tendOut = \\\"%s%sTR\\\" % (xPString, yString)\\n\\n\\telif type == 9:\\t\\t\\t# Bottom left\\n\\t\\tcenterX = 103.0 / 64.0\\n\\t\\tcenterY = 25.0 / 64.0\\n\\t\\tstart = 90.0\\n\\t\\tend = 180.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sTR\\\" % (xPString, yPString), 0.75, 0.25, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sTR\\\" % (xString, yString), 0.75, 0.25, [\\\"%s%sBR\\\" % (xString, yMString)]]\\n\\t\\texitOut =\\t[\\\"%s%sBR\\\" % (xPString, yPString), 0.75, 0.75, [\\\"%s%sBL\\\" % (xPPString, yPString)]]\\n\\n\\t\\tendIn = \\\"%s%sTR\\\" % (xString, yString)\\n\\t\\tendOut = \\\"%s%sBR\\\" % (xPString, yPString)\\n\\n\\telif type == 10:\\t\\t# Top left\\n\\t\\tcenterX = 103.0 / 64.0\\n\\t\\tcenterY = 103.0 / 64.0\\n\\t\\tstart = 180.0\\n\\t\\tend = 270.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sBR\\\" % (xString, yPString), 0.75, 0.75, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sTR\\\" % (xPString, yString), 0.75, 0.25, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sBR\\\" % (xPString, yString), 0.75, 0.75, [\\\"%s%sBL\\\" % (xPPString, yString)]]\\n\\t\\texitOut =\\t[\\\"%s%sBL\\\" % (xString, yPString), 0.25, 0.75, [\\\"%s%sTL\\\" % (xString, yPPString)]]\\n\\n\\t\\tendIn = \\\"%s%sBR\\\" % (xPString, yString)\\n\\t\\tendOut = \\\"%s%sBL\\\" % (xString, yPString)\\n\\n\\telse: # type == 11:\\t\\t# Top right\\n\\t\\tcenterX = 25.0 / 64.0\\n\\t\\tcenterY = 103.0 / 64.0\\n\\t\\tstart = 270.0\\n\\t\\tend = 360.0\\n\\n\\t\\tenterIn =\\t[\\\"%s%sBL\\\" % (xString, yString), 0.25, 0.75, [\\\"%s%sI0\\\" % (xString, yString)]]\\n\\t\\tenterOut =\\t[\\\"%s%sBR\\\" % (xPString, yPString), 0.75, 0.75, [\\\"%s%sO0\\\" % (xString, yString)]]\\n\\t\\texitIn =\\t[\\\"%s%sBL\\\" % (xPString, yPString), 0.25, 0.75, [\\\"%s%sTL\\\" % (xPString, yPPString)]]\\n\\t\\texitOut =\\t[\\\"%s%sTL\\\" % (xString, yString), 0.25, 0.25, [\\\"%s%sTR\\\" % (xMString, yString)]]\\n\\n\\t\\tendIn = \\\"%s%sBL\\\" % (xPString, yPString)\\n\\t\\tendOut = \\\"%s%sTL\\\" % (xString, yString)\\n\\n\\tpointList = [enterIn, enterOut, exitIn, exitOut]\\n\\n\\tstring = \\\"%s%s\\\" % (xString, yString)\\n\\tstep = ((end - 1) - (start + 1)) / float(slices)\\n\\n\\tfor i in range(slices):\\n\\n\\t\\tangle = radians(start + step * i)\\n\\n\\t\\tif i < 9:\\n\\t\\t\\ttemp = [\\\"%sI%d\\\" % (string, i), centerX + cos(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[\\\"%sI%d\\\" % (string, i + 1)]]\\n\\t\\telse:\\n\\t\\t\\ttemp = [\\\"%sI%d\\\" % (string, i), centerX + cos(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[endIn]]\\n\\n\\t\\tpointList.append(temp)\\n\\n\\t\\tangle = radians(start + step * (10 - i))\\n\\n\\t\\tif i < 9:\\n\\t\\t\\ttemp = [\\\"%sO%d\\\" % (string, i), centerX + cos(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[\\\"%sO%d\\\" % (string, i + 1)]]\\n\\t\\telse:\\n\\t\\t\\ttemp = [\\\"%sO%d\\\" % (string, i), centerX + cos(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcenterY + sin(angle) * outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t[endOut]]\\n\\n\\t\\tpointList.append(temp)\\n\\n\\treturn pointList\",\n \"def get_neighbors(point):\\n pt = point.copy()\\n output= [point.copy() for i in range(4)]\\n output[0:2] = map(Point.setY, output[0:2], [pt.getY()+ i for i in range(-1,2,2)])\\n output[2:4]= map(Point.setX, output[2:4], [pt.getX()+ i for i in range(-1,2,2)])\\n return output\",\n \"def avCDNC(CL,abovesize=nan,uppersize=nan,inst=\\\"FSSP96\\\",scan=0):\\n if len(CL.times[\\\"verticloud\\\"])<=scan:\\n print(\\\"[avCDNC] No vertical scan for this cloud.\\\")\\n return nan\\n else:\\n ts=CL.times[\\\"verticloud\\\"][scan] # times of the vertical scan\\n pos=[i for i,x in enumerate(CL.sd) if inst.lower() in x[\\\"Distname\\\"].lower()]; \\n if len(pos)<=0: cancel=1; raise ValueError(\\\"This instrument name has not been found (inst=%s).\\\" % inst)\\n else: pos=pos[0]\\n calt=[i for i,x in enumerate(CL.dttl) if x == 'altitude']; calt=calt[0]\\n ctim=[i for i,x in enumerate(CL.dttl) if x == 'time']; ctim=ctim[0]\\n alt=CL.data[calt]\\n tim=CL.data[ctim]\\n clwc=[i for i,x in enumerate(CL.dttl) if x == 'LWC']; \\n if len(clwc)>1: print(\\\"[avCDNC] Multiple LWC found.\\\"); lwc=np.ones((2,))*NaN; lwctime=ts # LWC found in the basic data\\n elif len(clwc)==1: lwc=CL.data[clwc[0]]; lwctime=tim; \\n else: # looking for LWC in the extradata\\n posx=[] \\n for i,L in enumerate(CL.extrattl): # for all extra datasets available\\n posx=posx+[[i,j] for j,x in enumerate(L) if x.lower() == 'lwc'] # check all titles matching with LWC\\n if len(posx)==1: \\n lwc=CL.extradata[posx[0][0]][posx[0][1]] # loading the LWC data\\n j=[j for j,x in enumerate(CL.extrattl[i]) if x.lower() == 'time'][0]\\n lwctime=CL.extradata[posx[0][0]][j] # loading associated time stamp\\n else: print(\\\"[avCDNC] No LWC (or multiple) was found in the basic data or the extra data.\\\"); return nan\\n \\n \\n timtc=CL.sd[pos][\\\"time\\\"] # time corresponding to the concentration tc\\n # find shortest common time stamp\\n ta1=np.max([lwctime[0],tim[0],timtc[0],ts[0]]); ta2=np.min([lwctime[-1],tim[-1],timtc[-1],ts[1]]); \\n taix=[nonzero((timtc>=ta1)*(timtc<=ta2))[0]]; \\n usedtime=timtc[taix]\\n if len(usedtime)==0: WA=nan # weighted average is not calculable (no data for the vertical scan)\\n else:\\n tc=samac.dNdlogDp2N(CL.sd[pos],abovesize,uppersize)[taix] # total concentration between above- and upper-size\\n test=tim.__array__()==timtc\\n if len(tim)==len(timtc): \\n if (tim.__array__()==timtc).all()==True: alt=alt[taix]\\n else:\\n print(\\\"[avCDNC] nonequal times (although same length): altitude was interpolated.\\\")\\n # interpolating on size distribution data.\\n falt=interpolate.interp1d(tim,alt,kind='linear') \\n alt=falt(usedtime); \\n else:\\n print(\\\"[avCDNC] nonequal times: altitude was interpolated.\\\")\\n # interpolating on size distribution data.\\n falt=interpolate.interp1d(tim,alt,kind='linear') \\n alt=falt(usedtime); \\n if len(lwctime)==len(timtc):\\n if (lwctime.__array__()==timtc).all()==True: lwc=lwc[taix]\\n else: flwc=interpolate.interp1d(lwctime,lwc,kind='linear'); lwc=flwc(usedtime)\\n # integrating\\n dalt=np.diff(alt);\\n lwc=lwc[1:];\\n tc=tc[1:];\\n WA=abs(sum(tc*lwc*dalt))/(samac.lwp(CL)[scan][0]) # if inst conc is cm-3 (cm-3 lwc*meters / lwc*meters = cm-3)\\n return WA\",\n \"def get_obstList(self,X,Y,Z):\\n #Pipe_1\\n\\tpipe_1 = np.array(np.where((X - 1)**2 + (Y - 4)**2 >= 0.5**2)).flatten()\\n\\tpipe_1_stop_z = np.array(np.where(Z <= 3.0)).flatten()\\n\\tpipe_1_stop_y = np.array(np.where(Y >= 3.25)).flatten()\\n\\tpipe_1_stop = np.intersect1d(pipe_1_stop_z[:],pipe_1_stop_y[:])\\n\\tpipe_1 = np.intersect1d(pipe_1[:],pipe_1_stop[:])\\n\\n\\t#Turn_1\\n\\tturn_1 = np.array(np.where((0.75 - np.sqrt((Y - 3.25)**2 + (Z -3)**2))**2 + (X - 1)**2 >= 0.5**2)).flatten()\\n\\tturn_1_stop_z = np.array(np.where(Z >= 3.0)).flatten()\\n\\tturn_1_stop_y = np.array(np.where(Y>= 1.75)).flatten()\\n\\tturn_1_stop = np.intersect1d(turn_1_stop_z[:],turn_1_stop_y[:])\\n\\tturn_1 = np.intersect1d(turn_1[:],turn_1_stop[:])\\n\\n\\t#Pipe_2\\n\\tpipe_2 = np.array(np.where((X - 1)**2 + (Y - 2.5)**2 >= 0.5**2)).flatten()\\n\\tpipe_2_start_z = np.array(np.where(Z >= 1.5)).flatten()\\n\\tpipe_2_start_y_up = np.array(np.where(Y <= 3.25)).flatten()\\n\\tpipe_2_start_y_down = np.array(np.where(Y >= 1.75)).flatten()\\n\\tpipe_2_start_y = np.intersect1d(pipe_2_start_y_up[:],pipe_2_start_y_down[:])\\t\\n\\tpipe_2_start = np.intersect1d(pipe_2_start_z[:],pipe_2_start_y[:])\\n\\tpipe_2 = np.intersect1d(pipe_2[:],pipe_2_start[:])\\n\\tpipe_2_stop_z = np.array(np.where(Z <= 3.0)).flatten()\\n\\tpipe_2_stop_y = np.array(np.where(Y <= 3.25)).flatten()\\n\\tpipe_2_stop = np.intersect1d(pipe_2_stop_z[:],pipe_2_stop_y[:])\\n\\tpipe_2 = np.intersect1d(pipe_2[:],pipe_2_stop[:])\\n\\n\\t#Turn_2\\n\\tturn_2 = np.array(np.where((0.75 - np.sqrt((Y - 1.75)**2 + (Z -1.5)**2))**2 + (X - 1)**2 >= 0.5**2)).flatten()\\n\\tturn_2_stop_z = np.array(np.where(Z <= 1.5)).flatten()\\n\\tturn_2_stop_y = np.array(np.where(Y <= 3.25)).flatten()\\n\\tturn_2_stop = np.intersect1d(turn_2_stop_z[:],turn_2_stop_y[:])\\n\\tturn_2 = np.intersect1d(turn_2[:],turn_2_stop[:])\\n\\t\\n\\t#Pipe_3\\n\\tpipe_3 = np.array(np.where((X - 1)**2 + (Y - 1.0)**2 >= 0.5**2)).flatten()\\n\\tpipe_3_start_z = np.array(np.where(Z >= 1.5)).flatten()\\n\\tpipe_3_start_y = np.array(np.where(Y <= 1.75)).flatten()\\n\\tpipe_3_start = np.intersect1d(pipe_3_start_z[:],pipe_3_start_y[:])\\n\\tpipe_3 = np.intersect1d(pipe_3[:],pipe_3_start[:])\\t\\n\\n\\t#Put the pieces together\\n\\n\\tpipe = np.union1d(pipe_1[:],turn_1[:])\\n\\tpipe = np.union1d(pipe[:],pipe_2[:])\\n\\tpipe = np.union1d(pipe[:],turn_2[:])\\t\\n\\tpipe = np.union1d(pipe[:],pipe_3[:])\\n\\n\\tobst_list = pipe[:]\\n\\n \\n return list(obst_list[:])\",\n \"def hammer_points(neighbors = 3):\\n tgtPts = cmds.ls(sl=True, fl=True)\\n#---------------- add in soft selection? \\n if not tgtPts:\\n cmds.warning(\\\"Select one or more cvs\\\")\\n return\\n\\n for tgtPt in tgtPts:\\n\\n #tgtPtPos = cmds.pointPosition(tgtPt)\\n \\n tgtNum = int(tgtPt.partition(\\\"[\\\")[2].rpartition(\\\"]\\\")[0])\\n #tgtBase = tgtPt.partition(\\\"[\\\")[0]\\n crv = tgtPts[0].partition(\\\".\\\")[0]\\n \\n ptPosListX = []\\n ptPosListY = []\\n ptPosListZ = []\\n \\n count = 0\\n \\n for x in range(-neighbors, neighbors+1):\\n \\n count += abs(x)\\n \\n if x != 0:\\n origPt = \\\"{0}.cv[{1}]\\\".format(crv, tgtNum + x)\\n origPtPos = cmds.pointPosition(origPt)\\n \\n for a in range(abs(x)):\\n ptPosListX.append(origPtPos[0])\\n ptPosListY.append(origPtPos[1])\\n ptPosListZ.append(origPtPos[2])\\n \\n avgX = sum(ptPosListX)/(len(ptPosListX))\\n avgY = sum(ptPosListY)/(len(ptPosListY))\\n avgZ = sum(ptPosListZ)/(len(ptPosListZ))\\n \\n newPos = [avgX, avgY, avgZ]\\n \\n cmds.xform(tgtPt, ws=True, t=newPos)\",\n \"def __get_points_lips(self, lips_points):\\n uol = []\\n uil = []\\n lol = []\\n lil = []\\n for i in range(0, 14, 2):\\n uol.append([int(lips_points[i]), int(lips_points[i + 1])])\\n for i in range(12, 24, 2):\\n lol.append([int(lips_points[i]), int(lips_points[i + 1])])\\n lol.append([int(lips_points[0]), int(lips_points[1])])\\n for i in range(24, 34, 2):\\n uil.append([int(lips_points[i]), int(lips_points[i + 1])])\\n for i in range(32, 40, 2):\\n lil.append([int(lips_points[i]), int(lips_points[i + 1])])\\n lil.append([int(lips_points[24]), int(lips_points[25])])\\n return uol, uil, lol, lil\",\n \"def stop_existing_connections_to_part(session, handling, conn_list, at_date):\\n stop_at = int(at_date.gps)\\n data = []\\n\\n for conn in conn_list:\\n part = handling.get_dossier(conn[0], conn[1], at_date=at_date, exact_match=True)\\n if len(part):\\n key = cm_utils.make_part_key(conn[0], conn[1])\\n x = None\\n if conn[2].lower() in part[key].input_ports:\\n x = part[key].connections.down[conn[2].upper()]\\n elif conn[2].lower() in part[key].output_ports:\\n x = part[key].connections.up[conn[2].upper()]\\n if x is not None:\\n print(\\\"Stopping connection {} at {}\\\".format(x, str(at_date)))\\n stopping = [\\n x.upstream_part,\\n x.up_part_rev,\\n x.downstream_part,\\n x.down_part_rev,\\n x.upstream_output_port,\\n x.downstream_input_port,\\n x.start_gpstime,\\n \\\"stop_gpstime\\\",\\n stop_at,\\n ]\\n data.append(stopping)\\n with mc.MCSessionWrapper(session=session) as session:\\n update_connection(session, data, False)\",\n \"def create_conserved_motif_list(dyn_id,gpcr_pdb,gpcr_aa,j,my_pos,motifs,multiple_chains,chain_name):\\n my_pos_bw=my_pos.split(\\\"x\\\")[0]\\n (my_aa,chain)=gpcr_aa[my_pos]\\n add_chain_name=\\\"\\\"\\n if multiple_chains:\\n add_chain_name=\\\":\\\"+chain_name \\n while j < len(motifs):\\n cons_pos = motifs[j][1]\\n cons_pos_bw=cons_pos[1:]\\n cons_aa=cons_pos[0]\\n if my_pos_bw==cons_pos_bw:\\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\\n if pos_range:\\n motifs[j][2]=True\\n motifs[j][3]=pos_range + add_chain_name\\n if cons_aa != \\\"x\\\" and my_aa != cons_aa:\\n motifs[j][1]+=my_aa\\n j+=1\",\n \"def getLCLimits(*args):\\n return args[0].Limit.LCLimit.lc_limit\",\n \"def get_obstList(self,X,Y,Z):\\n #Pipe in - find all points exterior of large pipe\\n\\tpipe_in = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_in/2)**2)).flatten()\\n\\tpipe_in_stop = np.array(np.where(Z <= 4)).flatten()\\n\\tpipe_in = np.intersect1d(pipe_in[:],pipe_in_stop[:])\\n\\n\\t#Contraction - find all points exterior of contraction\\n\\tr_cone = self.diam_out\\n\\th_cone = self.diam_out\\t\\n\\tcontraction = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (r_cone/h_cone)**2*(Z - (4 + h_cone))**2)).flatten()\\n\\tcontraction_start = np.array(np.where(Z >= 4)).flatten()\\n\\tcontraction_stop = np.array(np.where(Z <= 4 + .5*self.diam_out)).flatten()\\n\\tcontraction = np.intersect1d(contraction[:],contraction_start[:])\\n\\tcontraction = np.intersect1d(contraction[:],contraction_stop[:])\\n\\n\\t#Pipe out - final all points exterior of smaller pipe\\n\\tpipe_out = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_out/2)**2)).flatten()\\n\\tpipe_out_start = np.array(np.where(Z >= 4 + .5*self.diam_out)).flatten()\\n\\tpipe_out = np.intersect1d(pipe_out[:],pipe_out_start[:])\\n\\n\\n\\t#Put the pieces together\\n\\n\\t#pipe = pipe_in[:]\\n\\tpipe = np.union1d(contraction[:],pipe_in[:])\\n\\tpipe = np.union1d(pipe[:],pipe_out[:])\\n\\n\\tobst_list = pipe[:]\\n\\n \\n return list(obst_list[:])\",\n \"def LimitPointsBetweenSubContourNodes(scList, numInteriorPointsDict, interpolate=True):\\n limIntPtsFunc = (\\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\\n )\\n for sc in scList:\\n sc.points = limIntPtsFunc(sc.points, numInteriorPointsDict[tuple(sc.values)])\",\n \"def allcJPDs(net,cond_node,cond_states):\\r\\n \\r\\n onodes = net.Outputnodes()\\r\\n onodes = sorted(onodes)\\r\\n combinations = [i for i in itertools.combinations(onodes,2)]\\r\\n JPDdatas = [] \\r\\n progress = 0\\r\\n for cs in cond_states:\\r\\n JPDdata = []\\r\\n for c in combinations:\\r\\n print 'Progress: ' +str(int(100*float(progress)/float(len(combinations)*len(cond_states))))+ ' %'\\r\\n priorA = getCondPrior(net,c[0],cond_node,cs)\\r\\n print priorA\\r\\n priorB = getCondPrior(net,c[1],cond_node,cs) \\r\\n print priorB\\r\\n JPD = cJPD(net,c,cond_node,cs)\\r\\n cov = Covariance (priorA,priorB,JPD)\\r\\n cor = Correlation (priorA,priorB,cov) \\r\\n JPDdata.append([c[0],c[1],JPD,cov,cor])\\r\\n progress+=1\\r\\n JPDdatas.append(JPDdata)\\r\\n return JPDdatas\",\n \"def fixed_points(self, epsilon = 0.000001):\\n # (a b) (z) = (Lz)\\n # (c d) (1) ( L) \\n\\n # az + b = c z^2 + d z\\n # 0 = c z^2 + (d-a)z - b\\n # z = ((a-d) \\\\pm sqrt( (a-d)^2 + 4 bc )) / 2c\\n\\n a, b, c, d = self\\n\\n assert abs(c) > epsilon\\n zp = ((a - d) + sqrt( (a - d)**2 + 4*b*c)) / 2*c\\n zm = ((a - d) - sqrt( (a - d)**2 + 4*b*c)) / 2*c\\n Lp = c*zp + d\\n Lm = c*zm + d\\n if abs(Lp) < abs(Lm):\\n Ls = [Lp, Lm]\\n out = [zp, zm]\\n else:\\n Ls = [Lm, Lp]\\n out = [zm, zp] \\n assert abs(Ls[0]) < 1 - epsilon and 1 + epsilon < abs(Ls[1])\\n return [CP1((z,1)) for z in out]\",\n \"def extract_labels_cps(scene: \\\"Scenemaker\\\") -> List[Tuple[int, np.ndarray]]:\\r\\n objects = utils.select_collection(scene.target_collection)\\r\\n boxes_list = []\\r\\n\\r\\n for obj in objects:\\r\\n objclass = obj.name.split(\\\".\\\")[0]\\r\\n cornermatrix = np.empty((8, 3))\\r\\n for j, corner in enumerate(obj.bound_box):\\r\\n cornermatrix[j] = corner\\r\\n\\r\\n boxes_list.append((scene.name2num[objclass], cornermatrix))\\r\\n\\r\\n return boxes_list\",\n \"def _get_points_nd(clicks_lists, net_clicks_limit):\\n total_clicks = []\\n num_pos_clicks = [sum(x.is_positive for x in clicks_list) for clicks_list in clicks_lists]\\n num_neg_clicks = [len(clicks_list) - num_pos for clicks_list, num_pos in zip(clicks_lists, num_pos_clicks)]\\n num_max_points = max(num_pos_clicks + num_neg_clicks)\\n\\n if net_clicks_limit is not None:\\n num_max_points = min(net_clicks_limit, num_max_points)\\n num_max_points = max(1, num_max_points)\\n\\n for clicks_list in clicks_lists:\\n clicks_list = clicks_list[:net_clicks_limit]\\n pos_clicks = [click.coords for click in clicks_list if click.is_positive]\\n pos_clicks = pos_clicks + (num_max_points - len(pos_clicks)) * [(-1, -1)]\\n\\n neg_clicks = [click.coords for click in clicks_list if not click.is_positive]\\n neg_clicks = neg_clicks + (num_max_points - len(neg_clicks)) * [(-1, -1)]\\n total_clicks.append(pos_clicks + neg_clicks)\\n\\n return np.array(total_clicks)\",\n \"def getNodeList(x, y, type):\\n\\t\\n\\tif type == 0:\\n\\t\\treturn pointListForGrass(x, y)\\n\\telif type == 1:\\n\\t\\treturn pointListForHorizontal(x, y)\\n\\telif type == 2:\\n\\t\\treturn pointListForVirticle(x, y)\\n\\telif type == 3:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 4:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 5:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 6:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 7:\\n\\t\\treturn pointListForPlus(x, y)\\n\\telif type == 8:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telif type == 9:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telif type == 10:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telif type == 11:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telse:\\n\\t\\treturn []\",\n \"def add_pconn(self):\\n self.use_pconn= True\\n self.pconn = []\\n for i,c in enumerate(self.conn):\\n atoms_pconn = []\\n atoms_image = []\\n for ji, j in enumerate(c):\\n # If an atom or vertex is connected to another one multiple times (in an image), this\\n # will be visible in the self.conn attribute, where the same neighbour will be listed\\n # multiple times.\\n # Sometimes, the distances are a bit different from each other, and in this case, we\\n # have to increase the threshold, until the get_distvec function will find all imgis.\\n n_conns = c.count(j)\\n t = 0.01\\n while True:\\n d,r,imgi = self.get_distvec(i,j,thresh=t)\\n t += 0.01\\n if n_conns == len(imgi):\\n break\\n if len(imgi) == 1:\\n # only one neighbor .. all is fine\\n atoms_pconn.append(images[imgi[0]])\\n atoms_image.append(imgi[0])\\n else:\\n # we need to assign an image to each connection\\n # if an atom is connected to another atom twice this means it must be another\\n # image\\n for ii in imgi:\\n # test if this image is not used for this atom .. then we can use it\\n if atoms_image.count(ii)==0:\\n atoms_image.append(ii)\\n atoms_pconn.append(images[ii])\\n else:\\n # ok, we have this image already\\n use_it = True\\n #print(c, \\\"=>\\\", j)\\n #print(atoms_image)\\n for k, iii in enumerate(atoms_image):\\n #print('k',k)\\n if (iii == ii) and (c[k] == j): use_it=False\\n if use_it:\\n atoms_image.append(ii)\\n atoms_pconn.append(images[ii])\\n self.pconn.append(atoms_pconn)\\n #if len(atoms_pconn) != len(c): print(\\\"AOSUHDAPUFHPOUFHPWOUFHPOUDHSPUODHASIUDHAUSIDHSD\\\")\\n return\\n\\n # 'na',lower(label),xyz,i,j)\",\n \"def displacements_recursive(config, pointInds_toUse, pointInds_tracked, pointInds_tracked_tuple, positions_recursive,\\n pts_spaced, color_tuples, relaxation_factor, session):\\n\\n ## Main loop to pull out displacements in each video\\n ind_concat = 0\\n fps = 0\\n tic_fps = time.time()\\n tic_all = time.time()\\n\\n optic = config['Optic']\\n video = config['Video']\\n\\n vidNums_toUse = optic['vidNums_toUse']\\n showVideo_pref = optic['showVideo_pref']\\n fps_counterPeriod = video['fps_counterPeriod']\\n printFPS_pref = video['printFPS_pref']\\n remote = config['General']['remote']\\n save_vid = video['save_demo']\\n\\n\\n Fs = video['Fs']\\n vid_width = video['width']\\n vid_height = video['height']\\n test_len = video['demo_len']\\n save_pathFull = str(Path(config['Paths']['viz']) / 'optic_test.avi')\\n\\n numVids = session['num_vids']\\n path_vid_allFiles = session['videos']\\n \\n lk_names = [key for key in optic['lk'].keys()]\\n lk_params = {k: (tuple(optic['lk'][k]) if type(optic['lk'][k]) is list else optic['lk'][k]) \\\\\\n for k in lk_names}\\n \\n\\n # Define the codec and create VideoWriter object\\n if showVideo_pref and (save_vid or remote):\\n fourcc = cv2.VideoWriter_fourcc(*'MJPG')\\n print(f'saving to file {save_pathFull}')\\n out = cv2.VideoWriter(save_pathFull, fourcc, Fs, (np.int64(vid_width), np.int64(vid_height)))\\n else:\\n out = None\\n\\n vid_lens = []\\n pointInds_old = pointInds_toUse\\n for vidNum_iter in vidNums_toUse:\\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\\n # metadata = vid.get_meta_data()\\n\\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\\n numFrames_rough = int(video.get(\\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\\n\\n frameToSet = 0\\n frame = vid.get_data(0) # Get a single frame to use as the first 'previous frame' in calculating optic flow\\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n old_frame = new_frame_gray\\n\\n print(f'\\\\n Calculating displacement field: video # {vidNum_iter+1}/{numVids}')\\n for iter_frame , new_frame in enumerate(tqdm(vid, total=numFrames_rough)):\\n\\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\\n\\n ##calculate optical flow\\n # pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None, **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, np.single(pointInds_old),\\n None,\\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\\n\\n # diff = np.squeeze((pointInds_new - pointInds_old)) # this is the important variable. Simply the difference in the estimate\\n \\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\\n \\n # pointInds_tracked = pointInds_tracked + (pointInds_new - pointInds_toUse) # calculate integrated position\\n # pointInds_tracked = pointInds_tracked + diff[:,None,:] # calculate integrated position\\n pointInds_tracked = pointInds_new - (pointInds_new -pointInds_toUse)*relaxation_factor # multiplied constant is the relaxation term\\n\\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter) \\n if ind_concat ==0:\\n positions_recursive[:,:,ind_concat] = np.zeros((pts_spaced.shape[0] ,2))\\n else:\\n # displacements[:,:,ind_concat] = np.single(np.squeeze((pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\\n positions_recursive[:,:,ind_concat] = np.squeeze((pointInds_tracked)) # this is the important variable. Simply the difference in the estimate\\n\\n pointInds_old = pointInds_tracked\\n\\n ## below is just for visualization. Nothing calculated is maintained\\n if showVideo_pref:\\n\\n pointInds = [pointInds_tracked, pointInds_tracked_tuple]\\n counters = [iter_frame, vidNum_iter, ind_concat, fps]\\n if (remote and iter_frame < test_len) or not remote:\\n videos.visualize_progress(config, session, new_frame, pointInds, color_tuples, counters, out)\\n\\n if (save_vid or remote) and iter_frame == test_len:\\n out.release()\\n\\n k = cv2.waitKey(1) & 0xff\\n if k == 27: break\\n\\n ind_concat = ind_concat + 1\\n\\n if ind_concat % fps_counterPeriod == 0:\\n elapsed = time.time() - tic_fps\\n fps = fps_counterPeriod / elapsed\\n if printFPS_pref:\\n print(fps)\\n tic_fps = time.time()\\n vid_lens.append(iter_frame+1)\\n\\n ## Calculate how long calculation took\\n elapsed = time.time() - tic_all\\n helpers.print_time('video time elapsed:', elapsed)\\n print(f'Capture rate: {round(ind_concat / elapsed, 3)} fps')\\n\\n numFrames_total = ind_concat\\n cv2.destroyAllWindows()\\n\\n positions_recursive = positions_recursive[:, :, ~np.isnan(positions_recursive[0, 0, :])]\\n displacements = np.zeros_like(positions_recursive)\\n displacements[:,:,1:] = np.diff(positions_recursive , axis=2)\\n\\n return displacements, numFrames_total , positions_recursive, vid_lens\",\n \"def get_obstList(self,X,Y,Z):\\n #Pipe in - find all points exterior of small\\n\\tpipe_in = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_in/2)**2)).flatten()\\n\\tpipe_in_stop = np.array(np.where(Z <= 3 + 0.5*(self.diam_out - self.diam_in))).flatten()\\n\\tpipe_in = np.intersect1d(pipe_in[:],pipe_in_stop[:])\\n\\n\\t#Expansion - find all points exterior of expansion\\n\\tr_cone = self.diam_in\\n\\th_cone = self.diam_in\\t\\n\\texpansion = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (r_cone/h_cone)**2*(Z - 3)**2)).flatten()\\n\\texpansion_start = np.array(np.where(Z >= 3 + 0.5*(self.diam_out - self.diam_in)))\\n\\t#expansion_stop = np.array(np.where(Z <= 4)).flatten()\\n\\texpansion = np.intersect1d(expansion[:],expansion_start[:])\\n\\t#expansion = np.intersect1d(expansion[:],expansion_stop[:])\\n\\n\\t#Pipe out - final all points exterior of smaller pipe\\n\\tpipe_out = np.array(np.where((X - 1)**2 + (Y - 1)**2 > (self.diam_out/2)**2)).flatten()\\n\\tpipe_out_start = np.array(np.where(Z >= 3 + 0.5*(self.diam_in - self.diam_out))).flatten()\\n\\tpipe_out = np.intersect1d(pipe_out[:],pipe_out_start[:])\\n\\n\\n\\t#Put the pieces together\\n\\n\\tpipe = expansion[:]\\n\\tpipe = np.union1d(expansion[:],pipe_in[:])\\n\\tpipe = np.union1d(pipe[:],pipe_out[:])\\n\\n\\tobst_list = pipe[:]\\n\\n \\n return list(obst_list[:])\",\n \"def initialize_lattice_cpa(risk_slim_settings, warmstart_settings, cplex_parameters, compute_loss_real, compute_loss_cut_real, bounds = None):\\n warmstart_settings = dict(warmstart_settings)\\n risk_slim_settings = dict(risk_slim_settings)\\n #get_objval\\n #check_feasible\\n\\n\\n C_0 = np.array(risk_slim_settings['coef_set'].C_0j)\\n L0_reg_ind = np.isnan(C_0)\\n C_0[L0_reg_ind] = risk_slim_settings['C_0']\\n C_0_nnz = C_0[L0_reg_ind]\\n\\n if bounds is None:\\n bounds = {\\n 'objval_min': 0.0,\\n 'objval_max': CPX_INFINITY,\\n 'loss_min': 0.0,\\n 'loss_max': CPX_INFINITY,\\n 'L0_min': 0,\\n 'L0_max': risk_slim_settings['L0_max'],\\n }\\n warmstart_settings['type'] = 'cvx'\\n risk_slim_settings.update(bounds)\\n risk_slim_settings['relax_integer_variables'] = True\\n\\n #create RiskSLIM LP\\n risk_slim_lp, risk_slim_lp_indices = create_risk_slim(risk_slim_settings)\\n risk_slim_lp = set_cplex_mip_parameters(risk_slim_lp, cplex_parameters, display_cplex_progress = warmstart_settings['display_cplex_progress'])\\n\\n # solve risk_slim_lp LP using standard CPA\\n cpa_stats, initial_cuts, cts_pool = cutting_plane_algorithm(risk_slim_lp,\\n risk_slim_lp_indices,\\n warmstart_settings,\\n compute_loss_real,\\n compute_loss_cut_real)\\n\\n # update bounds\\n initial_bounds = chained_updates(bounds, C_0_nnz, new_objval_at_relaxation=cpa_stats['lowerbound'])\\n initial_pool = SolutionPool(cts_pool.P)\\n\\n #remove redundant solutions, remove infeasible solutions, order solutions by objective value of RiskSLIMLP\\n cts_pool = cts_pool.distinct().removeInfeasible(check_feasible).sort()\\n\\n if warmstart_settings['use_sequential_rounding']:\\n initial_pool, _, _ = sequential_round_solution_pool(cts_pool,\\n max_runtime=warmstart_settings['sequential_rounding_max_runtime'],\\n max_solutions=warmstart_settings['sequential_rounding_max_solutions'],\\n objval_cutoff=bounds['objval_max'],\\n L0_min=bounds['L0_min'],\\n L0_max=bounds['L0_max'])\\n\\n initial_pool = initial_pool.distinct().sort()\\n bounds = chained_updates(bounds, C_0_nnz, new_objval_at_feasible=np.min(initial_pool.objvals))\\n else:\\n initial_pool, _, _ = round_solution_pool(cts_pool, constraints)\\n\\n initial_pool.computeObjvals(get_objval)\\n if warmstart_settings['polishing_after'] and len(initial_pool) > 0:\\n initial_pool, _, _ = discrete_descent_solution_pool(initial_pool,\\n warmstart_settings['polishing_max_runtime'],\\n warmstart_settings['polishing_max_solutions'])\\n\\n initial_pool = initial_pool.removeInfeasible(check_feasible).distinct().sort()\\n\\n if len(initial_pool) > 0:\\n initial_bounds = chained_updates(bounds, C_0_nnz, new_objval_at_feasible=np.min(initial_pool.objvals))\\n\\n return initial_pool, initial_cuts, initial_pool\",\n \"def add_ixp_links(self, ixps, c2p_factor, ixp_mode=0):\\n\\n print \\\"-> Get AS Connectivity\\\"\\n c2p_connections = self.get_as_connectivity_fast(ixps)\\n\\n # loop through all ixp connections\\n print \\\"-> Start Adding the Links\\\"\\n i = 0\\n\\n pairs = itertools.combinations(ixps.keys(), 2)\\n\\n num_p2p_links = 0\\n num_c2p_links = 0\\n\\n for pair in pairs:\\n i += 1\\n if i % 1000000 == 0:\\n print \\\"--> Processed \\\" + str(i) + \\\" IXP links\\\"\\n\\n participant1 = int(pair[0])\\n participant2 = int(pair[1])\\n\\n # check if those nodes actually exist\\n if self.has_node(participant1) and self.has_node(participant2):\\n p1_ixps = set(ixps[pair[0]])\\n p2_ixps = set(ixps[pair[1]])\\n ixp_intersect = p1_ixps.intersection(p2_ixps)\\n if len(ixp_intersect) >= 1:\\n if self.has_edge(participant1, participant2):\\n self[participant1][participant2]['ixps'] = list(ixp_intersect)\\n else:\\n if participant1 in c2p_connections[participant2]:\\n num_c2p_links += 1\\n self.add_edge(participant2, participant1, relationship=-1,\\n ixps=list(ixp_intersect), as1=participant1, as2=participant2)\\n elif participant2 in c2p_connections[participant1]:\\n num_c2p_links += 1\\n self.add_edge(participant1, participant2, relationship=-1,\\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\\n else:\\n # mode 0: by default add a p2p link, if there is no c2p connection between the two\\n if ixp_mode == 0:\\n num_p2p_links += 1\\n self.add_edge(participant1, participant2, relationship=0,\\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\\n # mode 1: add by default a p2p link, if there is a c2p+ or the number of neighbors\\n # differ in size more than X times\\n else:\\n num_neighbors_1 = float(nx.degree(self, participant1))\\n num_neighbors_2 = float(nx.degree(self, participant2))\\n\\n if num_neighbors_1 == 0 or num_neighbors_2 == 0:\\n print \\\"\\\\nERROR\\\"\\n print \\\"Node \\\" + str(participant1) + \\\" has \\\" + str(num_neighbors_1) + \\\" neighbors\\\"\\n print \\\"Node \\\" + str(participant2) + \\\" has \\\" + str(num_neighbors_2) + \\\" neighbors\\\"\\n continue\\n\\n if num_neighbors_1/num_neighbors_2 >= c2p_factor:\\n num_c2p_links += 1\\n self.add_edge(participant1, participant2, relationship=-1,\\n ixps=list(ixp_intersect), as1=participant1, as2=participant2)\\n # update connection data structure\\n c2p_connections[participant2] |= c2p_connections[participant1]\\n c2p_connections[participant2].add(participant1)\\n elif num_neighbors_2/num_neighbors_1 >= c2p_factor:\\n num_c2p_links += 1\\n self.add_edge(participant1, participant2, relationship=-1,\\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\\n # update connection data structure\\n c2p_connections[participant1] |= c2p_connections[participant2]\\n c2p_connections[participant1].add(participant2)\\n else:\\n num_p2p_links += 1\\n self.add_edge(participant1, participant2, relationship=0,\\n ixps=list(ixp_intersect), as1=participant2, as2=participant1)\\n\\n print \\\"--> Added a total of \\\" + str(num_c2p_links + num_p2p_links) + \\\" IXP links of which \\\" + \\\\\\n str(num_c2p_links) + \\\" were c2p and \\\" + str(num_p2p_links) + \\\" were p2p\\\"\",\n \"def power_points():\\n next_reading = power_readings()\\n stretch = []\\n\\n def next():\\n nonlocal stretch, next_reading\\n stretch.append(next_reading())\\n if len(stretch) > XMAX + 1:\\n stretch.pop(0)\\n x = XMAX + 1 - len(stretch)\\n points = []\\n for y in stretch:\\n points.append((x, y))\\n points.append((x, 0))\\n x += 1\\n return points\\n\\n return next\",\n \"def create_conserved_motif_list_otherclass(gpcr_pdb,gpcr_aa,j,my_pos,motifs,multiple_chains,chain_name):\\n my_pos_bw=my_pos.split(\\\"x\\\")[0]\\n (my_aa,chain)=gpcr_aa[my_pos]\\n add_chain_name=\\\"\\\"\\n if multiple_chains:\\n add_chain_name=\\\":\\\"+chain_name \\n while j < len(motifs):\\n cons_pos_bw = motifs[j][4]\\n if my_pos_bw==cons_pos_bw:\\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\\n if pos_range:\\n motifs[j][2]=True\\n motifs[j][3]=pos_range + add_chain_name\\n j+=1\",\n \"def get_ctrl_points(self) -> list[tuple]:\\n self.calculate_d_vals()\\n self.calculate_psi_vals()\\n self.calculate_theta_vals()\\n self.calculate_phi_vals()\\n self.show_debug_msg()\\n self.ctrl_pts = self.calculate_ctrl_pts()\\n return self.ctrl_pts\",\n \"def getAndSortFiducialPoints(self, center):\\r\\n # self.__registrationStatus.setText('Registration processing...')\\r\\n # pNode = self.parameterNode()\\r\\n # fixedAnnotationList = slicer.mrmlScene.GetNodeByID(pNode.GetParameter('fixedLandmarksListID'))\\r\\n # if fixedAnnotationList != None:\\r\\n # fixedAnnotationList.RemoveAllChildrenNodes()\\r\\n markerCenters = center\\r\\n nbCenter = len(center)\\r\\n for k in range(nbCenter):\\r\\n point = [0]\\r\\n for i in range(nbCenter):\\r\\n U,V,W = 0,0,0\\r\\n for j in range(nbCenter):\\r\\n d = 0\\r\\n if i != j and markerCenters[i]!=(0,0,0):\\r\\n d2 = (markerCenters[i][0]-markerCenters[j][0])**2+(markerCenters[i][1]-markerCenters[j][1])**2+(markerCenters[i][2]-markerCenters[j][2])**2\\r\\n d = d2**0.5\\r\\n # print markerCenters[i],markerCenters[j]\\r\\n #print d\\r\\n if d >=45 and d<=53:\\r\\n U += 1\\r\\n elif d >53 and d<60:\\r\\n V +=1\\r\\n elif d >=70 and d<80:\\r\\n W +=1\\r\\n #print U,V,W\\r\\n if U+V+W>=3:\\r\\n #print markerCenters[i]\\r\\n point.extend([i])\\r\\n point.remove(0)\\r\\n minX = [999,999,999,999]\\r\\n maxX = [-999,-999,-999,-999]\\r\\n sorted = [[0,0,0] for l in range(4)]\\r\\n sortedConverted = [[0,0,0] for l in range(4)]\\r\\n for i in range(2):\\r\\n for k in point:\\r\\n if markerCenters[k][0]<= minX[0]:\\r\\n minX[0] = markerCenters[k][0]\\r\\n minX[1] = k\\r\\n elif markerCenters[k][0]<= minX[2]:\\r\\n minX[2] = markerCenters[k][0]\\r\\n minX[3] = k\\r\\n if markerCenters[k][0]>= maxX[0]:\\r\\n maxX[0] = markerCenters[k][0]\\r\\n maxX[1] = k\\r\\n elif markerCenters[k][0]>= maxX[2]:\\r\\n maxX[2] = markerCenters[k][0]\\r\\n maxX[3] = k\\r\\n if markerCenters[minX[1]][1] < markerCenters[minX[3]][1]:\\r\\n sorted[0] = minX[1]\\r\\n sorted[1] = minX[3]\\r\\n else:\\r\\n sorted[0] = minX[3]\\r\\n sorted[1] = minX[1]\\r\\n if markerCenters[maxX[1]][1]>markerCenters[maxX[3]][1]:\\r\\n sorted[2] = maxX[1]\\r\\n sorted[3] = maxX[3]\\r\\n else:\\r\\n sorted[2] = maxX[3]\\r\\n sorted[3] = maxX[1]\\r\\n sorted2 = [0,0,0,0]\\r\\n if 1:#self.horizontalTemplate.isChecked():\\r\\n sorted2[0]=sorted[2]\\r\\n sorted2[2]=sorted[0]\\r\\n sorted2[1]=sorted[3]\\r\\n sorted2[3]=sorted[1]\\r\\n else:\\r\\n sorted2[0]=sorted[3]\\r\\n sorted2[2]=sorted[1]\\r\\n sorted2[1]=sorted[0]\\r\\n sorted2[3]=sorted[2]\\r\\n # logic = slicer.modules.annotations.logic()\\r\\n # logic.SetActiveHierarchyNodeID(pNode.GetParameter('fixedLandmarksListID'))\\r\\n # if pNode.GetParameter(\\\"Template\\\")=='4points':\\r\\n # nbPoints=4\\r\\n # elif pNode.GetParameter(\\\"Template\\\")=='3pointsCorners':\\r\\n # nbPoints=3\\r\\n l = slicer.modules.annotations.logic()\\r\\n l.SetActiveHierarchyNodeID(slicer.util.getNode('Fiducial List_fixed').GetID())\\r\\n for k in range(4) :\\r\\n fiducial = slicer.mrmlScene.CreateNodeByClass('vtkMRMLAnnotationFiducialNode')\\r\\n fiducial.SetReferenceCount(fiducial.GetReferenceCount()-1)\\r\\n fiducial.SetFiducialCoordinates(markerCenters[sorted2[k]])\\r\\n fiducial.SetName(str(k))\\r\\n fiducial.Initialize(slicer.mrmlScene)\\r\\n\\r\\n sRed = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNodeRed\\\")\\r\\n if sRed ==None :\\r\\n sRed = slicer.mrmlScene.GetNodeByID(\\\"vtkMRMLSliceNode1\\\")\\r\\n # sRed.SetSliceVisible(1)\\r\\n m= sRed.GetSliceToRAS()\\r\\n m.SetElement(0,3,sortedConverted[3][0])\\r\\n m.SetElement(1,3,sortedConverted[3][1])\\r\\n m.SetElement(2,3,sortedConverted[3][2])\\r\\n sRed.Modified()\\r\\n return sorted2\",\n \"def approximate_circuit(\\n self,\\n circuit: Circuit,\\n psols: list[list[tuple[Circuit, float]]],\\n pts: list[CircuitPoint],\\n ) -> list[Circuit]:\\n num_blocks = len(pts)\\n approx_threshold = self.approx_threshold or num_blocks / 10\\n bounds = [[0, len(psol_list)] for psol_list in psols]\\n\\n psol_configs: list[list[int]] = []\\n approx_circuits: list[Circuit] = []\\n dists = [[psol[1] for psol in psol_list] for psol_list in psols]\\n utrys = [\\n [psol[0].get_unitary() for psol in psol_list]\\n for psol_list in psols\\n ]\\n n_cxs = [\\n [psol[0].count(CNOTGate()) for psol in psol_list]\\n for psol_list in psols\\n ]\\n n_cx = sum(op.gate._circuit.count(CNOTGate()) for op in circuit) # type: ignore # noqa\\n\\n for _ in range(self.sample_size):\\n x = []\\n f = float('inf')\\n for _ in range(3):\\n result = dual_annealing(\\n annealing_objective,\\n args=(\\n approx_threshold,\\n n_cx,\\n psol_configs,\\n dists,\\n utrys,\\n n_cxs,\\n self.pert,\\n self.weit,\\n ),\\n x0=[0] * num_blocks,\\n bounds=bounds,\\n seed=int(time.time()),\\n initial_temp=5e4,\\n maxiter=10000,\\n )\\n\\n if result.fun < f:\\n x = result.x\\n f = result.fun\\n\\n blocks = [int(x_e) for x_e in x]\\n\\n if blocks in psol_configs:\\n _logger.debug('Generated a repeat approximate circuit.')\\n break\\n\\n approx_dist = sum(\\n psols[b][ind][1]\\n for b, ind in enumerate(blocks)\\n )\\n\\n if approx_dist > approx_threshold:\\n _logger.debug('Approximate circuit has high distance.')\\n break\\n\\n psol_configs.append(blocks)\\n approx_circuit = self.assemble_circuit(circuit, blocks, psols, pts)\\n approx_circuit.unfold_all()\\n approx_circuits.append(approx_circuit)\\n _logger.info(\\n 'Generated approximate circuit with approximate distance:'\\n f' {approx_dist}.',\\n )\\n _logger.info(\\n f'Approximate circuit has {approx_circuit.count(CNOTGate())}'\\n ' cnots.',\\n )\\n\\n return approx_circuits\",\n \"def build_csls_subgraphs(self):\\n # Graph for calculating only score\\n scores_s2t = self.build_eval_graph(\\n \\\"ScoreS2T\\\", self.src_ten, self.tgt_ten, en_knn=False, en_mean=False\\n )\\n scores_t2s = self.build_eval_graph(\\n \\\"ScoreT2S\\\", self.tgt_ten, self.src_ten, en_knn=False, en_mean=False\\n )\\n # Graphs for calculating average between source and target\\n avg1_s2t = self.build_eval_graph(\\\"Avg1\\\", self.src_ten, self.tgt_ten, knn=10)\\n avg2_s2t = self.build_eval_graph(\\\"Avg2\\\", self.tgt_ten, self.src_ten, knn=10)\\n # Graph for selecting top 100 elements\\n top100_matches = tf.nn.top_k(self.score_ph, 100)\\n # Graph for selecting top 2 elements\\n top2_matches = tf.nn.top_k(self.score_ph, 2)\\n # Graph for calculating similarity\\n csls_mean_score = self.build_sim_graph(\\\"SimGraph\\\")\\n\\n # Dictionary\\n csls_graphs = {\\n \\\"ScoreGraph\\\": scores_s2t,\\n \\\"ScoreG_T2S\\\": scores_t2s,\\n \\\"Avg1S2T\\\": avg1_s2t,\\n \\\"Avg2S2T\\\": avg2_s2t,\\n \\\"Top100\\\": top100_matches,\\n \\\"Top2\\\": top2_matches,\\n \\\"CSLS_Criteria\\\": csls_mean_score,\\n }\\n return csls_graphs\",\n \"def auxmax_cc_piece(x,k_ind,m_ind):\\n \\n # Adding new linear function as a last function:\\n # The first line. If k_ind = nomax-1, this is a new line, otherwise an old one.\\n line_start=cfg.nfea*sum(cfg.jk[i] for i in range(k_ind))\\n if cfg.jk[k_ind]==1 and k_ind==cfg.nomax-1: #\\n print \\\"hihu0\\\"\\n f_cc=np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\\n return f_cc\\n else:\\n print \\\"hihu1\\\",line_start\\n f_cc=np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\\n \\n cfg.min_line[k_ind,m_ind] = 0 # a global variable to save the smallest value.\\n \\n # Next lines\\n line_start += cfg.nfea\\n for j in range(1,cfg.jk[k_ind]-1): # Everything but the first and last.\\n \\n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\\n \\n # Minimum of lines\\n if f_tmp <= f_cc:\\n f_cc = f_tmp\\n cfg.min_line[k_ind,m_ind] = j\\n line_start += cfg.nfea\\n \\n \\n # The last line.\\n if k_ind==cfg.nomax-1:\\n \\n f_tmp = np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\\n else: \\n \\n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\\n \\n # Minimum of lines\\n if f_tmp <= f_cc:\\n f_cc = f_tmp\\n cfg.min_line[k_ind,m_ind] = cfg.jk[k_ind]-1 \\n \\n \\n return f_cc\",\n \"def create_conserved_pos_list_otherclass(gpcr_pdb,gpcr_aa, i,my_pos, cons_pos_li, multiple_chains,chain_name,gnum_classes_rel,dict_class,current_class):\\n my_pos_bw=my_pos.split(\\\"x\\\")[0]\\n add_chain_name=\\\"\\\"\\n if multiple_chains:\\n add_chain_name=\\\":\\\"+chain_name\\n while i < len(cons_pos_li):\\n cons_pos_bw_ourclass = cons_pos_li[i][1]\\n if my_pos_bw==cons_pos_bw_ourclass:\\n pos_range=find_range_from_cons_pos(my_pos, gpcr_pdb)\\n if pos_range:\\n cons_pos_li[i][2]=pos_range + add_chain_name\\n cons_pos_li[i][1]=\\\"Correspods to \\\"+cons_pos_bw_ourclass + current_class.lower()\\n i+=1\",\n \"def netmedic_param_search(entry_point, true_root_cause,\\n pc_aggregate, pc_alpha, data_inwindow, data_head, dep_graph, window_start):\\n result_list = []\\n for hist_start in range(0, 200, 50):\\n for hist_len in [50]:\\n for current_start in range(200, 300, 50):\\n for current_len in[50]:\\n for bin_size in [5, 10, 15]:\\n tic = time.time()\\n prks, acc = test_netmedic(\\n data_source=\\\"ibm_micro_service\\\",\\n history_range=(hist_start, hist_start+hist_len),\\n current_range=(\\n current_start, current_start+current_len),\\n bin_size=bin_size,\\n affected_node=entry_point,\\n true_root_cause=true_root_cause,\\n verbose=0,\\n runtime_debug=False,\\n pc_aggregate=pc_aggregate,\\n pc_alpha=pc_alpha,\\n data=data_inwindow,\\n data_head=data_head,\\n disable_print=True,\\n dep_graph=dep_graph,\\n window_start=window_start\\n )\\n toc = time.time()-tic\\n result_list.append({\\n 'history_range': (hist_start, hist_start+hist_len),\\n 'current_range': (current_start, current_start+current_len),\\n 'bin_size': bin_size,\\n 'time': toc,\\n 'prks': prks,\\n 'acc': acc\\n })\\n return result_list\",\n \"def C(v,securite):\\n to_return = set()\\n x,y = l[v][0],l[v][1]\\n a,b = id_case(x,y) #on recupere la case ou se trouve le disque qu'on test\\n voisinage = set(cases[a,b]) #on recupere la liste du voisinage (pas forcement contact)\\n #4\\n #012\\n #345\\n #678 \\n if a>100:\\n voisinage = add_list(voisinage,cases[a-4*rayon,b]) #3\\n if b>200:\\n voisinage = add_list(voisinage,cases[a-4*rayon,b-4*rayon]) #0\\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\\n if b<600:\\n voisinage = add_list(voisinage,cases[a-4*rayon,b+4*rayon]) #6\\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\\n if a<1100-4*rayon:\\n voisinage = add_list(voisinage,cases[a+4*rayon,b]) #5\\n if b>200:\\n voisinage = add_list(voisinage,cases[a+4*rayon,b-4*rayon]) #2\\n voisinage = add_list(voisinage,cases[a,b-4*rayon]) #1\\n if b<600:\\n voisinage = add_list(voisinage,cases[a+4*rayon,b+4*rayon]) #8\\n voisinage = add_list(voisinage,cases[a,b+4*rayon]) #7\\n \\n #On ajoute plusieurs fois le meme a un ensemble -> pas grave\\n for i in voisinage:\\n xb,yb = l[i][0],l[i][1]\\n if 0<sqrt((x-xb)**2+(y-yb)**2)<=2*rayon+securite:\\n to_return.add(i)\\n return to_return\",\n \"def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):\\n return [\\n [sc.cVLS() for sc in scList]\\n for scList in GetSubContoursByFrame(watershed, allValsByFrame)\\n ]\",\n \"def getCriteriaSeries(mergedSegments,updatedSpeed,inversedIndex,WEIGHTS,minValidData):\\n return pd.concat([getNeighboursCriteriaIndex(x,mergedSegments,updatedSpeed,inversedIndex,WEIGHTS,minValidData=MIN_VALID_DATA) for x in inversedIndex.values])\",\n \"def get_contact_points(contact_points_path, json_name='contact_points.json',\\n dataset_type='ycb', use_clustering=True,\\n use_filter_penetration=True,\\n inf_penetration_check=True, get_label=False):\\n\\n if osp.isdir(contact_points_path):\\n contact_points_dict = load_multiple_contact_points(\\n contact_points_path, json_name)\\n else:\\n contact_points_dict = json.load(open(contact_points_path, 'r'))\\n contact_points = contact_points_dict['contact_points']\\n\\n\\n\\n if use_clustering:\\n contact_points = cluster_contact_points(\\n contact_points, min_samples=-1)\\n get_label = False\\n\\n if use_filter_penetration:\\n if inf_penetration_check:\\n box_size = [100, 0.0001, 0.0001]\\n else:\\n box_size = [0.1, 0.0001, 0.0001]\\n\\n dirname = osp.dirname(contact_points_path)\\n if dataset_type == 'ycb':\\n contact_points, _ = filter_penetration(\\n osp.join(dirname, 'base.urdf'),\\n contact_points, box_size=box_size)\\n else:\\n contact_points, _ = filter_penetration(\\n osp.join(dirname, urdf_name),\\n contact_points, box_size=box_size)\\n get_label = False\\n\\n if len(contact_points) == 0:\\n print('num of hanging points: {}'.format(len(contact_points)))\\n return None\\n\\n if get_label:\\n labels = contact_points_dict['labels']\\n return contact_points, labels\\n else:\\n return contact_points\",\n \"def _draw_connections(plot, clusters, sp_cache):\\n for path in sp_cache:\\n clsts = [_find_cluster(clusters, step) for step in sp_cache[path]]\\n plot.plot([c.centroid.x for c in clsts], [c.centroid.y for c in clsts], '-k', linewidth=0.09)\",\n \"def layer_coords(label_lst): #full path\\n \\n #if a fundus then do this block\\n gyrus_check = all(i.__contains__(\\\"fundus\\\") for i in label_lst)\\n if gyrus_check:\\n for layer in label_lst:\\n #read data\\n df_layer = pd.read_csv(layer)\\n df_layer = df_layer.iloc[1:,0]\\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\\\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\\n\\n #compute slope\\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\\n\\n #split lam label into three\\n split = math.floor(len(df_layer['X'].values)/3)\\n df_layer_right = df_layer[0:split]\\n df_layer_left = df_layer[-split:]\\n df_layer_middle = df_layer[split:-split]\\n\\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000'\\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\\n plt.axis('off')\\n plt.savefig('layer_contour.png')\\n # plt.show()\\n plt.close()\\n\\n #read, convert to grayscale, find edges\\n layer_img = cv2.imread('layer_contour.png')\\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\\n\\n #find contours\\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n # cv2.imshow('contour', layer_edges)\\n # cv2.waitKey(0)\\n # cv2.destroyAllWindows()\\n \\n #order contours\\n contours = [np.squeeze(i) for i in contours]\\n df_contours = pd.DataFrame(contours)\\n contours_ord = df_contours.loc[6].values, df_contours.loc[4].values, \\\\\\n df_contours.loc[3].values, df_contours.loc[2].values, \\\\\\n df_contours.loc[1].values, df_contours.loc[0].values, \\\\\\n df_contours.loc[5].values\\n contours_ord = np.squeeze(contours_ord)\\n \\n\\n #plot all layers and add coordinate data to dict \\n lay_coords_dict = {}\\n for laycon, i in zip(contours_ord, list(range(len(contours)))): \\n #split coordinates into top and bottom edge\\n if i == 0: #0 == pial\\n c_idx = int(np.floor(len(laycon)/2))\\n coords_top = np.array(list(reversed(laycon[:c_idx])))\\n lay_coords_dict[i] = coords_top[10:]\\n # print(coords_top)\\n\\n else:\\n c_idx = int(np.floor(len(laycon)/2))\\n coords_top = np.array(list(reversed(laycon[c_idx:])))\\n lay_coords_dict[i] = coords_top[5:-7]\\n\\n \\n #plot coords\\n # for key, val in lay_coords_dict.items():\\n # plt.plot([i[0] for i in val], [i[1] for i in val], lw=1.75)\\n # plt.gca().invert_yaxis()\\n # plt.show()\\n # plt.close()\\n # sys.exit()\\n\\n #delete edge detect image and return dict\\n rm_img_cmd = \\\"rm layer_contour.png\\\"\\n os.system(rm_img_cmd)\\n return(lay_coords_dict)\\n \\n\\n #for crown data do this block\\n else:\\n for layer in label_lst:\\n #read data\\n df_layer = pd.read_csv(layer)\\n df_layer = df_layer.iloc[1:,0]\\n df_layer = pd.DataFrame( [list(map(float, i)) for i in [list(i.split()) for i in \\\\\\n df_layer.values]], columns=['idk1', 'X', 'Y', 'Z', 'idk2'])[['X', 'Y', 'Z']]\\n\\n #compute slope\\n yvals = [(y2 - y1) for y1, y2 in zip(df_layer['Y'], df_layer['Y'][1:])]\\n xvals = [(x2 - x1) for x1, x2 in zip(df_layer['X'], df_layer['X'][1:])]\\n layer_slope = [round(i,2) for i in np.divide(yvals, xvals)]\\n\\n #split lam label into three\\n split = math.floor(len(df_layer['X'].values)/3)\\n df_layer_right = df_layer[0:split]\\n df_layer_left = df_layer[-split:]\\n df_layer_middle = df_layer[split:-split]\\n\\n plt.plot(df_layer['X'], df_layer['Y'], lw=3) #color='#000000', lw=5\\n # plt.plot(df_layer['X'], df_layer['Y'], linewidth=1, marker='o', markersize=5)\\n plt.axis('off')\\n plt.savefig('layer_contour.png')\\n # plt.show()\\n plt.close()\\n\\n #read, convert to grayscale, find edges\\n layer_img = cv2.imread('layer_contour.png')\\n layer_img_grey = cv2.cvtColor(layer_img, cv2.COLOR_BGR2GRAY)\\n layer_edges = cv2.Canny(layer_img_grey, 30, 200)\\n\\n #find contours\\n contours, hierachy = cv2.findContours(layer_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n # cv2.imshow('contour', layer_edges)\\n # cv2.waitKey(0)\\n # cv2.destroyAllWindows()\\n \\n\\n #plot all layers and add coordinate data to dict\\n lay_coords_dict = {}\\n for laycon, i in zip(contours, list(range( len(contours) ) )[::-1] ):#7\\n #split coordinates into top and bottom edge\\n # print(laycon)\\n coords_lst = [list(ii) for i in laycon for ii in i] # 0 == GWB\\n # print(coords_lst)\\n\\n c_split = math.floor(len(coords_lst)/4)\\n coords_top = coords_lst[:c_split][::-1] + coords_lst[-c_split:][::-1]\\n lay_coords_dict[i] = coords_top\\n df_coords = pd.DataFrame(coords_top, columns=['X', 'Y'])\\n # print(df_coords)\\n\\n #plot using all coordinates\\n plt.plot(df_coords['X'].values, df_coords['Y'].values, lw=3)\\n plt.gca().invert_yaxis()\\n # plt.show()\\n plt.close()\\n\\n\\n # use k means to get rid of extra coords on short lines\\n for i in list(range(1,6)):\\n # kMEANS clustering, separate short line bottom half\\n df_short = pd.DataFrame(lay_coords_dict[i], columns=['X', 'Y']) #1=L1,\\n # plt.scatter( df_short['X'].values, df_short['Y'].values, s=5 )\\n # plt.gca().invert_yaxis()\\n # plt.show()\\n\\n #scale data\\n scaler = StandardScaler()\\n scaler.fit( df_short[['X', 'Y']].values )\\n short_scale = scaler.transform( df_short[['X', 'Y']].values )\\n\\n init = np.array([[0.514, -0.629], [-1.101, 1.344]])\\n\\n #predict\\n # kmeans_classifier = KMeans(n_clusters=2, init=init) #fixed centroids\\n kmeans_classifier = KMeans(n_clusters=2) \\n\\n y_kmeans = kmeans_classifier.fit_predict(short_scale)\\n centroids = kmeans_classifier.cluster_centers_\\n inertia = kmeans_classifier.inertia_\\n\\n\\n #update df\\n df_short.insert(2, column='kClass', value=y_kmeans)\\n\\n #df scaled\\n df_short_scale = pd.DataFrame(short_scale, columns=['X', 'Y'])\\n df_short_scale.insert(2, column='kClass', value=y_kmeans)\\n \\n\\n \\\"\\\"\\\"\\n #plot data points for k means, clusters\\n colmap = {0: '#029386', 1: '#D2691E', 2: '#A52A2A'}\\n for i in range(2):\\n new_df = df_short_scale[df_short_scale['kClass']==i]\\n plt.scatter(new_df['X'].values, new_df['Y'].values, s=20, \\\\\\n label='cluster' + str(i+1), color=colmap[i])\\n\\n #plot centroids\\n for i in range (2):\\n plt.scatter(centroids[i][0], centroids[i][1], marker='x', s=500, \\\\\\n label='centroid' + str(i+1), color=colmap[i])\\n \\n plt.legend()\\n plt.gca().invert_yaxis()\\n plt.show()\\n \\\"\\\"\\\"\\n\\n\\n #new df for clean data, take centroid with more data points\\n num_class0 = len(df_short[df_short['kClass']==0])\\n num_class1 = len(df_short[df_short['kClass']==1])\\n\\n if num_class0 > num_class1:\\n \\n df_short_clean = df_short[df_short['kClass']==0]\\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\\\\n df_short_clean['Y'].values)]\\n else:\\n df_short_clean = df_short[df_short['kClass']==1]\\n lay_coords_dict[i] = [[i,j] for i,j in zip(df_short_clean['X'].values,\\\\\\n df_short_clean['Y'].values)]\\n\\n #plot clean short line\\n # plt.scatter(df_short_clean['X'].values, df_short_clean['Y'].values, s=20)\\n # plt.gca().invert_yaxis()\\n # plt.show()\\n\\n #delete edge detect image and return dict\\n rm_img_cmd = \\\"rm layer_contour.png\\\"\\n os.system(rm_img_cmd)\\n return(lay_coords_dict)\",\n \"def branches_library(point, dict_v, dict_e, list_v, kind_v, tuple_e):\\n branches=[[point]] #unfinished branches\\n lista=[] # finished branches, possible branches started in endpoint and ended in trunkpoint\\n next_points = []\\n while branches != []:\\n for branch in branches:\\n next_points = detect_next_points(branch[-1], branch[:-1], tuple_e)\\n temp_list=list()\\n \\n if len(next_points)==0:\\n branches.remove(branch)\\n continue\\n for pointn in next_points:\\n temp_list.append(branch+[pointn])\\n \\n branches.remove(branch)\\n\\n for br in temp_list:\\n if control_endpoint(br[-1],list_v, kind_v)==1:\\n lista.append(br)\\n else:\\n branches.append(br)\\n if len(lista)>10:\\n return lista\\n return lista\",\n \"def get_l_interface(n_v,n_c, neighbours, vs, CV_matrix,L):\\n h_j = np.empty((n_v, 3, 2))\\n for i in range(3):\\n h_j[:, i] = vs\\n h_jp1 = np.dstack((roll_reverse(neighbours[:,:,0]),roll_reverse(neighbours[:,:,1])))\\n l = np.mod(h_j - h_jp1 + L/2,L) - L/2\\n l = np.sqrt(l[:,:,0]**2 + l[:,:,1]**2)\\n LI = np.zeros((n_c,n_c),dtype=np.float32)\\n for i in range(3):\\n LI+= np.asfortranarray(l[:,i]*CV_matrix[:,:,i])@np.asfortranarray(CV_matrix[:,:,np.mod(i+2,3)].T)\\n return LI\",\n \"def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\\n orderOfSCsByValueByFrame = [\\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\\n ]\\n return scListByFrame, orderOfSCsByValueByFrame\",\n \"def lcs(hh, vv):\\n B=LCS.getB(hh,vv)\\n trac=LCS.backtrack(B);\\n cs=[ hh[h-1] for v,h,k in trac if k=='1' ]\\n return cs\",\n \"def crss(nds):\\n cross_product = []\\n nds = nodes[:, array(nds) - 1]\\n for i, j, k, l in zip([2, 3, 1, 4, 6, 7, 5, 8], [4, 1, 3, 2, 8, 5, 7, 6], \\n [5, 6, 8, 7, 1, 2, 4, 3], [1, 2, 4, 3, 5, 6, 8, 7]):\\n p1 = nds[:, i - 1]\\n p2 = nds[:, j - 1]\\n p3 = nds[:, k - 1]\\n p0 = nds[:, l - 1] \\n u = p1 - p0\\n v = p2 - p0\\n w = p3 - p0 \\n c = array([u[1]*v[2] - u[2]*v[1],\\n u[2]*v[0] - u[0]*v[2],\\n u[0]*v[1] - u[1]*v[0]])\\n cross_product.append(dot(w, c)) \\n \\n for i in range(4, 8):\\n cross_product[i] = - cross_product[i]\\n \\n return cross_product\",\n \"def detect_coeff_knee(coeffs, n_min=10, limit_order_up=8, limit_order_down=5,\\n threshold=0.05, min_window=4, window_ratio=0.01):\\n coeffs = np.absolute(np.asarray(coeffs))\\n max_coeff = coeffs.max()\\n coeffs = coeffs[n_min:]\\n coeffs = np.log10(coeffs)\\n max_coeff = np.log10(max_coeff)\\n N = len(coeffs)\\n window = max(min_window, int(window_ratio*N))\\n def f(i):\\n return max(coeffs[i-window:i+window])\\n wrange = lrange(window, N-window)\\n best = min([max(coeffs[i-window:i+window]) for i in wrange])\\n limit = min(best + limit_order_up, max_coeff - limit_order_down)\\n start_idx = wrange[-1]\\n while start_idx > wrange[0] and f(start_idx) < limit:\\n start_idx -= 1\\n if f(start_idx) >= limit and start_idx-window > 0:\\n coeffs = coeffs[start_idx-window:]\\n n_min += start_idx-window\\n N = len(coeffs)\\n wrange = range(window, N-window)\\n worst = coeffs.max()\\n def max_defect(i):\\n # Return the maximum (normalized) distance of the *knee* to the\\n # straight connection from 0 to i.\\n a = np.asarray([0, worst/best])\\n b = np.asarray([i/N, f(i)/best])\\n def _defect(j):\\n # Return the (normalized) distance of the point j to the\\n # connecting line 0 to i.\\n return f(j)/best - ((b[1]-a[1]) * float(j)/i + a[1])\\n return max([0] + [_defect(j) for j in range(window, i-window, window)])\\n # Search from the end to catch the highest resolution we might want to\\n # keep.\\n knee = next((i+n_min for i in reversed(wrange) if max_defect(i) < threshold), None)\\n if knee + window > wrange[-1]:\\n # We're below the threshold near the end already, so we should not\\n # detect a knee at all.\\n knee = None\\n return knee\",\n \"def get_verts(v_l, v_r):\\n\\n\\t\\tv_l = v_l%chain.length\\n\\t\\tv_r = v_r%chain.length\\n\\n\\t\\tpoints = []\\n\\t\\tcoords = list(chain.coords)\\n\\t\\tif v_r > v_l:\\n\\n\\t\\t\\tfor i in range(1, len(coords)):\\n\\t\\t\\t\\n\\t\\t\\t\\tpd = LineString(coords[:i+1]).length\\n\\n\\t\\t\\t\\tif pd > v_l and pd < v_r:\\n\\t\\t\\t\\t\\tpoints.append(coords[i])\\n\\t\\telse:\\n\\n\\t\\t\\tfor i in range(1, len(coords)):\\n\\t\\t\\t\\n\\t\\t\\t\\tpd = LineString(coords[:i+1]).length\\n\\n\\t\\t\\t\\tif pd > v_l:\\n\\t\\t\\t\\t\\tpoints.append(coords[i])\\n\\n\\t\\t\\tfor i in range(1, len(coords)):\\n\\t\\t\\t\\n\\t\\t\\t\\tpd = LineString(coords[:i+1]).length\\n\\n\\t\\t\\t\\tif pd < v_r:\\n\\t\\t\\t\\t\\tpoints.append(coords[i])\\n\\n\\n\\t\\treturn points\",\n \"def stop_connections(session, conn_list, at_date):\\n stop_at = int(at_date.gps)\\n data = []\\n for conn in conn_list:\\n print(\\n \\\"Stopping connection {}:{}<{} - {}>{}:{} at {}\\\".format(\\n conn[0], conn[1], conn[4], conn[2], conn[3], conn[5], str(at_date)\\n )\\n )\\n this_one = []\\n for cc in conn:\\n this_one.append(cc)\\n this_one.append(\\\"stop_gpstime\\\")\\n this_one.append(stop_at)\\n data.append(this_one)\\n with mc.MCSessionWrapper(session=session) as session:\\n update_connection(session, data, False)\",\n \"def all_lcs(X, Y):\\n return back_track_all(lcs_length(X, Y), X, Y, len(X), len(Y))\",\n \"def predecessors(xi):\\n X_K = xi.berkovich_line()\\n if xi.is_limit_point():\\n xi = xi.approximation()\\n y = xi.parameter()\\n v = xi.pseudovaluation_on_polynomial_ring()\\n v_list = v.augmentation_chain()[1:-1]\\n return [X_K.point_from_pseudovaluation_on_polynomial_ring(w, y)\\n for w in v_list]\",\n \"def diameter_clustering_vs_prob_ws(num_nodes, k):\\r\\n xdata = []\\r\\n ydata = []\\r\\n zdata = []\\r\\n prob = 0.0005\\r\\n while prob < 1:\\r\\n xdata += [prob]\\r\\n diameters = []\\r\\n coeffs = []\\r\\n for i in range(k):\\r\\n graph = make_ws_graph(num_nodes, 8, prob)\\r\\n diameters += [diameter(graph)]\\r\\n coeffs += [clustering_coefficient(graph)]\\r\\n ydata += [sum(diameters) / k / 19.0] #divide by 19 as this diameter of circle lattice\\r\\n zdata += [sum(coeffs) / k / 0.7] #divide by 0.7 as this is clustering coefficient of circle lattice\\r\\n prob = 1.2*prob\\r\\n return xdata, ydata, zdata\",\n \"def _vertical_blindspot_network(x):\\n skips = [x]\\n\\n n = x\\n n = _vshifted_conv(n, 48, 'enc_conv0')\\n n = _vshifted_conv(n, 48, 'enc_conv1')\\n n = _vshifted_pool(n)\\n skips.append(n)\\n\\n n = _vshifted_conv(n, 48, 'enc_conv2')\\n n = _vshifted_pool(n)\\n skips.append(n)\\n\\n n = _vshifted_conv(n, 48, 'enc_conv3')\\n n = _vshifted_pool(n)\\n skips.append(n)\\n\\n n = _vshifted_conv(n, 48, 'enc_conv4')\\n n = _vshifted_pool(n)\\n skips.append(n)\\n\\n n = _vshifted_conv(n, 48, 'enc_conv5')\\n n = _vshifted_pool(n)\\n n = _vshifted_conv(n, 48, 'enc_conv6')\\n\\n #-----------------------------------------------\\n n = UpSampling2D(2)(n)\\n n = Concatenate(axis=3)([n, skips.pop()])\\n n = _vshifted_conv(n, 96, 'dec_conv5')\\n n = _vshifted_conv(n, 96, 'dec_conv5b')\\n\\n n = UpSampling2D(2)(n)\\n n = Concatenate(axis=3)([n, skips.pop()])\\n n = _vshifted_conv(n, 96, 'dec_conv4')\\n n = _vshifted_conv(n, 96, 'dec_conv4b')\\n\\n n = UpSampling2D(2)(n)\\n n = Concatenate(axis=3)([n, skips.pop()])\\n n = _vshifted_conv(n, 96, 'dec_conv3')\\n n = _vshifted_conv(n, 96, 'dec_conv3b')\\n\\n n = UpSampling2D(2)(n)\\n n = Concatenate(axis=3)([n, skips.pop()])\\n n = _vshifted_conv(n, 96, 'dec_conv2')\\n n = _vshifted_conv(n, 96, 'dec_conv2b')\\n\\n n = UpSampling2D(2)(n)\\n n = Concatenate(axis=3)([n, skips.pop()])\\n n = _vshifted_conv(n, 96, 'dec_conv1a')\\n n = _vshifted_conv(n, 96, 'dec_conv1b')\\n\\n # final pad and crop for blind spot\\n n = ZeroPadding2D([[1,0],[0,0]])(n)\\n n = Cropping2D([[0,1],[0,0]])(n)\\n\\n return n\",\n \"def GetListOfNextConnections(TimeTableList, TimeTableIndex, StationHourIndex, CurrentStation, \\r\\n\\tabfahrt_std, abfahrt_min, WaitingTime):\\r\\n\\tinterval_start = 60*abfahrt_std + abfahrt_min\\r\\n\\tinterval_end = interval_start + WaitingTime\\r\\n\\r\\n\\tFilteredTimeTable = []\\r\\n\\thour = abfahrt_std\\r\\n\\r\\n\\t# what if key does not exist (i.e. no connection in data set)\\r\\n\\tif not StationHourIndex.has_key((CurrentStation, abfahrt_std)):\\r\\n\\t\\t# f.e. no connection found after 7.55 until 8:00\\r\\n\\t\\t\\r\\n\\t\\tif StationHourIndex.has_key((CurrentStation, abfahrt_std+1)):\\r\\n\\t\\t\\thour += 1\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn FilteredTimeTable\\r\\n\\r\\n\\tfor i in range(StationHourIndex[(CurrentStation, hour)], len(TimeTableList)):\\r\\n\\t\\tif TimeTableIndex[i] <= interval_end and TimeTableList[i][ConnInfoInd['station_from']] == CurrentStation:\\r\\n\\t\\t\\tif TimeTableIndex[i] >= interval_start:\\r\\n\\t\\t\\t\\tFilteredTimeTable.append(TimeTableList[i])\\r\\n\\t\\telse:\\r\\n\\t\\t\\tbreak\\r\\n\\treturn FilteredTimeTable\",\n \"def dotAstroLc(lc, id, classname):\\n lcs = []\\n numlcs = 0\\n data = lc\\n soup = BeautifulSoup(data)\\n try:\\n ra = float(soup('position2d')[0]('value2')[0]('c1')[0]\\n .renderContents())\\n dec = float(soup('position2d')[0]('value2')[0]('c2')[0]\\n .renderContents())\\n except IndexError:\\n print('position2d/value2/c1 or c2 tag not present in light curve file')\\n ra, dec = [None, None]\\n time_unit = []\\n for timeunitfield in soup(ucd=\\\"time.epoch\\\"):\\n time_unit.append(timeunitfield['unit'])\\n\\n for data_table in soup('tabledata'):\\n\\n epochs = []\\n mags = []\\n errs = []\\n\\n for row in data_table('tr'):\\n tds = row(\\\"td\\\")\\n epochs.append(float(tds[0].renderContents()))\\n mags.append(float(tds[1].renderContents()))\\n errs.append(float(tds[2].renderContents()))\\n\\n if len(epochs) > 0:\\n lcs.append(lightCurve(epochs, mags, errs, ra, dec, id,\\n time_unit[numlcs], classname))\\n numlcs += 1\\n\\n return lcs\",\n \"def _ppsc_gossip(self):\\n for i in range(self.s):\\n for edges in self.all_edges:\\n # for each connected component\\n selected_edge = random.choice(edges)\\n self._ppsc_gossip_edge(selected_edge)\",\n \"def allJPDs(net):\\r\\n \\r\\n onodes = net.Outputnodes()\\r\\n combinations = [i for i in itertools.combinations(onodes,2)]\\r\\n JPDdata = [] \\r\\n for c in combinations:\\r\\n priorA = getPrior(net,c[0])\\r\\n priorB = getPrior(net,c[1]) \\r\\n jpd = JPD(net,c)\\r\\n cov = Covariance (priorA,priorB,jpd)\\r\\n cor = Correlation (priorA,priorB,cov) \\r\\n JPDdata.append([c[0],c[1],jpd,cov,cor])\\r\\n return JPDdata\",\n \"def FindCouplings():\\n l1v = np.linspace(l1min, l1max, num=48)\\n l2v = np.logspace(np.log10(l2min), np.log10(l2max), num=48)\\n l3v = np.linspace(l3min, l3max, num=48)\\n gxv = np.linspace(gxmin, gxmax, num=48)\\n p = multiprocessing.Pool()\\n f = open(file_name, 'w+')\\n line = '|l1--l2--l3--gx--minima--mass1--mass2--stable|'\\n f.write(line+'\\\\n')\\n f.write('-'*90+'\\\\n')\\n f.close()\\n for l1 in l1v:\\n for l2 in l2v:\\n start_time_loop = time.time()\\n params = cartesian((l1, -l2, l3v, gxv))\\n print params.shape\\n p.map(CheckCouplings, params)\\n print(\\\"--- Loop has taken: %s seconds ---\\\" % (time.time() - start_time_loop))\",\n \"def get_networks_from_multiplex_pajek(pajek):\\n\\n def _extract_intra_links(pajek):\\n \\\"\\\"\\\"Return dictionary of intralayer `nx.Graph`s from input formatted pajek\\\"\\\"\\\"\\n string_links = re.findall(r\\\"\\\\d+ \\\\d+ \\\\d+.*\\\", pajek.split(\\\"*Intra\\\")[1].split(\\\"*Inter\\\")[0])\\n intra_links = [list(map(eval, link.split())) for link in string_links]\\n G_arr_intra = defaultdict(lambda: nx.Graph)\\n for l in intra_links:\\n G_arr_intra[l[0]].add_edge(l[1], l[2])\\n return G_arr_intra\\n \\n def _extract_intra_links_from_multiplex(pajek):\\n \\\"\\\"\\\"Return dictionary of intralayer `nx.Graph`s from output formatted pajek\\\"\\\"\\\"\\n string_links = re.findall(r\\\"\\\\d+ \\\\d+ \\\\d+ \\\\d+.*\\\", pajek.split(\\\"*multiplex\\\")[1])\\n value_links = [list(map(eval, link.split())) for link in string_links]\\n G_arr_intra = defaultdict(lambda: nx.Graph)\\n for l in value_links:\\n if l[0] == l[2]:\\n G_arr_intra[l[0]].add_edge(l[1], l[3])\\n return G_arr_intra\\n \\n if \\\"*Intra\\\" in pajek:\\n return _extract_intra_links(pajek)\\n if \\\"*multiplex\\\" in pajek:\\n return _extract_intra_links_from_multiplex(pajek)\\n \\n raise ValueError(\\\"No intra links inside pajek\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6758528","0.65826356","0.5632501","0.55175966","0.54169285","0.5379928","0.5346093","0.5311847","0.53098977","0.52789253","0.52344453","0.52038324","0.5167569","0.51378644","0.51114464","0.50953865","0.5084913","0.5053021","0.5044931","0.5041024","0.5013001","0.50111765","0.50046015","0.50027806","0.49950987","0.49884048","0.49780113","0.49647602","0.49543485","0.4924476","0.49196208","0.4916995","0.49165225","0.4911022","0.49003166","0.48839307","0.4882995","0.48754153","0.48680452","0.48621124","0.48554903","0.48344758","0.48322737","0.48261455","0.4813884","0.4809351","0.4790475","0.47821882","0.47704002","0.47658956","0.47605494","0.47597703","0.47537455","0.47358114","0.47320256","0.4728254","0.47275957","0.47251415","0.4724504","0.47160354","0.47100803","0.46954155","0.4689708","0.46895868","0.4688601","0.4684663","0.4684648","0.4682801","0.46826592","0.46768817","0.46601775","0.46592224","0.4659105","0.465875","0.46558917","0.46418124","0.46389243","0.46384177","0.46364626","0.46349382","0.46290854","0.46289733","0.46278334","0.4622387","0.4618315","0.46153876","0.4613479","0.46126232","0.46122158","0.46067482","0.46057642","0.46056253","0.4605544","0.4605077","0.460258","0.4596858","0.45965484","0.45950326","0.45949984","0.45939234"],"string":"[\n \"0.6758528\",\n \"0.65826356\",\n \"0.5632501\",\n \"0.55175966\",\n \"0.54169285\",\n \"0.5379928\",\n \"0.5346093\",\n \"0.5311847\",\n \"0.53098977\",\n \"0.52789253\",\n \"0.52344453\",\n \"0.52038324\",\n \"0.5167569\",\n \"0.51378644\",\n \"0.51114464\",\n \"0.50953865\",\n \"0.5084913\",\n \"0.5053021\",\n \"0.5044931\",\n \"0.5041024\",\n \"0.5013001\",\n \"0.50111765\",\n \"0.50046015\",\n \"0.50027806\",\n \"0.49950987\",\n \"0.49884048\",\n \"0.49780113\",\n \"0.49647602\",\n \"0.49543485\",\n \"0.4924476\",\n \"0.49196208\",\n \"0.4916995\",\n \"0.49165225\",\n \"0.4911022\",\n \"0.49003166\",\n \"0.48839307\",\n \"0.4882995\",\n \"0.48754153\",\n \"0.48680452\",\n \"0.48621124\",\n \"0.48554903\",\n \"0.48344758\",\n \"0.48322737\",\n \"0.48261455\",\n \"0.4813884\",\n \"0.4809351\",\n \"0.4790475\",\n \"0.47821882\",\n \"0.47704002\",\n \"0.47658956\",\n \"0.47605494\",\n \"0.47597703\",\n \"0.47537455\",\n \"0.47358114\",\n \"0.47320256\",\n \"0.4728254\",\n \"0.47275957\",\n \"0.47251415\",\n \"0.4724504\",\n \"0.47160354\",\n \"0.47100803\",\n \"0.46954155\",\n \"0.4689708\",\n \"0.46895868\",\n \"0.4688601\",\n \"0.4684663\",\n \"0.4684648\",\n \"0.4682801\",\n \"0.46826592\",\n \"0.46768817\",\n \"0.46601775\",\n \"0.46592224\",\n \"0.4659105\",\n \"0.465875\",\n \"0.46558917\",\n \"0.46418124\",\n \"0.46389243\",\n \"0.46384177\",\n \"0.46364626\",\n \"0.46349382\",\n \"0.46290854\",\n \"0.46289733\",\n \"0.46278334\",\n \"0.4622387\",\n \"0.4618315\",\n \"0.46153876\",\n \"0.4613479\",\n \"0.46126232\",\n \"0.46122158\",\n \"0.46067482\",\n \"0.46057642\",\n \"0.46056253\",\n \"0.4605544\",\n \"0.4605077\",\n \"0.460258\",\n \"0.4596858\",\n \"0.45965484\",\n \"0.45950326\",\n \"0.45949984\",\n \"0.45939234\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71487695"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93480,"cells":{"query":{"kind":"string","value":"Make 2 simplified subcontour networks, one for scListRef and another for scList with a 1to1 mapping to the first"},"document":{"kind":"string","value":"def GetMatchedSubContourLists(\n scListRef,\n scList,\n allValsByFrame,\n orderOfSCsByValue,\n splitLength=1,\n fixedNumInteriorPoints=None,\n):\n ## NOT DONE! MERGE LATER??\n return simplifiedSCListRef, simplifiedSCList"},"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 GetMatchedSubContourListsCollapsing(scListA, scListB):\n\n if (\n scListA == scListB\n ): # if we got the same object for some reason, just return 2 shallow clones\n return scListA, scListB\n\n scsMatchedInB = [] # This keeps us from looping over both lists\n\n scsMatchedInB, removeFromA, removeFromB = FindMatchesAndRemovals(scListA, scListB)\n unMatchedInB = [\n i for i in range(len(scListB)) if i not in scsMatchedInB\n ] # This lets us skip the indexes that already matched\n\n _, removeFromB_2, removeFromA_2 = FindMatchesAndRemovals(\n scListB, scListA, searchInds=unMatchedInB\n ) # FLIP\n\n removeFromA = sorted(list(set(removeFromA + removeFromA_2)))\n removeFromB = sorted(list(set(removeFromB + removeFromB_2)))\n\n scListANew = deepcopy(scListA)\n scListBNew = deepcopy(scListB)\n\n for i in removeFromA[::-1]:\n RemoveSubContour(scListA, i)\n for i in removeFromB[::-1]:\n RemoveSubContour(scListB, i)\n\n return scListANew, scListBNew","def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\n # number of nodes\n nx = 5 # along x\n ny = 5 # along y\n\n # getting integration points\n nint = 4\n points, weights = get_points_weights(nint=nint)\n\n # geometry\n a = 3 # along x\n b = 3 # along y\n\n # material properties\n E = 200e9\n nu = 0.3\n laminaprop = (E, E, nu)\n stack = [0]\n h = 0.001\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\n\n # creating mesh\n x = np.linspace(0, a, nx)\n y = np.linspace(0, b, ny)\n xmesh, ymesh = np.meshgrid(x, y)\n\n # node coordinates and position in the global matrix\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\n nids = 1 + np.arange(ncoords.shape[0])\n nid_pos = dict(zip(nids, np.arange(len(nids))))\n\n # identifying nodal connectivity for plate elements\n # similar than Nastran's CQUAD4\n #\n # ^ y\n # |\n #\n # 4 ________ 3\n # | |\n # | | --> x\n # | |\n # |_______|\n # 1 2\n\n\n nids_mesh = nids.reshape(nx, ny)\n n1s = nids_mesh[:-1, :-1].flatten()\n n2s = nids_mesh[1:, :-1].flatten()\n n3s = nids_mesh[1:, 1:].flatten()\n n4s = nids_mesh[:-1, 1:].flatten()\n\n num_elements = len(n1s)\n print('num_elements', num_elements)\n\n N = DOF*nx*ny\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n init_k_KC0 = 0\n init_k_KG = 0\n\n plates = []\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\n plate = BFSPlate2D()\n plate.n1 = n1\n plate.n2 = n2\n plate.n3 = n3\n plate.n4 = n4\n plate.c1 = DOF*nid_pos[n1]\n plate.c2 = DOF*nid_pos[n2]\n plate.c3 = DOF*nid_pos[n3]\n plate.c4 = DOF*nid_pos[n4]\n plate.ABD = lam.ABD\n plate.lex = a/(nx - 1)\n plate.ley = b/(ny - 1)\n plate.init_k_KC0 = init_k_KC0\n plate.init_k_KG = init_k_KG\n update_KC0(plate, points, weights, Kr, Kc, Kv)\n init_k_KC0 += KC0_SPARSE_SIZE\n init_k_KG += KG_SPARSE_SIZE\n plates.append(plate)\n\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\n\n # applying boundary conditions\n\n # locating nodes\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\n\n x = ncoords[:, 0]\n y = ncoords[:, 1]\n\n # applying boundary conditions\n # simply supported\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\n bk[2::DOF] = check\n check = isclose(x, 0) | isclose(x, a)\n bk[3::DOF] = check\n # point supports\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\n bk[0::DOF] = check\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\n bk[1::DOF] = check\n\n # unconstrained nodes\n bu = ~bk # logical_not\n\n # defining external force vector\n fext = np.zeros(KC0.shape[0], dtype=float)\n\n # applying unitary load along u at x=a\n # nodes at vertices get 1/2 the force\n for plate in plates:\n pos1 = nid_pos[plate.n1]\n pos2 = nid_pos[plate.n2]\n pos3 = nid_pos[plate.n3]\n pos4 = nid_pos[plate.n4]\n if isclose(x[pos3], a):\n Nxx = -1\n xi = +1\n elif isclose(x[pos1], 0):\n Nxx = +1\n xi = -1\n else:\n continue\n lex = plate.lex\n ley = plate.ley\n indices = []\n c1 = DOF*pos1\n c2 = DOF*pos2\n c3 = DOF*pos3\n c4 = DOF*pos4\n cs = [c1, c2, c3, c4]\n for ci in cs:\n for i in range(DOF):\n indices.append(ci + i)\n fe = np.zeros(4*DOF, dtype=float)\n for j in range(nint):\n eta = points[j]\n plate.update_Nu(xi, eta)\n Nu = np.asarray(plate.Nu)\n fe += ley/2*weights[j]*Nu*Nxx\n fext[indices] += fe\n\n Kuu = KC0[bu, :][:, bu]\n fextu = fext[bu]\n\n # static solver\n uu = spsolve(Kuu, fextu)\n u = np.zeros(KC0.shape[0], dtype=float)\n u[bu] = uu\n\n if plot_static:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n uplot = u[0::DOF].reshape(nx, ny).T\n vplot = u[1::DOF].reshape(nx, ny).T\n print('u extremes', uplot.min(), uplot.max())\n print('v extremes', vplot.min(), vplot.max())\n levels = np.linspace(uplot.min(), uplot.max(), 300)\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n # eigenvalue solver\n\n # getting integration points\n for plate in plates:\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\n KGuu = KG[bu, :][:, bu]\n\n # solving modified generalized eigenvalue problem\n # Original: (KC0 + lambda*KG)*v = 0\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\n num_eigenvalues = 5\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\n tol=1e-6, sigma=1., mode='cayley')\n eigvals = -1./eigvals\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\n eigvecs[bu, :] = eigvecsu\n\n if plot_lb:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n mode = 0\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\n levels = np.linspace(wplot.min(), wplot.max(), 300)\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\n assert isclose(kc, 6.6, rtol=0.05)","def construct_network(self):\n r = 0\n n = self.nbr_0_splxs\n for k in range(n):\n self.splxs.append((0, (0, k)))\n self.nbr_splxs += 1\n r, edge = self.find_next_edge(r)\n # this while loop finds the new edge to treat and add it to the 1-splx list and then finds out if a 2-splx is created\n while edge != (-1, -1):\n # Add the new edge\n self.one_splxs.append((edge, self.nbr_splxs))\n self.splxs.append((1, self.nbr_1_splxs))\n self.nbr_1_splxs += 1\n self.nbr_splxs += 1\n self.dist_appearance.append(r)\n a, b = edge\n # find out if a 2-splx has been created\n for i in range(self.nbr_1_splxs - 1):\n c, d = self.one_splxs[i][0]\n if d == a:\n for j in range(i + 1, self.nbr_1_splxs - 1):\n e, f = self.one_splxs[j][0]\n if e == c and f == b:\n self.two_splxs.append((self.nbr_1_splxs - 1, i, j))\n self.splxs.append((2, self.nbr_2_splxs))\n self.nbr_2_splxs += 1\n self.nbr_splxs += 1\n self.dist_appearance.append(r)\n # find the next edge to treat\n r, edge = self.find_next_edge(r)\n print(\"Network created\")\n return ()","def build_csls_subgraphs(self):\n # Graph for calculating only score\n scores_s2t = self.build_eval_graph(\n \"ScoreS2T\", self.src_ten, self.tgt_ten, en_knn=False, en_mean=False\n )\n scores_t2s = self.build_eval_graph(\n \"ScoreT2S\", self.tgt_ten, self.src_ten, en_knn=False, en_mean=False\n )\n # Graphs for calculating average between source and target\n avg1_s2t = self.build_eval_graph(\"Avg1\", self.src_ten, self.tgt_ten, knn=10)\n avg2_s2t = self.build_eval_graph(\"Avg2\", self.tgt_ten, self.src_ten, knn=10)\n # Graph for selecting top 100 elements\n top100_matches = tf.nn.top_k(self.score_ph, 100)\n # Graph for selecting top 2 elements\n top2_matches = tf.nn.top_k(self.score_ph, 2)\n # Graph for calculating similarity\n csls_mean_score = self.build_sim_graph(\"SimGraph\")\n\n # Dictionary\n csls_graphs = {\n \"ScoreGraph\": scores_s2t,\n \"ScoreG_T2S\": scores_t2s,\n \"Avg1S2T\": avg1_s2t,\n \"Avg2S2T\": avg2_s2t,\n \"Top100\": top100_matches,\n \"Top2\": top2_matches,\n \"CSLS_Criteria\": csls_mean_score,\n }\n return csls_graphs","def __init__(self,\n name,\n vertices_location,\n connectivity,\n connectivity_ids=None,\n connectivity_label=None,\n connectivity_label_metadata=None,\n connectivity_colormap = None,\n connector_size=2.6,\n global_deselect_alpha=0.2,\n global_select_alpha=1.0,\n skeleton_linewidth=2.0):\n super(Microcircuit, self).__init__( name )\n\n if not connectivity_ids is None:\n self.connectivity_ids = connectivity_ids\n\n if not connectivity_label is None:\n self.connectivity_labels = connectivity_label\n\n if not connectivity_label_metadata is None:\n\n for semanticdict in connectivity_label_metadata:\n # name needs to be based on convention, TODO: best from ontology id rather than string!\n # TODO: use microcircuit convention\n if semanticdict.has_key(\"name\"):\n name = semanticdict[\"name\"]\n if \"skeleton\" in name:\n self.con_skeleton = int(semanticdict[\"value\"])\n elif \"presynaptic\" in name:\n self.con_pre = int(semanticdict[\"value\"])\n elif \"postsynaptic\" in name:\n self.con_post = int(semanticdict[\"value\"])\n\n else:\n # TODO: default\n self.con_skeleton = 1\n self.con_pre = 2\n self.con_post = 3\n\n # selection stores integer ids from connectivity_selectionID\n # when selected\n self.skeleton_selection = []\n\n # use the connectivity labels to extract the connectivity for the skeletons\n self.index_skeleton = np.where(self.connectivity_labels == self.con_skeleton)[0]\n self.index_allpre = np.where(self.connectivity_labels == self.con_pre)[0]\n self.index_allpost = np.where(self.connectivity_labels == self.con_post)[0]\n \n self.vertices = vertices_location\n self.connectivity = connectivity\n\n connectivity_skeleton = self.connectivity[self.index_skeleton]\n self.vertices_skeleton = self.vertices[ connectivity_skeleton.ravel() ]\n \n # we have a simplified connectivity now\n self.connectivity_skeleton = np.array( range(len(self.vertices_skeleton)), dtype = np.uint32 )\n self.connectivity_skeleton = self.connectivity_skeleton.reshape( (len(self.connectivity_skeleton)/2, 2) )\n self.connectivity_ids_skeleton = self.connectivity_ids[ self.index_skeleton ]\n\n # look up the start and end vertex id\n # map these to _skeleton arrays, and further to actor???\n\n # colors for skeletons\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_skeleton ):\n self.connectivity_skeleton_colors = np.repeat(connectivity_colormap[self.con_skeleton], len(self.connectivity_skeleton), axis=0).astype( np.float32 )\n\n ##########\n # Incoming connectors\n ##########\n\n # extract the pre connectivity and create cones\n # store the indices for to be used to create the vector scatter\n # by itself, it represent implicitly the index used to select/deselect the vectors\n if len(self.index_allpre) == 0:\n if DEBUG:\n print \"no presynaptic connection\"\n self.pre_actor = None\n else:\n self.vertices_pre = self.vertices[ connectivity[self.index_allpre].ravel() ]\n self.pre_p1 = self.vertices_pre[::2, :] # data is NOT copied here\n self.pre_p2 = self.vertices_pre[1::2, :]\n pren = len(self.index_allpre)\n r1 = np.ones( pren, dtype = np.float32 ) * connector_size\n r2 = np.zeros( pren, dtype = np.float32 )\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_pre ):\n preval = np.ones( pren, dtype = np.dtype(type(self.con_pre)) ) * self.con_pre\n else:\n preval = None\n self.pre_actor = VectorScatter( \"PreConnector\", self.pre_p1, self.pre_p2, r1, r2, values = preval,\n resolution = 8, colormap = connectivity_colormap )\n # len(self.index_pre) = len(self.pre_p1) = len(preval)\n\n ##########\n # Outgoing connectors\n ##########\n\n # extract the post connectivity and create cones\n if len(self.index_allpost) == 0:\n if DEBUG:\n print \"no postsynaptic connection\"\n self.post_actor = None\n else:\n self.vertices_post = self.vertices[ connectivity[self.index_allpost].ravel() ]\n self.post_p1 = self.vertices_post[::2, :]\n self.post_p2 = self.vertices_post[1::2, :]\n postn = len(self.index_allpost)\n r1 = np.zeros( postn, dtype = np.float32 )\n r2 = np.ones( postn, dtype = np.float32 ) * connector_size\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_post ):\n postval = np.ones( postn, dtype = np.dtype(type(self.con_post)) ) * self.con_post\n else:\n postval = None\n self.post_actor = VectorScatter( \"PostConnector\", self.post_p1, self.post_p2, r1, r2, values = postval,\n resolution = 8, colormap = connectivity_colormap )\n\n ##########\n # Skeletons\n ##########\n self.skeleton = Skeleton( name = \"Polygon Lines\",\n vertices = self.vertices_skeleton,\n connectivity = self.connectivity_skeleton,\n connectivity_colors = self.connectivity_skeleton_colors,\n connectivity_ID = self.connectivity_ids_skeleton,\n linewidth = skeleton_linewidth,\n global_deselect_alpha = global_deselect_alpha,\n global_select_alpha = global_select_alpha )\n\n self.connectivity_skeletononly_ids = None\n self.connectivity_preonly_ids = None\n self.connectivity_postonly_ids = None\n\n self.global_deselect_alpha = global_deselect_alpha\n self.global_select_alpha = global_select_alpha","def sub_graph_merging(self):","def LimitPointsBetweenSubContourNodes(scList, numInteriorPointsDict, interpolate=True):\n limIntPtsFunc = (\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\n )\n for sc in scList:\n sc.points = limIntPtsFunc(sc.points, numInteriorPointsDict[tuple(sc.values)])","def sweep_CPPN(genotype, E1, subp_1, subp_2, norm_in, canvas):\n\n\t# get value from widget field\n\tinnov_num = E1.get()\n\n\t# find index of desired connection\n\tindex = -1\n\tfor con_ind in range(len(genotype.connections)):\n\t\tif(genotype.connections[con_ind].getInnovationNumber() == innov_num):\n\t\t\tindex = con_ind\n\told_weight = genotype.connections[con_ind].getWeight()\n\n\tsweep_weight = 10\n\twhile(sweep_weight > -10):\n\t\tgenotype.connections[con_ind].setWeight(sweep_weight)\n\t\t# clear both subplots so new graphs can be placed into the GUI\n\t\tsubp_1.clear()\n\t\tsubp_2.clear()\n\n\t\t# create graphs again and put graphs onto them\n\t\toutputs = []\n\t\tfor ins in norm_in:\n\t\t\toutputs.append(genotype.getOutput(ins)[0])\n\t\toutputs_np = np.array(outputs, copy=True)\n\t\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\n\n\t\tgraph_genotype_GUI(genotype, subp_2)\n\n\t\tcanvas.show()\n\t\tcanvas.get_tk_widget().pack()\n\t\tsweep_weight -= .5\n\t\ttime.sleep(TIME_DELAY)\n\n\t# reset the graphs to their old state with the original weight\n\tgenotype.connections[con_ind].setWeight(old_weight)\n\t# clear both subplots so new graphs can be placed into the GUI\n\tsubp_1.clear()\n\tsubp_2.clear()\n\n\t# create graphs again and put graphs onto them\n\toutputs = []\n\tfor ins in norm_in:\n\t\toutputs.append(genotype.getOutput(ins)[0])\n\toutputs_np = np.array(outputs, copy=True)\n\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\n\n\tgraph_genotype_GUI(genotype, subp_2)\n\n\tcanvas.show()\n\tcanvas.get_tk_widget().pack()","def connect_synfluct(self, PF_BG_rate=6, PF_BG_cv=1, STL_BG_rate=20, STL_BG_cv=1):\n \n if self.do_run:\n \n for m in self.ST_stims:\n del m \n del self.ST_stims\n \n for m in self.PF_stims:\n del m \n del self.PF_stims\n \n self.ST_stims = []\n self.PF_stims = []\n \n \n for n in range(self.n_celltypes):\n \n for i, gid in enumerate(self.gidlist[n]): # for every cell in the gidlist \n \n PF_syn_list = self.cells[n][i].createsyn_PF()\n \n for d in PF_syn_list:\n d.input.newnetstim.number = 1e9\n d.input.newnetstim.noise = PF_BG_cv\n d.input.newnetstim.interval = 1000.0 / PF_BG_rate\n d.input.newnetstim.start = 0\n \n self.PF_stims.append(PF_syn_list)\n \n ST_stim_list = self.cells[n][i].createsyn_ST(record_all=0)\n\n for d in ST_stim_list:\n d.newnetstim.number = 1e9\n d.newnetstim.noise = STL_BG_cv\n d.newnetstim.interval = 1000.0 / STL_BG_rate\n d.newnetstim.start = 0\n \n self.ST_stims.append(ST_stim_list)\n \n if self.id == 0: print \"- PF and ST stimulation added.\"","def test_construct_subcircuit_layers(self):\r\n dev = qml.device(\"default.qubit\", wires=3)\r\n\r\n def circuit(params):\r\n # section 1\r\n qml.RX(params[0], wires=0)\r\n # section 2\r\n qml.RY(params[1], wires=0)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n # section 3\r\n qml.RX(params[2], wires=0)\r\n qml.RY(params[3], wires=1)\r\n qml.RZ(params[4], wires=2)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n # section 4\r\n qml.RX(params[5], wires=0)\r\n qml.RY(params[6], wires=1)\r\n qml.RZ(params[7], wires=2)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n return qml.expval(qml.PauliX(0)), qml.expval(qml.PauliX(1)), qml.expval(qml.PauliX(2))\r\n\r\n circuit = qml.QNode(circuit, dev)\r\n\r\n params = np.ones([8])\r\n tapes = circuit.metric_tensor(params, only_construct=True)\r\n\r\n # this circuit should split into 4 independent\r\n # sections or layers when constructing subcircuits\r\n assert len(tapes) == 4\r\n\r\n # first layer subcircuit\r\n assert len(tapes[0].operations) == 1\r\n assert isinstance(tapes[0].operations[0], qml.Hadamard) # PauliX decomp\r\n\r\n # second layer subcircuit\r\n assert len(tapes[1].operations) == 4\r\n assert isinstance(tapes[1].operations[0], qml.RX)\r\n # PauliY decomp\r\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\r\n assert isinstance(tapes[1].operations[2], qml.S)\r\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\r\n\r\n # # third layer subcircuit\r\n assert len(tapes[2].operations) == 8\r\n assert isinstance(tapes[2].operations[0], qml.RX)\r\n assert isinstance(tapes[2].operations[1], qml.RY)\r\n assert isinstance(tapes[2].operations[2], qml.CNOT)\r\n assert isinstance(tapes[2].operations[3], qml.CNOT)\r\n # PauliX decomp\r\n assert isinstance(tapes[2].operations[4], qml.Hadamard)\r\n # PauliY decomp\r\n assert isinstance(tapes[2].operations[5], qml.PauliZ)\r\n assert isinstance(tapes[2].operations[6], qml.S)\r\n assert isinstance(tapes[2].operations[7], qml.Hadamard)\r\n\r\n # # fourth layer subcircuit\r\n assert len(tapes[3].operations) == 13\r\n assert isinstance(tapes[3].operations[0], qml.RX)\r\n assert isinstance(tapes[3].operations[1], qml.RY)\r\n assert isinstance(tapes[3].operations[2], qml.CNOT)\r\n assert isinstance(tapes[3].operations[3], qml.CNOT)\r\n assert isinstance(tapes[3].operations[4], qml.RX)\r\n assert isinstance(tapes[3].operations[5], qml.RY)\r\n assert isinstance(tapes[3].operations[6], qml.RZ)\r\n assert isinstance(tapes[3].operations[7], qml.CNOT)\r\n assert isinstance(tapes[3].operations[8], qml.CNOT)\r\n # PauliX decomp\r\n assert isinstance(tapes[3].operations[9], qml.Hadamard)\r\n # PauliY decomp\r\n assert isinstance(tapes[3].operations[10], qml.PauliZ)\r\n assert isinstance(tapes[3].operations[11], qml.S)\r\n assert isinstance(tapes[3].operations[12], qml.Hadamard)","def osnc(pl, refnd):\n return [refnd[i] for i in pl]","def subCruise(self, footprints):\n sub = Cruise()\n sub.V = [v for v in self.V if v.uid in footprints]\n sub.E = []\n sub.neighbours = {}\n sub.resorts = {}\n for key, value in self.neighbours.items():\n sub.neighbours[key] = []\n if key in footprints:\n sub.V.extend([self.V[v] for v in value if self.V[v] not in sub.V])\n sub.E.extend([(key, v) for v in value])\n sub.neighbours.get(key).extend(value)\n for v in value:\n sub.neighbours[v] = [key]\n\n p = set(sub.V)\n #sorted_resorts = sorted(self.resorts, key=len, reverse=True)\n for key, resort in self.resorts.items():\n s = set(resort.footprints)\n if len(tuple(s & p)) > 0:\n sub.resorts[key] = Resort(list(tuple(s & p)))\n p -= s\n if len(tuple(p)) == 0:\n break\n\n addresstamp = reduce(lambda x, y: x + y, [v.addresstamp for v in sub.V])\n sub.upperleft = list(map(min, zip(*addresstamp)))\n sub.bottomright = list(map(max, zip(*addresstamp)))\n sub.upperright = [sub.bottomright[0], sub.upperleft[1]]\n sub.bottomleft = [sub.upperleft[0], sub.bottomright[1]]\n (sub.W, sub.H) = (sub.upperright[0] - sub.bottomleft[0], sub.bottomleft[1] - sub.upperright[1])\n sub.grid = self.grid[np.ix_(list(range(sub.upperleft[1],sub.bottomleft[1])), list(range(sub.upperleft[0],sub.bottomright[0])))]\n\n assert sub.W >= 0\n assert sub.H >= 0\n return sub","def generate_connectivity_constraint(problem, b_list, add_S):\n\n # Constructing A_iq and b_iq for inequality (38) for all S in add_S as sp.coo matrix\n A_iq_row = []\n A_iq_col = []\n A_iq_data = []\n\n constraint_idx = 0\n # For each base\n for b, S_v_t in product(b_list, add_S):\n pre_S_transition = problem.graph.pre_tran_vt(S_v_t)\n pre_S_connectivity = problem.graph.pre_conn_vt(S_v_t)\n for v, t in S_v_t:\n # add y\n A_iq_row.append(constraint_idx)\n A_iq_col.append(problem.get_yb_idx(b, v, t))\n A_iq_data.append(1)\n for v0, v1, t0 in pre_S_transition:\n A_iq_row.append(constraint_idx)\n A_iq_col.append(problem.get_x_idx(b, v0, v1, t0))\n A_iq_data.append(-1)\n for v0, v1, t1 in pre_S_connectivity:\n A_iq_row.append(constraint_idx)\n A_iq_col.append(problem.get_xbar_idx(b, v0, v1, t1))\n A_iq_data.append(-1)\n constraint_idx += 1\n A_iq_38 = sp.coo_matrix(\n (A_iq_data, (A_iq_row, A_iq_col)), shape=(constraint_idx, problem.num_vars)\n )\n\n return Constraint(A_iq=A_iq_38, b_iq=np.zeros(constraint_idx))","def cfdProcessElementTopology(self):\r\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \r\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\r\n\r\n ## (list of lists) list of face indices forming each element\r\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\r\n \r\n #populates self.elementNeighbours\r\n for iFace in range(self.numberOfInteriorFaces):\r\n own=self.owners[iFace]\r\n nei=self.neighbours[iFace]\r\n \r\n #adds indices of neighbour cells\r\n self.elementNeighbours[own].append(nei)\r\n self.elementNeighbours[nei].append(own)\r\n \r\n #adds interior faces\r\n self.elementFaces[own].append(iFace)\r\n self.elementFaces[nei].append(iFace)\r\n \r\n #adds boundary faces ('patches')\r\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\r\n own=self.owners[iFace]\r\n self.elementFaces[own].append(iFace)\r\n \r\n ## List of lists containing points forming each element\r\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n \r\n for faceIndex in self.elementFaces[iElement]:\r\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\r\n \r\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\r\n \r\n ## Upper coefficient indices (owners)\r\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n ## Lower coefficient indices (owners)\r\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n ## Element number from 1 to numberOfElements + 1\r\n iNb=1\r\n for faceIndex in self.elementFaces[iElement]:\r\n \r\n #skip if it is a boundary face\r\n if faceIndex > self.numberOfInteriorFaces-1:\r\n continue\r\n \r\n own = self.owners[faceIndex]\r\n nei = self.neighbours[faceIndex]\r\n \r\n if iElement == own:\r\n self.upperAnbCoeffIndex[faceIndex] = iNb\r\n elif iElement == nei:\r\n self.lowerAnbCoeffIndex[faceIndex] = iNb\r\n \r\n iNb = iNb +1","def TNFR1_to_SecondaryComplex():\n \n Parameter('TNFa_0' , 5000) # 3000 corresponds to 50ng/ml TNFa\n Parameter('TNFR1_0' , 200) # 200 receptors per cell\n Parameter('TRADD_0' , 1000) # molecules per cell (arbitrarily assigned)1000\n Parameter('CompI_0' , 0) # complexes per cell\n Parameter('RIP1_0' , 20000) # molecules per cell 20000\n Parameter('NFkB_0' , 0) # molecules per cell\n \n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\n Initial(RIP1(bDD=None, bRHIM = None, state = 'ub'), RIP1_0) # RIP1\n Initial(NFkB(bf=None), NFkB_0)\n\n # =========================================\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\n # -----------------------------------------\n # TNFa+ TNFR1 <-> TNFa:TNFR1\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub \n \n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\n # [active]CompI:RIP1 >> [active]CompI + RIP1\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\n\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it. \n\n # ------------------------------------------\n \n # -------------Complex I assembly----------------\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [KF, KR])\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [KF, KR])\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), KC)\n \n # --------------Complex I - RIP1 Modification-----------------\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[KF, KR])\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR]) \n \n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'),KC)\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [Parameter('k2', 0), KR])\n #Rule('RIP1_rel', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod') + RIP1(bDD=None, bRHIM = None, state = 'unmod'), KC3)\n #bind(CompI(bDD=None, state = 'mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR])\n #Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod'),KC3)\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), KC)\n Rule('NFkB_expression', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), KE)\n # --------------RIP1 Ubiquitination---------------------------\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), KC2)\n # Rule('RIP1_deUb', RIP1(bDD=None, bRHIM = None, state='ub')>> RIP1(bDD=None, bRHIM = None, state='unmod'), KR)","def make_m2_crv(TSUGITE_list, SHIGUCHI_list):\n \"\"\"\n 1 Get information from TSUGITE_list and SHIGUCHI_list.\n \"\"\"\n # TSUGITE\n # Left----------------------------------------------------------------------\n # material2\n m2_left_list = TSUGITE_list[0]\n m2_left_upper = m2_left_list[0]\n m2_left_middle = m2_left_list[1]\n m2_left_lower = m2_left_list[2]\n\n # SHIGUCHI\n m2_KUMIKI_points1 = SHIGUCHI_list[4]\n m2_KUMIKI_points2 = SHIGUCHI_list[5]\n\n m2_KUMIKI_points1.reverse()\n\n m2_left_upper.extend(m2_KUMIKI_points1)\n m2_left_upper.append(m2_left_upper[0])\n m2_left_upper_crv = rs.AddPolyline(m2_left_upper)\n\n m2_left_middle.extend(m2_KUMIKI_points1)\n m2_left_middle.append(m2_left_middle[0])\n m2_left_middle_crv = rs.AddPolyline(m2_left_middle)\n\n m2_left_lower.extend(m2_KUMIKI_points1)\n m2_left_lower.append(m2_left_lower[0])\n m2_left_lower_crv = rs.AddPolyline(m2_left_lower)\n\n m2_left_crvs = [m2_left_upper_crv, m2_left_middle_crv, m2_left_lower_crv]\n\n # Right---------------------------------------------------------------------\n m2_right_list = TSUGITE_list[1]\n m2_right_upper = m2_right_list[0]\n m2_right_middle = m2_right_list[1]\n m2_right_lower = m2_right_list[2]\n\n # SHIGUCHI\n m2_KUMIKI_points1 = SHIGUCHI_list[0]\n m2_KUMIKI_points2 = SHIGUCHI_list[1]\n\n # Extend\n # material2\n m2_right_upper.reverse()\n m2_right_middle.reverse()\n m2_right_lower.reverse()\n\n # m2_KUMIKI_points1.reverse()\n\n m2_right_upper.extend(m2_KUMIKI_points1)\n m2_right_upper.append(m2_right_upper[0])\n m2_right_upper_crv = rs.AddPolyline(m2_right_upper)\n\n m2_right_middle.extend(m2_KUMIKI_points1)\n m2_right_middle.append(m2_right_middle[0])\n m2_right_middle_crv = rs.AddPolyline(m2_right_middle)\n\n m2_right_lower.extend(m2_KUMIKI_points1)\n m2_right_lower.append(m2_right_lower[0])\n m2_right_lower_crv = rs.AddPolyline(m2_right_lower)\n\n m2_right_crvs = [m2_right_upper_crv, m2_right_middle_crv, m2_right_lower_crv]\n\n return m2_left_crvs, m2_right_crvs","def plot_simplex(self, num_contours: int = 100, num_sub_div: int = 8,\n color_map: str = 'viridis', border: bool = True, ax: Axes = None) -> Axes:\n\n corners = array([[0, 0], [1, 0], [0.5, 0.75 ** 0.5]])\n triangle = Triangulation(corners[:, 0], corners[:, 1])\n mid_points = [\n (corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2\n for i in range(3)\n ]\n\n def to_barycentric(cartesian):\n \"\"\"\n Converts 2D Cartesian to barycentric coordinates.\n\n :param cartesian: A length-2 sequence containing the x and y value.\n \"\"\"\n s = [(corners[i] - mid_points[i]).dot(cartesian - mid_points[i]) / 0.75\n for i in range(3)]\n s_clipped = clip(a=s, a_min=0, a_max=1)\n return s_clipped / norm(s_clipped, ord=1)\n\n refiner = UniformTriRefiner(triangle)\n tri_mesh = refiner.refine_triangulation(subdiv=num_sub_div)\n f = [self._method(to_barycentric(xy))\n for xy in zip(tri_mesh.x, tri_mesh.y)]\n ax = ax or new_axes()\n ax.tricontourf(tri_mesh, f, num_contours, cmap=color_map)\n ax.set_aspect('equal')\n ax.set_xlim(0, 1)\n ax.set_ylim(0, 0.75 ** 0.5)\n ax.set_axis_off()\n if border:\n ax.triplot(triangle, linewidth=1)\n\n return ax","def update_CPPN(genotype, E1, E2, subp_1, subp_2, norm_in, num_x, num_y, canvas):\n\n\t# get values from fields, should all be comma separated\n\tinnov_nums = E1.get().split(\",\")\n\tnew_weights = E2.get().split(\",\")\n\n\t# get all values from the above lists\n\tfor innov_num, new_weight in zip(innov_nums, new_weights):\n\t\t# search through connections to find the correct\n\t\t# weight to change\n\t\tfor con in genotype.connections:\n\t\t\tif(con.getInnovationNumber() == int(innov_num)):\n\t\t\t\tcon.setWeight(float(new_weight))\n\n\t# clear both subplots so new graphs can be placed into the GUI\n\tsubp_1.clear()\n\tsubp_2.clear()\n\n\t# create graphs again and put graphs onto them\n\toutputs = []\n\tfor ins in norm_in:\n\t\toutputs.append(genotype.getOutput(ins)[0])\n\toutputs_np = np.array(outputs, copy=True)\n\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\n\n\tgraph_genotype_GUI(genotype, subp_2)\n\n\tcanvas.show()\n\tcanvas.get_tk_widget().pack()","def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def subdListComponentConversion(*args, border: bool=True, fromEdge: bool=True, fromFace:\n bool=True, fromUV: bool=True, fromVertex: bool=True, internal:\n bool=True, toEdge: bool=True, toFace: bool=True, toUV:\n bool=True, toVertex: bool=True, uvShell: bool=True,\n uvShellBorder: bool=True, **kwargs)->List[AnyStr]:\n pass","def TNFR1_to_SecondaryComplex():\n \n Parameter('TNFa_0' , 6000) # 6000 corresponds to 100ng/ml TNFa\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\n Parameter('CompI_0' , 0) # complexes per cell\n Parameter('NFkB_0' , 0) # molecules per cell\n alias_model_components()\n \n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'ub'), RIP1_0) # RIP1\n Initial(NFkB(bf=None), NFkB_0)\n \n # =========================================\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\n # -----------------------------------------\n # TNFa+ TNFR1 <-> TNFa:TNFR1\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\n \n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\n # [active]CompI:RIP1 >> [active]CompI + RIP1\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\n \n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\n \n # ------------------------------------------\n \n # -------------Complex I assembly----------------\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\n \n # --------------Complex I - RIP1 Modification-----------------\n # Complex I recruits RIP1\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\n \n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1e-3))\n\n # De-ubiquitination and degradation or release of RIP1 from complex I\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'), Parameter('k6',1))\n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\n \n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [1e-10,1])\n \n # Receptor recycle\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1))\n \n # --------------RIP1 Ubiquitination---------------------------\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))","def modelTheGraph(contourset):\r\n cntr_data = pd.DataFrame(columns=['level', 'node_x', 'node_y', 'path'])\r\n frames = list()\r\n start_time_model_graph = time.time()\r\n for level_index in range(len(contourset.collections)):\r\n path_counter = 0\r\n indices = np.arange(0, len(contourset.collections[level_index].get_paths()))\r\n array_list = np.take(contourset.collections[level_index].get_paths(), indices)\r\n for item in array_list.flat:\r\n node_x = item.vertices[:, 0].tolist()\r\n node_y = item.vertices[:, 1].tolist()\r\n frames.append([level_index, node_x, node_y, path_counter])\r\n path_counter += 1\r\n df = pd.DataFrame(frames, columns=['level', 'node_x', 'node_y', 'path'])\r\n df1 = df[['level', 'node_y', 'path']]\r\n df2 = df[['level', 'node_x', 'path']]\r\n lst_col = 'node_y'\r\n r1 = pd.DataFrame({\r\n col: np.repeat(df1[col].values, df1[lst_col].str.len())\r\n for col in df1.columns.drop(lst_col)}\r\n ).assign(**{lst_col: np.concatenate(df1[lst_col].values)})[df1.columns]\r\n lst_col2 = 'node_x'\r\n r2 = pd.DataFrame({\r\n col: np.repeat(df2[col].values, df2[lst_col2].str.len())\r\n for col in df2.columns.drop(lst_col2)}\r\n ).assign(**{lst_col2: np.concatenate(df2[lst_col2].values)})[df2.columns]\r\n cntr_data['level'] = r1['level'].tolist()\r\n cntr_data['node_x'] = r2['node_x'].tolist()\r\n cntr_data['node_y'] = r1['node_y'].tolist()\r\n cntr_data['path'] = r1['path'].tolist()\r\n print(\"For modeling the graph %s seconds\" % (time.time() - start_time_model_graph))\r\n\r\n return cntr_data","def addGrids(self, grid, label):\n self.grid = grid\n self.label = label\n self.H = len(grid)\n self.W = len(grid[0])\n self.visited = [[False] * self.W for _ in range(self.H)]\n self.clusters = [self._resort_size(r, c) for r, c in product(range(self.H), range(self.W)) if self.grid[r][c] != 0 and not self.visited[r][c]]\n self.subsets = []\n\n assert len(self.V) == len(self.neighbours.keys())\n\n if len(self.V) == 0 or not any(self.neighbours.values()):\n for addresstamp in self.clusters:\n footprint = Footprint(self.source, label, addresstamp)\n self.source += 1\n self.neighbours[footprint.uid] = []\n for v in self.V:\n if v.is_overlappedFootprint(footprint):\n self.E.append((v, footprint))\n self.neighbours.get(v.uid).append(footprint.uid)\n self.neighbours.get(footprint.uid).append(v.uid)\n self.resorts[v] = Resort([footprint])\n self.V.append(footprint)\n return\n\n connected_footprints = []\n for sub in self.recursive_findDenseZones(self.neighbours):\n self.subsets.append(sub)\n connected_footprints.extend(sub.getFootprintId())\n for addresstamp in self.clusters:\n footprint = Footprint(self.source, label, addresstamp)\n self.source += 1\n self.neighbours[footprint.uid] = []\n if len(addresstamp) == 1:\n self.V.append(footprint)\n continue\n new_sub = 1\n for sub in self.subsets:\n if sub.check_collision(footprint):\n new_sub = 0\n new_resort = 1\n for key, resort in sub.resorts.items():\n if resort.getLastFootprint().is_overlappedFootprint(footprint):\n new_resort = 0\n for n in resort.footprints:\n self.E.append((n, footprint))\n self.neighbours.get(n.uid).append(footprint.uid)\n self.neighbours.get(footprint.uid).append(n.uid)\n sub.resorts[key].addFootprint(footprint)\n self.resorts[key].addFootprint(footprint)\n break\n if new_resort:\n sub.resorts[footprint] = Resort([footprint])\n self.resorts[footprint] = Resort([footprint])\n break\n if new_sub:\n min_distance = sqrt(self.H**2 + self.W**2)\n closest = None\n for key, resort in self.resorts.items():\n if footprint.distance_from_resort(resort) < min_distance:\n min_distance = footprint.distance_from_resort(resort)\n closest = key\n assert closest\n for n in self.resorts[closest].footprints:\n self.E.append((n, footprint))\n self.neighbours.get(n.uid).append(footprint.uid)\n self.neighbours.get(footprint.uid).append(n.uid)\n self.V.append(footprint)","def pool_snps(parent1, parent2):","def discretize(self, obstacle_collection, drone_poses, goal_poses):\n cyl_c1_list = []\n cyl_c2_list = []\n cyl_r_list = []\n cyl_dir_list = []\n for obs in obstacle_collection.obstacles:\n if isinstance(obs, Cylinder):\n if obs.axis == 'x':\n cyl_dir_list.append(0)\n cyl_c1_list.append(obs.position.y + abs(MIN_Y))\n cyl_c2_list.append(obs.position.z)\n elif obs.axis == 'y':\n cyl_dir_list.append(1)\n cyl_c1_list.append(obs.position.x + abs(MIN_X))\n cyl_c2_list.append(obs.position.z)\n elif obs.axis == 'z':\n cyl_dir_list.append(2)\n cyl_c1_list.append(obs.position.x + abs(MIN_X))\n cyl_c2_list.append(obs.position.y + abs(MIN_Y))\n\n cyl_r_list.append(obs.radius)\n\n x_dim = MAX_X - MIN_X\n y_dim = MAX_Y - MIN_Y\n z_dim = MAX_Z\n mesh_nodes = mesh.generateMesh([x_dim, y_dim, z_dim],\n cyl_c1_list, cyl_c2_list, cyl_r_list, cyl_dir_list,\n self.__angle, self.__size, self.__approximation,\n self.__radiusedge, self.__ratio)\n for _ in mesh_nodes:\n self.__nodes.append(MeshNode())\n for n in mesh_nodes:\n self.__nodes[n.index].x = n.x - abs(MIN_X)\n self.__nodes[n.index].y = n.y - abs(MIN_Y)\n self.__nodes[n.index].z = n.z\n for edge in n.adj:\n self.__nodes[n.index].add_edge(self.__nodes[edge])\n\n def add_node(n):\n for node in self.__nodes:\n # Only short edges that are not on the ground or through obstacles\n if n.dist(node) < MESH_EDGE_DIST and (n.z > DRONE_HEIGHT or node.z > DRONE_HEIGHT):\n valid_edge = True\n for obs in obstacle_collection.obstacles:\n if isinstance(obs, Cylinder):\n cylinder_seg = Segment(Point(obs.position), Point(obs.position))\n if obs.axis == 'x':\n cylinder_seg.b += Point(1000, 0, 0)\n elif obs.axis == 'y':\n cylinder_seg.b += Point(0, 1000, 0)\n else:\n cylinder_seg.b += Point(0, 0, 1000)\n edge_seg = Segment(Point(n.position()), Point(node.position()))\n\n if cylinder_seg.min_distance(edge_seg) < obs.radius:\n valid_edge = False\n if valid_edge:\n n.add_edge(node)\n\n # Adding drone nodes\n drone_nodes = {}\n if drone_poses is not None:\n for drone_id in drone_poses:\n p = drone_poses[drone_id].position\n drone_nodes[drone_id] = MeshNode(p.x, p.y, p.z)\n add_node(drone_nodes[drone_id])\n\n # Adding goal nodes\n goal_nodes = {}\n if goal_poses is not None:\n for drone_id in goal_poses:\n p = goal_poses[drone_id]\n goal_nodes[drone_id] = MeshNode(p.x, p.y, p.z)\n add_node(goal_nodes[drone_id])\n\n return drone_nodes, goal_nodes","def _build_topology(self):\n\t\t# childSection.connect(parentSection, [parentX], [childEnd])\n\t\tfor i in range(self._axonNodes-1):\n\t\t\tself.node[i].connect(self.mysa[2*i],0,1)\n\t\t\tself.mysa[2*i].connect(self.flut[2*i],0,1)\n\t\t\tself.flut[2*i].connect(self.stin[6*i],0,1)\n\t\t\tself.stin[6*i].connect(self.stin[6*i+1],0,1)\n\t\t\tself.stin[6*i+1].connect(self.stin[6*i+2],0,1)\n\t\t\tself.stin[6*i+2].connect(self.stin[6*i+3],0,1)\n\t\t\tself.stin[6*i+3].connect(self.stin[6*i+4],0,1)\n\t\t\tself.stin[6*i+4].connect(self.stin[6*i+5],0,1)\n\t\t\tself.stin[6*i+5].connect(self.flut[2*i+1],0,1)\n\t\t\tself.flut[2*i+1].connect(self.mysa[2*i+1],0,1)\n\t\t\tself.mysa[2*i+1].connect(self.node[i+1],0,1)","def create_subbasin_graph():\n subbasin_to_downstream = pd.read_csv(module_dir + '/../data/simulations_shervan/test.rvh', sep='\\s+', skiprows=7, nrows=724, names=['subbasin', 'downstream_subbasin'], usecols=[1,2])\n subbasin_to_downstream['subbasin'] = subbasin_to_downstream['subbasin']\n subbasin_to_downstream['downstream_subbasin'] = 'sub' + subbasin_to_downstream['downstream_subbasin'].astype(str)\n subbasin_to_downstream['edge'] = 1\n\n for subbasin in subbasin_to_downstream['subbasin'].unique():\n is_sink = 1 if len(subbasin_to_downstream[(subbasin_to_downstream['subbasin'] == subbasin) & subbasin_to_downstream['edge'] == 1]) == 0 else 0\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': subbasin, 'downstream_subbasin': subbasin, 'edge': is_sink}, ignore_index=True)\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': 'sub-1', 'downstream_subbasin': 'sub-1', 'edge': 1}, ignore_index=True)\n \n adj = subbasin_to_downstream.pivot(index='subbasin', columns='downstream_subbasin', values='edge').fillna(0) \n adj = adj.sort_index(axis=0).sort_index(axis=1)\n \n G = nx.from_numpy_matrix(adj.values, parallel_edges=False, create_using=nx.DiGraph())\n label_mapping = dict(zip(range(len(adj.values)), adj.index))\n G = nx.relabel_nodes(G, label_mapping)\n \n return G","def labeled_subsimplex(\n label_func, init, disc\n): # pylint: disable=too-many-locals,too-many-statements\n init = np.asarray(init, float)\n dim = init.size\n # Base vertex of the subsimplex currently being used\n dinit = _discretize_mixture(init, disc)\n base = np.append(dinit, 0)\n base[0] += 1\n # permutation array of [1,dim] where v0 = base,\n # v{i+1} = [..., vi_{perms[i] - 1} - 1, vi_{perms[i]} + 1, ...]\n perms = np.arange(1, dim + 1)\n # Array of labels for each vertex\n labels = np.arange(dim + 1)\n labels[dim] = label_func(dinit / disc)\n # Vertex used to label initial vertices (vertex[-1] == 0)\n label_vertex = base[:-1].copy()\n # Last index moved\n index = dim\n # Most recent created index, should be set to\n new_vertex = None\n\n while labels[index] < dim:\n # Find duplicate index. this is O(dim) but not a bottleneck\n (dup_labels,) = np.nonzero(labels == labels[index])\n (index,) = dup_labels[dup_labels != index]\n\n # Flip simplex over at index\n if index == 0:\n base[perms[0]] += 1\n base[perms[0] - 1] -= 1\n perms = np.roll(perms, -1)\n labels = np.roll(labels, -1)\n index = dim\n\n elif index == dim:\n base[perms[-1] - 1] += 1\n base[perms[-1]] -= 1\n perms = np.roll(perms, 1)\n labels = np.roll(labels, 1)\n index = 0\n\n else: # 0 < index < dim\n perms[index - 1], perms[index] = perms[index], perms[index - 1]\n\n # Compute actual value of flipped vertex\n new_vertex = base.copy()\n new_vertex[perms[:index]] += 1\n new_vertex[perms[:index] - 1] -= 1\n\n utils.check(\n np.all(new_vertex >= 0) and new_vertex.sum() == disc + 1,\n \"vertex rotation failed, check labeling function\",\n )\n\n # Update label of new vertex\n if new_vertex[-1] == 2:\n labels[index] = dim\n elif new_vertex[-1] == 0:\n labels[index] = np.argmax(new_vertex[:-1] - label_vertex)\n else: # == 1\n labels[index] = label_func(new_vertex[:-1] / disc)\n utils.check(\n 0 <= labels[index] < dim and new_vertex[labels[index]],\n \"labeling function was not proper (see help)\",\n )\n\n # Average out all vertices in simplex we care about\n current = base\n if index == 0: # pragma: no cover\n count = 0\n mean = np.zeros(dim)\n else: # pragma: no cover\n count = 1\n mean = current.astype(float)\n for i, j in enumerate(perms, 1):\n current[j] += 1\n current[j - 1] -= 1\n if i != index:\n count += 1\n mean += (current - mean) / count\n return mean[:-1] / disc","def CD95_to_SecondaryComplex():\n\n Parameter('Fas_0' , 6000) # 6000 corresponds to 100ng/ml Fas (J Immunol 2005)\n Parameter('CD95_0' , 4817) # 4817receptors per cell (J Immunol 2005)\n Parameter('FADD_0' , 8030) # 8300 molecules per cell (J Immunol 2005)\n Parameter('flip_L_0', 390220) # 39022 molecules per cell (J Immunol 2005)\n Parameter('flip_S_0', 390220) # molecules per cell assummed both isoforms w/conc.\n Parameter('proC8_0' , 16057) # procaspase 8 molecules per cell 16057 (J Immunol 2005)\n Parameter('C8_0' , 0) # active caspase 8 dimers per cell.\n Parameter('Bar_0' , 1.0e3) # Bar molecules per cell. (Hela Cells)\n alias_model_components()\n \n Initial(Fas(blig=None), Fas_0) #Fas Ligand\n Initial(CD95(blig=None, bDD=None), CD95_0) #Fas Receptor (CD95)\n Initial(FADD(bDD=None, bDED1=None, bDED2=None), FADD_0) #FADD\n Initial(flip_L(bDED=None), flip_L_0) #c-Flip[L]\n Initial(flip_S(bDED=None), flip_S_0) #c-Flip[S]\n Initial(proC8(bDED=None), proC8_0) #procaspase 8\n Initial(C8(bf=None, state = 'A'), C8_0) #caspase 8\n Initial(Bar(bC8=None), Bar_0) #bifunctional apoptosis regulator\n \n # =========================================\n # CD95 ligation and formation of Secondary Complex rules\n # -----------------------------------------\n # Fas + CD95 <-> Fas:CD95\n # Fas:CD95 + FADD <-> Fas:CD95:FADD\n # Fas:CD95:FADD + proC8 <-> Fas:CD95:FADD:proC8\n \n # Fas:CD95:FADD:proC8 + proC8 <-> Fas:CD95:FADD:proC8:proC8 -> Fas:CD95:FADD + C8\n # Fas:CD95:FADD:proC8 + flip_L <-> Fas:CD95:FADD:proC8:flip_L\n # Fas:CD95:FADD:proC8 + flip_S <-> Fas:CD95:FADD:proC8:flip_S\n \n # Fas:CD95:FADD:proC8:flip_L <-> Fas:CD95 + FADD:proC8:flip_L\n # Fas:CD95:FADD:proC8:flip_S <-> Fas:CD95 + FADD:proC8:flip_S\n # ------------------------------------------\n \n # ==========================================\n # Regulation (downstream of CD95) of Caspase 8 activity\n # ------------------------------------------\n # C8 + BAR <-> C8:BAR\n # C8 + TRAF2 >> TRAF2\n \n # -------------DISC assembly----------------\n alias_model_components()\n bind(Fas(blig=None), 'blig', CD95(blig = None, bDD = None), 'blig', [1.89e-7, 1e-4])\n bind(CD95(blig = ANY, bDD = None), 'bDD', FADD(bDD = None, bDED1 =None, bDED2 = None), 'bDD', [1.04e-6, 0.2]) # (J Immunol 2005)\n bind(FADD(bDD = ANY, bDED1 = None, bDED2 = None),'bDED1', proC8(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\n \n # For simplicity allow proC8 to bind FADD before any c-Flip do.\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', flip_L(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', flip_S(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\n \n \n # procaspase 8 dimerization and activation\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', proC8(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\n \n Rule('C8_activation', FADD(bDED1 = ANY, bDED2 = ANY)%proC8(bDED=ANY)%proC8(bDED = ANY) >> FADD(bDED1 = None, bDED2 = None) + C8(bf = None, state = 'A'), Parameter('k1', 0.3)) # (J Immunol 2005)\n\n # caspase 8 inhibition by BAR\n bind(Bar(bC8 = None), 'bC8', C8(bf = None, state = 'A'), 'bf', [1e-6, 1e-3])\n \n # release of secondary complex from the DISC\n bind(FADD(bDD = None, bDED2 = ANY, bDED1 = ANY), 'bDD', CD95(blig = ANY, bDD=None), 'bDD', [1e-10, 1e-3])","def test_scipy_graph_to_cugraph_graph():\n dpr = mg.resolver\n scipy_sparse_matrix = ss.csr_matrix(\n np.array(\n [\n [0, 1, 1, 0, 0],\n [0, 0, 1, 0, 0],\n [1, 0, 0, 0, 0],\n [0, 0, 1, 0, 0],\n [0, 0, 0, 0, 0],\n ],\n dtype=bool,\n )\n )\n x = dpr.wrappers.Graph.ScipyGraph(scipy_sparse_matrix, np.arange(5))\n\n sources = [0, 0, 1, 2, 3]\n destinations = [1, 2, 2, 0, 2]\n cdf = cudf.DataFrame({\"Source\": sources, \"Destination\": destinations})\n g = cugraph.DiGraph()\n g.from_cudf_edgelist(cdf, source=\"Source\", destination=\"Destination\")\n intermediate = dpr.wrappers.Graph.CuGraph(g, cudf.Series(range(5)))\n\n y = dpr.translate(x, CuGraph)\n dpr.assert_equal(y, intermediate)\n assert len(dpr.plan.translate(x, CuGraph)) == 1","def new_resolve_unique_contigs(scaffold_list, unique_contigs_list):\n \n contig_location = {}\n s_l = copy.deepcopy(scaffold_list)\n \n #first deal with any scaffolds that have more than one copy of a unique contig\n to_remove = []\n for scaf in s_l: \n for contig in unique_contigs_list:\n if scaf.count(contig) > 1:\n scaffold_parts = split_siamese(contig, scaf)\n to_remove.append(scaf)\n s_l.extend(scaffold_parts)\n break \n for scaf in to_remove:\n s_l.remove(scaf) \n\n\n for contig in unique_contigs_list:\n #if contig[:4] == \"five\": \n finds = find_unique_contig(contig, s_l)\n\n if len(finds) > 1:\n contig_location[contig] = finds\n\n sc_ov = {}\n sc_ov = make_scaff_overlap_dict(contig_location)\n\n #This is the new bit that takes just the first conflicted contig \n first_k = list(sc_ov.items())[0:1]\n first_sc_ov = dict(first_k)\n new_scaffold_list = combine_overlapping_contigs(first_sc_ov, s_l)\n\n #Split off unique scaffolds attached by their 3' ends to multiple scaffolds\n \n for contig in contig_location:\n if contig[:5] == \"three\":\n for scaf in contig_location[contig]:\n conflict = False\n if scaf.index(contig) == 1:\n conflict = True\n new_left_scaf = scaf[:3]\n new_right_scaf = scaf[3:]\n if scaf.index(contig) == len(scaf) - 2:\n conflict = True\n new_left_scaf = scaf[:-3]\n new_right_scaf = scaf[-3:]\n if conflict:\n new_left_scaf.append(\"link_conflict6\")\n new_right_scaf.insert(0,\"link_conflict6\")\n if len(new_left_scaf) >= 4: \n new_scaffold_list.append(new_left_scaf)\n if len(new_right_scaf) >= 4:\n new_scaffold_list.append(new_right_scaf)\n if scaf in new_scaffold_list:\n new_scaffold_list.remove(scaf)\n\n return new_scaffold_list","def getContactRoute(ss_def, contacts_def):\n control = 0 # to control the while loop until the length of all SSEs\n i = 0 # i, j are the indices of the SSE array\n j = 0\n map_route = []\n while control != len(ss_def) - 1:\n\n # [20, 64, 28, 24, 56, 28, 24, 40, 24, 24, 88] 11\n if control == 0:\n control += 1\n i, j = getTopRank(ss_def, contacts_def) # get the largest intra contact smotif\n map_route.append([i, j, 'start'])\n else:\n if i == 0:\n ti = j\n j += 1\n control += 1\n direction = 'right'\n map_route.append([ti, j, direction])\n elif j == len(ss_def) - 1: # -1 to deal with array index\n tj = i\n i -= 1\n control += 1\n direction = 'left'\n map_route.append([i, tj, direction])\n else:\n ti, tj, new_direction = nextSS(map_route, ss_def, contacts_def)\n control += 1\n map_route.append([ti, tj, new_direction])\n return map_route","def _build_graph_general(self): \n\n #Find a canonical coloring scheme\n #Each node has a color that is determined by the non-mapped aspects\n nodecolors=set()\n for nl in self.net.iter_node_layers():\n nodecolors.add(self._slice_node_layer_not_allowed(nl))\n nodecolors_sorted=sorted(list(nodecolors))\n del nodecolors\n self._assert_full_order(nodecolors_sorted)\n self.colormap=dict( ((color,colorid) for colorid,color in enumerate(nodecolors_sorted) ))\n\n #each aux node has a color that is determined by the aspect\n self.auxcolormap=dict( ((auxcolor, auxcolorid+len(self.colormap)) for auxcolorid,auxcolor in enumerate(sorted(self.asp)) ) )\n\n\n #Add the underlying network\n #node-layers:\n for nl in self.net.iter_node_layers():\n nlid=self._get_node_id(nl)\n color=self._slice_node_layer_not_allowed(nl)\n colorid=self.colormap[color]\n self.add_node(nlid,colorid)\n\n #edges between node-layers:\n for nl1 in self.net.iter_node_layers():\n for nl2 in self.net[nl1]:\n nl1id=self._get_node_id(nl1)\n nl2id=self._get_node_id(nl2)\n self.add_link(nl1id,nl2id)\n\n\n #Add the auxiliary nodes and edges\n #add the aux nodes\n for a in self.asp:\n for elayer in self.net.slices[a]:\n auxid=self._get_auxnode_id( (a,elayer) )\n auxcolorid=self.auxcolormap[a]\n self.add_node(auxid,auxcolorid)\n \n #add the aux edges\n for nl in self.net.iter_node_layers():\n for a in self.asp:\n nlid=self._get_node_id(nl)\n auxid=self._get_auxnode_id( (a,nl[a]) )\n self.add_link(nlid,auxid)","def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n hspc=(max_x-min_x)/x_divisions\n vspc=(max_y-min_y)/y_divisions\n\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n pshp.set_property('position',\"%.1f\" % hval)\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n pshp.set_property('position',\"%.1f\" % vval)\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True) \n\n return layer","def create_map_coloring_csp():\n csp = CSP()\n states = [ 'WA', 'NT', 'Q', 'NSW', 'V', 'SA', 'T' ]\n edges = { 'SA': [ 'WA', 'NT', 'Q', 'NSW', 'V' ], 'NT': [ 'WA', 'Q' ], 'NSW': [ 'Q', 'V' ] }\n colors = [ 'red', 'green', 'blue' ]\n for state in states:\n csp.add_variable(state, colors)\n for state, other_states in edges.items():\n for other_state in other_states:\n csp.add_constraint_one_way(state, other_state, lambda i, j: i != j)\n csp.add_constraint_one_way(other_state, state, lambda i, j: i != j)\n return csp","def make_sub_data_train(data, config):\n sub_input_sequence = []\n sub_label_sequence = []\n\n\tfor scale in range(2,5):\t \n\n\t for i in range(len(data)):\n\n\t\t#input_, label_, = preprocess(data[i], config.scale) # do bicbuic only one scale\n\t\tinput_, label_, = preprocess(data[i], scale) # do bicbuic turn around all scale\n\t\n\t\tif len(input_.shape) == 3: # is color\n\t\t h, w, c = input_.shape\n\t\telse:\n\t\t h, w = input_.shape # is grayscale\n\t\n\t\t#checkimage(input_)\t\t\n\n\t\tnx, ny = 0, 0\n\t\tfor x in range(0, h - config.image_size + 1, config.stride):\n\t\t nx += 1; ny = 0\n\t\t for y in range(0, w - config.image_size + 1, config.stride):\n\t\t\tny += 1\n\n\t\t\tsub_input = input_[x: x + config.image_size, y: y + config.image_size] # 41 * 41\n\t\t\tsub_label = label_[x: x + config.label_size, y: y + config.label_size] # 41 * 41\n\n\n\t\t\t# Reshape the subinput and sublabel\n\t\t\tsub_input = sub_input.reshape([config.image_size, config.image_size, config.c_dim])\n\t\t\tsub_label = sub_label.reshape([config.label_size, config.label_size, config.c_dim])\n\n\t\t\t# Normialize\n\t\t\tsub_input = sub_input / 255.0\n\t\t\tsub_label = sub_label / 255.0\n\t\t\t\n\t\t\t#cv2.imshow(\"im1\",sub_input)\n\t\t\t#cv2.imshow(\"im2\",sub_label)\n\t\t\t#cv2.imshow(\"residual\",sub_input - sub_label)\n\t\t\t#cv2.waitKey(0)\n\n\t\t\t# Rotate 90,180,270\n\t\t\tfor angle in range(0,360,90):\t\n\t\t\t\tsub_input = rotate(sub_input,angle)\t\n\t\t\t\tsub_label = rotate(sub_label,angle)\t\n\t\t\n\t\t\t\t# Add to sequence\n\t\t\t\tsub_input_sequence.append(sub_input)\n\t\t\t\tsub_label_sequence.append(sub_label)\n\n\t\t\t\tcv2.imshow(\"im1\",sub_input)\n\t\t\t\tcv2.imshow(\"im2\",sub_label)\n\t\t\t\tcv2.imshow(\"residual\",sub_input - sub_label)\n\t\t\t\tcv2.waitKey(1)\n\t\t\t\t\n\n \n # NOTE: The nx, ny can be ignore in train\n return sub_input_sequence, sub_label_sequence, nx, ny","def AddContour(self,polyData):\n #research\n # called by drawIsoSurfaces\n profprint()\n # print polyData\n scene = slicer.mrmlScene\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\n #??? i suppose here is a bug:\n print 'modelNodes: ',modelNodes\n print 'self.ContourNode: ', self.contourNode\n #!!! self.contourNode is None\n \n #bugfix>>>>\n modelNode = slicer.vtkMRMLModelNode()\n self.contourNode = modelNode.GetID()\n # print 'self.ContourNode: ', self.contourNode\n #<<<bugfix\n \n # contourNode = slicer.util.getNode(self.contourNode)\n # print 'contourNode: ',contourNode\n if self.contourNode != None:\n slicer.mrmlScene.RemoveNode(self.contourNode.GetStorageNode())\n self.contourNode.RemoveAllDisplayNodeIDs()\n slicer.mrmlScene.RemoveNode(self.contourNode)\n \n #modelNode = slicer.vtkMRMLModelNode()\n modelNode.SetScene(scene)\n modelNode.SetAndObservePolyData(polyData)\n # display node\n displayNode = slicer.vtkMRMLModelDisplayNode()\n \n modelNode.SetName('Contours')\n \n scene.AddNode(displayNode)\n scene.AddNode(modelNode)\n \n displayNode.SetVisibility(1)\n displayNode.SetOpacity(0.06)\n displayNode.SetSliceIntersectionVisibility(1)\n displayNode.SetScalarVisibility(1)\n displayNode.SetActiveScalarName('ImageScalars') \n displayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileHotToColdRainbow2.txt')\n displayNode.SetScalarRange(10,40)\n displayNode.SetBackfaceCulling(0)\n displayNode.SetScene(scene)\n scene.AddNode(displayNode)\n modelNode.SetAndObserveDisplayNodeID(displayNode.GetID())\n # add to scene\n displayNode.SetInputPolyData(modelNode.GetPolyData())\n scene.AddNode(modelNode)\n\n #self.contourNode = modelNode.GetID()\n\n qt.QApplication.processEvents()","def CD95_to_SecondaryComplex():\n \n Parameter('Fas_0' , 000) # 3000 corresponds to 50ng/ml Fas\n Parameter('CD95_0' , 200) # 200 receptors per cell\n Parameter('FADD_0' , 1.0e3) # molecules per cell (arbitrarily assigned)1000\n Parameter('flip_L_0', 1.0e4) # molecules per cell\n Parameter('flip_S_0', 1.0e4) # molecules per cell\n Parameter('proC8_0' , 2.0e4) # procaspase 8 molecules per cell 20000\n Parameter('C8_0' , 0) # active caspase 8 dimers per cell.\n Parameter('Bar_0' , 1.0e3) # Bar molecules per cell.\n \n Initial(Fas(blig=None), Fas_0) #Fas Ligand\n Initial(CD95(blig=None, bDD=None), CD95_0) #Fas Receptor (CD95)\n Initial(FADD(bDD=None, bDED1=None, bDED2=None), FADD_0) #FADD\n Initial(flip_L(bDED=None), flip_L_0) #c-Flip[L]\n Initial(flip_S(bDED=None), flip_S_0) #c-Flip[S]\n Initial(proC8(bDED=None), proC8_0) #procaspase 8\n Initial(C8(bC8=None), C8_0) #caspase 8\n Initial(Bar(bC8=None), Bar_0) #bifunctional apoptosis regulator","def nodeSeparate(self,compInfo, ifSub, subname, subcktName,numNodesSub):\n node = []\n nodeTemp = []\n nodeDic = {}\n pinInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\n pinProtectedInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\n protectedNode = []\n print \"CompInfo coming to nodeSeparate function: compInfo\",compInfo\n \n #Removing '[' and ']' from compInfo for Digital node\n for i in range(0,len(compInfo),1):\n compInfo[i] = compInfo[i].replace(\"[\",\"\").replace(\"]\",\"\")\n \n \n for eachline in compInfo:\n words = eachline.split()\n if eachline[0] in ['m', 'e', 'g', 't','M','E','G','T']:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n nodeTemp.append(words[3])\n nodeTemp.append(words[4])\n elif eachline[0] in ['q', 'j','J','Q']:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n nodeTemp.append(words[3])\n elif eachline[0]=='x' or eachline[0]=='X':\n templine = eachline.split()\n for i in range(0,len(templine),1):\n if templine[i] in subcktName:\n point = i \n nodeTemp.extend(words[1:point])\n else:\n nodeTemp.append(words[1])\n nodeTemp.append(words[2])\n for i in nodeTemp:\n if i not in node:\n node.append(i)\n \n for i in range(0, len(node),1):\n nodeDic[node[i]] = 'n' + node[i]\n if ifSub == '0':\n if i != len(node)-1:\n pinInit = pinInit + nodeDic[node[i]] + ', '\n else:\n pinInit = pinInit + nodeDic[node[i]]\n else:\n nonprotectedNode = self.getSubInterface(subname, numNodesSub) \n if node[i] in nonprotectedNode:\n continue\n else:\n protectedNode.append(node[i])\n if ifSub == '1':\n if len(nonprotectedNode) > 0:\n for i in range(0, len(nonprotectedNode),1):\n if i != len(nonprotectedNode)-1:\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]] + ','\n else:\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]]\n if len(protectedNode) > 0:\n for i in range(0, len(protectedNode),1):\n if i != len(protectedNode)-1: \n pinInit = pinInit + nodeDic[protectedNode[i]] + ','\n else:\n pinInit = pinInit + nodeDic[protectedNode[i]]\n pinInit = pinInit + ';'\n pinProtectedInit = pinProtectedInit + ';'\n print \"Node---->\",node\n print \"nodeDic----->\",nodeDic\n print \"PinInit----->\",pinInit\n print \"pinProtectedinit--->\",pinProtectedInit\n return node, nodeDic, pinInit, pinProtectedInit","def _mn_contour_ ( self , npoint , par1 , par2 , nsigma = 1 ) :\n if npoint < 4 : raise ValueError ( 'contour: npoint (%s) must be >= 4' % npoint )\n if not par1 in self : raise ValueError ( 'contour: par1(%s) is not in Minuit' % par1 )\n if not par2 in self : raise ValueError ( 'contour: par2(%s) is not in Minuit' % par2 )\n if par1 == par2 : raise ValueError ( 'contour: par1 == par2(%s) ' % par2 )\n #\n ## save old error defintion\n #\n old_err_def = self.GetErrorDef()\n #\n ## set new error definition\n #\n self.SetErrorDef ( nsigma * nsigma )\n \n graph = self.Contour ( npoint , par1 , par2 )\n\n #\n ## restore old error defininion\n #\n status = self.GetStatus()\n self.SetErrorDef ( old_err_def ) \n #\n if graph and 0 == status : return graph\n logger.error ( 'TMinuit::Contour: status %i' % status ) \n return graph","def __init__(self,hdu_list,i_bin,fsk,mask_binary,masked_fraction,contaminants=None) :\n #Read numbers map\n self.fsk,nmap=read_flat_map(None,hdu=hdu_list[2*i_bin])\n compare_infos(fsk,self.fsk)\n\n #Read N(z)\n self.nz_data=hdu_list[2*i_bin+1].data.copy()\n\n #Make sure other maps are compatible\n if not self.fsk.is_map_compatible(mask_binary) :\n raise ValueError(\"Mask size is incompatible\")\n if not self.fsk.is_map_compatible(masked_fraction) :\n raise ValueError(\"Mask size is incompatible\")\n if contaminants is not None :\n for ic,c in enumerate(contaminants) :\n if not self.fsk.is_map_compatible(c) :\n raise ValueError(\"%d-th contaminant template is incompatible\"%ic)\n \n #Translate into delta map\n self.masked_fraction=masked_fraction\n self.weight=masked_fraction*mask_binary\n goodpix=np.where(mask_binary>0.1)[0]\n self.goodpix=goodpix\n self.mask_binary=mask_binary\n self.Ngal = np.sum(nmap*mask_binary)\n ndens=np.sum(nmap*mask_binary)/np.sum(self.weight)\n self.ndens_perad=ndens/(np.radians(self.fsk.dx)*np.radians(self.fsk.dy))\n self.delta=np.zeros_like(self.weight)\n self.delta[goodpix]=nmap[goodpix]/(ndens*masked_fraction[goodpix])-1\n\n #Reshape contaminants\n conts=None\n if contaminants is not None :\n conts=[[c.reshape([self.fsk.ny,self.fsk.nx])] for c in contaminants]\n\n #Form NaMaster field\n self.field=nmt.NmtFieldFlat(np.radians(self.fsk.lx),np.radians(self.fsk.ly),\n self.weight.reshape([self.fsk.ny,self.fsk.nx]),\n [self.delta.reshape([self.fsk.ny,self.fsk.nx])],\n templates=conts)","def AddContour(self, polyData):\r\n # research\r\n # called by drawIsoSurfaces\r\n profprint()\r\n # print polyData\r\n scene = slicer.mrmlScene\r\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\r\n # ??? i suppose here is a bug:\r\n print 'modelNodes: ', modelNodes\r\n print 'self.ContourNode: ', self.contourNode\r\n #!!! self.contourNode is None\r\n\r\n # bugfix>>>>\r\n modelNode = slicer.vtkMRMLModelNode()\r\n self.contourNode = modelNode.GetID()\r\n # print 'self.ContourNode: ', self.contourNode\r\n # <<<bugfix\r\n\r\n # contourNode = slicer.util.getNode(self.contourNode)\r\n # print 'contourNode: ',contourNode\r\n if self.contourNode != None:\r\n slicer.mrmlScene.RemoveNode(self.contourNode.GetStorageNode())\r\n self.contourNode.RemoveAllDisplayNodeIDs()\r\n slicer.mrmlScene.RemoveNode(self.contourNode)\r\n\r\n # modelNode = slicer.vtkMRMLModelNode()\r\n modelNode.SetScene(scene)\r\n modelNode.SetAndObservePolyData(polyData)\r\n # display node\r\n displayNode = slicer.vtkMRMLModelDisplayNode()\r\n\r\n modelNode.SetName('Contours')\r\n\r\n scene.AddNode(displayNode)\r\n scene.AddNode(modelNode)\r\n\r\n displayNode.SetVisibility(1)\r\n displayNode.SetOpacity(0.06)\r\n displayNode.SetSliceIntersectionVisibility(1)\r\n displayNode.SetScalarVisibility(1)\r\n displayNode.SetActiveScalarName('ImageScalars')\r\n displayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileHotToColdRainbow2.txt')\r\n displayNode.SetScalarRange(10, 40)\r\n displayNode.SetBackfaceCulling(0)\r\n displayNode.SetScene(scene)\r\n scene.AddNode(displayNode)\r\n modelNode.SetAndObserveDisplayNodeID(displayNode.GetID())\r\n # add to scene\r\n displayNode.SetInputPolyData(modelNode.GetPolyData())\r\n scene.AddNode(modelNode)\r\n\r\n # self.contourNode = modelNode.GetID()\r\n\r\n qt.QApplication.processEvents()","def _decomposition_with_many_workers(control_wires, target_wire, work_wires):\n num_work_wires_needed = len(control_wires) - 2\n work_wires = work_wires[:num_work_wires_needed]\n\n work_wires_reversed = list(reversed(work_wires))\n control_wires_reversed = list(reversed(control_wires))\n\n gates = []\n\n for i in range(len(work_wires)):\n ctrl1 = control_wires_reversed[i]\n ctrl2 = work_wires_reversed[i]\n t = target_wire if i == 0 else work_wires_reversed[i - 1]\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\n\n gates.append(qml.Toffoli(wires=[*control_wires[:2], work_wires[0]]))\n\n for i in reversed(range(len(work_wires))):\n ctrl1 = control_wires_reversed[i]\n ctrl2 = work_wires_reversed[i]\n t = target_wire if i == 0 else work_wires_reversed[i - 1]\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\n\n for i in range(len(work_wires) - 1):\n ctrl1 = control_wires_reversed[i + 1]\n ctrl2 = work_wires_reversed[i + 1]\n t = work_wires_reversed[i]\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\n\n gates.append(qml.Toffoli(wires=[*control_wires[:2], work_wires[0]]))\n\n for i in reversed(range(len(work_wires) - 1)):\n ctrl1 = control_wires_reversed[i + 1]\n ctrl2 = work_wires_reversed[i + 1]\n t = work_wires_reversed[i]\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\n\n return gates","def create_network(num_subs):\n\n # Need one host for each subscriber, one for a publisher, and one for a broker\n n_hosts = num_subs + 2\n\n topo = SingleSwitchTopo(n=n_hosts)\n\n return Mininet(topo=topo, controller=OVSController)","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def getCV(file1, type, imgOri,iteration):\n del s_arrays[:]\n del shapesContours[:]\n\n if type == 'shapes':\n spContours = getContours(imgOri,iteration)\n file1.write(str(len(spContours)) + '\\n')\n print(len(spContours))\n spContours = clean_Con(spContours)\n file1.write(str(len(spContours)) + '\\n')\n print(len(spContours))\n cv2.drawContours(imgOri, spContours, -1, (0, 255, 128), 5)\n # del s_arrays[:]\n # for each shape\n for cons in spContours:\n sampleComVector = []\n x, y, w, h = cv2.boundingRect(cons)\n cv2.rectangle(imgOri, (x, y), (x + w, y + h), (100, 100, 100), 1)\n\n # move the points to center\n for point in cons:\n sampleComVector.append(complex(point[0][0] - x, (point[0][1] - y)))\n # sampleComVectors store CV of all testees contours\n s_arrays.append(sampleComVector)\n # sampleContours store all testees contours, same order with sampleComVectors\n shapesContours.append(cons)\n\n elif type == 'temp':\n # Automatically find templete contour\n templetTrue = imgOri\n tpContour = getContours(templetTrue,iteration)\n for contour in tpContour:\n x, y, w, h = cv2.boundingRect(contour)\n #\n for point in contour:\n # -x and -y are to make left and upper boundry start from 0\n t_array.append(complex(point[0][0] - x, (point[0][1] - y)))","def _update_attributes(self,circuit_graph,name,lib_name,lib_graph, Gsub):\n #PnR can route primitive power but not subckt power\n if lib_name in self.all_lef:\n pg = []\n else:\n pg = self.pg\n G1 = circuit_graph\n num = len([key for key in Gsub\n if 'net' not in G1.nodes[key][\"inst_type\"]])\n # Define ports for subblock\n matched_ports = {}\n ports_weight = {}\n G2 = lib_graph.copy()\n for g1_n, g2_n in Gsub.items():\n if 'net' in G2.nodes[g2_n][\"inst_type\"]:\n if 'external' in G2.nodes[g2_n][\"net_type\"]:\n if num > 1 and g1_n in pg:\n # remove power connections\n G2=nx.relabel_nodes(G2,{g2_n:g1_n},copy=False)\n else:\n matched_ports[g2_n] = g1_n\n ports_weight[g2_n] = []\n for nbr in list(G2.neighbors(g2_n)):\n ports_weight[g2_n].append(G2.get_edge_data(g2_n, nbr)['weight'])\n else:\n G2.nodes[g2_n]['values'] = G1.nodes[g1_n]['values']\n G2.nodes[g2_n]['real_inst_type'] = G1.nodes[g1_n]['real_inst_type']\n return matched_ports,ports_weight,G2","def subdevice(self, center, leads, leads2):\n\n center = self.__s2m__(center,0)\n\n center_t = self.subsystem(center,center).simplified()\n leads_t = []\n connections_t = []\n\n for l_i,(l,l2) in enumerate(zip(leads,leads2)):\n\n l = self.__s2m__(l,0)\n l2 = self.__s2m__(l2,0)\n\n # Lead\n l_t = self.subsystem(l,l).simplified()\n\n # Lead replica\n l2_t = self.subsystem(l2,l2).simplified()\n\n # Hoppings\n l_b = self.subsystem(l,l2).simplified()\n l_f = self.subsystem(l2,l).simplified()\n\n # Check if the lead belongs to the scattering region\n if not set(l).issubset(set(center)):\n raise ValueError(\"Lead {:d} does not completely belong to the central region\".format(l_i))\n\n # Check absence of overlap\n center_without_lead = set(center) - set(l)\n if self.subsystem(center_without_lead,l2).absmax() != 0 or self.subsystem(l2,center_without_lead).absmax() != 0:\n raise ValueError(\"Lead replica {:d} interacts with the central region\".format(l_i))\n\n leads_t.append(TightBinding({\n 0: l_t,\n 1: l_f,\n -1: l_b,\n }))\n\n c = numpy.eye(self.shape[0], dtype = numpy.int)\n connections_t.append(c[numpy.ix_(l, center)])\n\n return MultiterminalDevice(center_t, leads_t, connections_t)","def simplify(self):\n \n added_clumps = []\n staying_tunnels = []\n removed_clumps = set()\n \n for tunnel in self.tunnels:\n tunnel_end_distance = self.get_distance(tunnel.start, tunnel.end)\n if tunnel_end_distance - tunnel.start.distance_from_wall < 0 or \\\n tunnel_end_distance - tunnel.end.distance_from_wall < 0:\n removed_clumps.add(tunnel.start.node)\n removed_clumps.add(tunnel.end.node)\n new_node = tunnel.merge_endpoints()\n added_clumps.append(new_node)\n else:\n staying_tunnels.append(tunnel)\n #print removed_clumps\n \n new_clumps = []\n \n for clump in list(self.clumps) + added_clumps:\n if clump not in removed_clumps:\n new_clumps.append(clump)\n else:\n removed_clumps.remove(clump)\n\n if removed_clumps:\n raise Exception(\"Some removed clumps couldn't be found in the main set and I'm scared\")\n \n self.clumps = new_clumps\n self.tunnels = staying_tunnels","def dfsCC(G,vis,u):\r\n\tvis[u] = True\r\n\tfor v in G[u]:\r\n\t\tif vis[v] == False:\r\n\t\t\tdfsCC(G,vis,v)\r\n\treturn","def __init__(self, nodes, infimum=1e-8):\n self.nodes, (self.nn, self.dim) = nodes, nodes.shape\n\n # generate anisotropic simplices\n delaunay = Delaunay(self.nodes)\n simplices = delaunay.simplices\n volumes = np.linalg.det(self.nodes[simplices[:, :-1]] - self.nodes[simplices[:, [-1]]])\n valid_indices = [i for i, v in enumerate(volumes) if np.abs(v) > infimum]\n simplices = simplices[valid_indices, :]\n volumes = volumes[valid_indices]\n\n # generate mask of convex hull\n mask = np.expand_dims(self.nodes[delaunay.convex_hull], axis=1) - np.expand_dims(self.nodes, axis=(0, 2))\n self.mask = np.min(np.abs(np.linalg.det(mask)), axis=0) == 0\n\n # generate isotropic simplices\n def reverse(spx): return spx[[0, 2, 1] + list(range(3, spx.__len__()))]\n self.simplices = np.array([spx if flag else reverse(spx) for spx, flag in zip(simplices, volumes > 0)])\n self.nt = self.simplices.shape[0]\n\n # generate isotropic surfaces of simplices.\n self.surfaces = np.stack([np.roll(self.simplices, -k, 1) if k * self.dim % 2 else reverse(np.roll(self.simplices, -k, 1).T).T for k in range(self.dim + 1)], axis=1)[:, :, 1:]\n\n # generate minors and determinants of `tensor` in isotropic mode.\n # +- x_{t,0,0} & \\cdots & x_{t,0,ND-1} & 1 -+\n # tensor[t, :, :] = | \\vdots & \\ddots & \\vdots & \\vdots |\n # +- x_{t,ND,0} & \\cdots & x_{t,ND,ND-1} & 1 -+\n tensor = np.concatenate([self.nodes[self.simplices, :], np.ones(shape=(self.simplices.__len__(), self.dim + 1, 1))], axis=-1)\n self.determinants = np.abs(volumes)\n self.minors = np.einsum(\"tij,t->tji\", np.linalg.inv(tensor), self.determinants)","def simplify(uniques, intersections, tolerance):\n uniques_sm = [u.simplify(tolerance=tolerance) for u in uniques]\n\n intersections_sm = [[None for i in range(len(uniques))] for j in range(len(uniques))]\n for i,s1 in enumerate(intersections):\n for j,s2 in enumerate(s1):\n if type(s2) is not shapely.geometry.GeometryCollection():\n intersections_sm[i][j] = s2.simplify(tolerance=tolerance)\n return uniques_sm, intersections_sm","def __init__(self, _dicom_dir, _contour_dir, inner_outer='inner'):\n\n self.data = []\n\n #list of indices for labeled masks\n self.labeled = []\n\n # iterate through all .dcm in the patient's dicom folder\n dicom_files = os.listdir(_dicom_dir)\n for dicom_file in dicom_files:\n if not dicom_file.endswith('.dcm'):\n pass\n else:\n idx = int(dicom_file[:-4])\n\n dcm = self.load_dicoms(_dicom_dir + \"/\" + dicom_file)\n height, width = dcm.shape\n\n ctr_i_b = None\n ctr_o_b = None\n if inner_outer == 'inner':\n ctr_i_b = self.load_contours(_contour_dir+'/i-contours/'+\n 'IM-0001-{:04d}-icontour-manual.txt'.format(idx), width, height)\n elif inner_outer == 'outer':\n ctr_o_b = self.load_contours(_contour_dir+'/o-contours/'+\n 'IM-0001-{:04d}-ocontour-manual.txt'.format(idx), width, height)\n elif inner_outer == 'both':\n ctr_i_b = self.load_contours(_contour_dir+'/i-contours/'+\n 'IM-0001-{:04d}-icontour-manual.txt'.format(idx), width, height)\n ctr_o_b = self.load_contours(_contour_dir+'/o-contours/'+\n 'IM-0001-{:04d}-ocontour-manual.txt'.format(idx), width, height)\n else:\n ctr_i_b = None\n ctr_o_b = None\n\n # if either inner or outer exists for given idx, add to self.labeled\n if ctr_i_b is not None:\n self.labeled.append(idx)\n elif ctr_o_b is not None:\n self.labeled.append(idx)\n\n self.data.append((idx, dcm, ctr_i_b, ctr_o_b))","def __init__(self, prefix, downstream, upstream, root):\n super(SubGraph, self).__init__(prefix, downstream, upstream, root)","def method2(self):\n cres=np.zeros(self.NL,dtype=float) # List of invariants\n # The U matrices from Fukui's method; storage...\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n for il in range(self.NL):\n # ... and calculation of U matrices for each layer\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.LDM[il,ix ,iy ,:,:]\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\n \n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\n \n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\n \n return cres","def smallClosNetwork():\n \n # Build a graph for Jupiter topo\n switch_nodes, edges = tp.tree_topo()\n G = build_graph(edges)\n nodes, host_nodes, tors, anodes, snodes = tp.getnodes()\n\n print('**** is_connected(G)', nx.is_connected(G))\n \n \n # Get the routing path of all nodes\n table_file_name = '../outputs/tree_routing_table.txt'\n if((os.path.isfile(table_file_name)) == False):\n table = all_routing(G, tors+['e1'], table_file_name)\n else:\n json_data = open(table_file_name).read()\n table = json.loads(json_data)\n \n print('**** Got routing table!')\n\n seeds, polys = cf.get_seeds_table_tree(switch_nodes) #\n \n return G, tors, edges, table, seeds, polys","def SLTrace(self,NSL=100,Pts=[]):\n TOF_end=[]\n SL_end=[]\n \n for i in range(4): #4 Subgrids\n \n if(len(Pts)==0):\n nsl=int(NSL*self.theta[i]/2/np.pi)\n Pts_init=PointOnUnitEdge(nsl) #Generating the start point along the well edge(alpha=0)\n else:\n nsl=len(Pts)\n Pts_init=Pts\n \n for j in range(nsl): #nsl streamlines\n GridID=i\n temp_trace=self.SubGrids[GridID].Trace1SL(Pts=Pts_init[j])\n \n SLtemp=RotateSL(temp_trace[3],Single=1,angle=self.SubGrids[GridID].RotateAngle)\n SLtemp=TranslateSL(SLtemp,Single=1,new_origin=self.SubGrids[GridID].NewOrigin)\n TOFtemp=temp_trace[5]\n \n flag=True\n while (flag==True): #the streamline will continue travel in another subgrid\n Pts_end=temp_trace[2][-1]\n temp_neighbor=self.NeighborTest(GridID,Pts_end) #test of crossing trace of a streamline\n flag=temp_neighbor[0]\n if(flag==True):\n temp_trace=[]\n SLtemp2=[]\n TOFtemp2=[]\n \n GridID_next=temp_neighbor[1]\n Pts_init_next=temp_neighbor[2]\n #Pts and TOF base starts from previous node\n temp_trace=self.SubGrids[GridID_next].Trace1SL(Pts=Pts_init_next,TOF_base=TOFtemp[-1])\n\n SLtemp2=RotateSL(temp_trace[3],Single=1,angle=self.SubGrids[GridID_next].RotateAngle)\n SLtemp2=TranslateSL(SLtemp2,Single=1,new_origin=self.SubGrids[GridID_next].NewOrigin)\n TOFtemp2=temp_trace[5]\n \n #SLtemp=np.append(SLtemp,SLtemp2,axis=0)\n #TOFtemp=np.append(TOFtemp,TOFtemp2,axis=0)\n SLtemp=np.append(SLtemp,SLtemp2[1:],axis=0)\n TOFtemp=np.append(TOFtemp,TOFtemp2[1:],axis=0)\n \n SL_end.append(SLtemp[-1])\n TOF_end.append(TOFtemp[-1])\n #Add all nodes and TOF into SL list\n self.SL.append(SLtemp)\n self.TOF.append(TOFtemp)\n \n \n #Plot the stremline\n plt.figure(figsize=(3, 3))\n plt.ylim(bottom=0,top=50)\n plt.xlim(left=0,right=50)\n plt.axes().set_aspect('equal')\n plt.title(r'Streamline in Physical Space ($x,y$)')\n \n #Grid edge\n Bound_vert=[self.Pts[0],self.Pts[1],self.Pts[2],self.Pts[3],self.Pts[0]]\n Internal_edge=[self.Pts[0],self.Pts[2],self.Pts[3],self.Pts[1]]\n \n plt.plot(*np.asarray(Bound_vert).T,lw=3,color='red')\n plt.plot(*np.asarray(Internal_edge).T,lw=2,ls='--',color='red')\n \n #Streamline\n for i in range(len(self.SL)):\n plt.plot(*np.asarray(self.SL[i]).T,lw=1,marker='o',markersize=0,color='blue')\n \n\n\n plt.show()\n return self.SL,self.TOF,SL_end,TOF_end","def simplified_graph(input_smiles, iso_flag=True):\n mol = Chem.MolFromSmiles(input_smiles)\n for atom in mol.GetAtoms():\n atom.SetFormalCharge(0)\n if atom.IsInRing():\n atom.SetAtomicNum(6)\n atom.SetIsAromatic(False)\n for bond in atom.GetBonds():\n bond.SetBondType(Chem.BondType.SINGLE)\n if not iso_flag:\n atom.SetChiralTag(Chem.ChiralType.CHI_OTHER)\n return Chem.MolToSmiles(mol, isomericSmiles=True)","def drawShadedContours(xlist, ylist, zmatrix, levels):\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))","def monolayer_4band():\n a = 0.222\n ax = 0.438\n ay = 0.332\n theta = 96.79 * (pi / 180)\n phi = 103.69 * (pi / 180)\n\n lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])\n\n h = a * sin(phi - pi / 2)\n s = 0.5 * ax - a * cos(theta / 2)\n lat.add_sublattices(\n ('A', [0, 0, h], 0),\n ('B', [s, 0, 0], 0),\n ('C', [ax/2, ay/2, 0], 0),\n ('D', [ax/2 + s, ay/2, h], 0)\n )\n\n lat.register_hopping_energies({\n 't1': -1.22,\n 't2': 3.665,\n 't3': -0.205,\n 't4': -0.105,\n 't5': -0.055\n })\n\n lat.add_hoppings(\n # t1\n ([-1, 0], 'A', 'D', 't1'),\n ([-1, -1], 'A', 'D', 't1'),\n ([ 0, 0], 'B', 'C', 't1'),\n ([ 0, -1], 'B', 'C', 't1'),\n # t2\n ([ 0, 0], 'A', 'B', 't2'),\n ([ 0, 0], 'C', 'D', 't2'),\n # t3\n ([ 0, 0], 'A', 'D', 't3'),\n ([ 0, -1], 'A', 'D', 't3'),\n ([ 1, 1], 'C', 'B', 't3'),\n ([ 1, 0], 'C', 'B', 't3'),\n # t4\n ([ 0, 0], 'A', 'C', 't4'),\n ([ 0, -1], 'A', 'C', 't4'),\n ([-1, 0], 'A', 'C', 't4'),\n ([-1, -1], 'A', 'C', 't4'),\n ([ 0, 0], 'B', 'D', 't4'),\n ([ 0, -1], 'B', 'D', 't4'),\n ([-1, 0], 'B', 'D', 't4'),\n ([-1, -1], 'B', 'D', 't4'),\n # t5\n ([-1, 0], 'A', 'B', 't5'),\n ([ 0, 1], 'A', 'B', 't5'),\n ([ 0, -1], 'A', 'B', 't5'),\n ([-1, 0], 'C', 'D', 't5'),\n ([ 0, 1], 'C', 'D', 't5'),\n ([ 0, -1], 'C', 'D', 't5'),\n )\n\n return lat","def test_1_1_2D_rec_init(self): # TODO: REMOVE FUNC AFTER SPLIT\n check = [(-1.0, -2.0), (7.0, 6.0), (7.0, -2.0), (-1.0, 6.0), (3.0, 2.0)]\n nn_checks = {(-1.0, -2.0): [(7, -2), (3.0, 2.0), (-1, 6)],\n (7.0, 6.0): [(7, -2), (3.0, 2.0), (-1, 6)],\n (7.0, -2.0): [(7, 6), (3.0, 2.0), (-1, -2)]}\n init_triangulation(2, 0, check, nn_checks, bounds=[(-1, 7), (-2, 6)])","def complex_network_mapping(graph):\n vect = []\n\n n = nx.number_of_nodes(graph)\n e = nx.number_of_edges(graph)\n print n, e\n\n# adj = nx.adjacency_matrix(graph).toarray()\n# adj_bin = np.where(adj > 0, 1., 0.)\n# adj_conn = 1 - adj\n adj_bin = nx.adjacency_matrix(graph).toarray()\n adj_bin = np.array(adj_bin, dtype=np.float)\n\n # Node Betweenness binary\n bt_bin = nx.betweenness_centrality(graph).values()\n avg_btb = np.mean(bt_bin)\n vect.append(avg_btb)\n\n # Edge betweenness\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\n vect.append(np.mean(ebt))\n\n # Eigen vector centrality binary\n evc_bin = eigenvector_centrality_und(adj_bin)\n avg_evcb = np.mean(evc_bin)\n vect.append(avg_evcb)\n\n # Flow coefficient\n _, flow_bin, _ = flow_coef_bd(adj_bin)\n avg_flow = np.mean(flow_bin)\n vect.append(avg_flow)\n\n # Kcoreness centrality\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\n avg_kcor = np.mean(kcor_bin)\n vect.append(avg_kcor)\n\n # Degree assortivity\n dac = nx.degree_assortativity_coefficient(graph)\n vect.append(dac)\n\n # Page rank centrality\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\n# avg_pgr = np.mean(pgr_wei)\n# vect.append(avg_pgr)\n\n # Rich club coefficient\n# rcc = nx.rich_club_coefficient(graph).values()\n# avg_rcc = np.mean(rcc)\n# vect.append(avg_rcc)\n\n # Transitivity\n tr = nx.transitivity(graph)\n vect.append(tr)\n\n # average clustering\n avg_clst = nx.average_clustering(graph)\n vect.append(avg_clst)\n\n glb_ef = efficiency_bin(adj_bin)\n vect.append(glb_ef)\n\n return vect","def FindMatchesAndRemovals(scListA, scListB, searchInds=None):\n scsMatchedInB = []\n removeFromA = []\n removeFromB = []\n\n if searchInds is None:\n searchInds = list(range(len(scListA)))\n\n for ind in searchInds:\n sca = scListA[ind]\n # Look for each sc from A in B:\n matchTuples = [\n (i, scb) for i, scb in enumerate(scListB) if sca.values == scb.values\n ]\n matchInds, matches = zip(*matchTuples)\n\n if len(matches) == 0:\n print(\"sc in A but not in B:\", sca.values, matches)\n sp, ep = sca.startPointValues, sca.endPointValues\n # get the values connected to the subcontour only at the corners:\n opposingValues = tuple(\n sorted(list(set(sp).union(ep).difference(sca.values)))\n )\n # get the sc's from B that have these values as their main values (aka, sca switched to this/these)\n matchOppTuples = [\n (i, scb)\n for i, scb in enumerate(scListB)\n if scb.values == opposingValues\n ]\n matchOppInds, matchesOpp = zip(*matchOppTuples)\n\n if matchesOpp == []:\n print(\"Not Recoverable!\")\n else:\n print(\n \"Recoverable: sc in A at index\",\n ind,\n sca.values,\n \"matches to sc in B at index\",\n matchOppInds[0],\n matchesOpp[0].values,\n )\n print(scListA[ind])\n removeFromA.append(\n ind\n ) # actually DO the removals later so we don't muck up the indexing!\n removeFromB.append(matchOppInds[0])\n scsMatchedInB.append(matchOppInds[0])\n\n if len(matchesOpp) > 1:\n print(\"More than 1 match!\")\n\n elif len(matches) > 1:\n print(\"sc in A matches multiple sc's in B:\", sca.values, matches)\n else:\n scsMatchedInB.append(matchInds[0])\n\n # Also check all the start and end points:\n # This stuff isn't really being used right now...\n sp1, sp2 = sca.startPointValues, matches[0].startPointValues\n if sp1 != sp2:\n print(\"start points don't match\", sp1, sp2)\n ep1, ep2 = sca.endPointValues, matches[0].endPointValues\n if ep1 != ep2:\n print(\"end points don't match\", ep1, ep2)\n\n return scsMatchedInB, removeFromA, removeFromB","def __init__(self, in_classes=1, channelscale=64):\n super(DetectPatchAndSegm, self).__init__()\n self.unetvgg1 = UNetSimple(in_classes=in_classes, channelscale=64, out_classes=2)#UNetVgg()\n self.unetvgg2 = UNetSimple(in_classes=3, channelscale=128, out_classes=3)#in is 2 patches and original image\n self.sft = nn.Softmax2d()","def slice_graph_fwd( startea, reg ): \r\n\tgraph = vcg_Graph.vcgGraph({\"title\":'\"Slice for %s\"' % reg, \\\r\n\t\t\"manhattan_edges\":\"no\", \"layoutalgorithm\":\"maxdepth\"})\r\n\t#\r\n\t# Retrieve the name of the current basic block\r\n\t# \r\n\tworklist = []\r\n\tdata_bib = {}\r\n\tstartnode = slice_node( startea, 0, reg )\r\n\trootnode = graph.Add_Node( startnode.to_name() )\r\n\tdata_bib[ startnode.to_name() ] = startnode\r\n\tworklist.insert( 0, rootnode )\r\n\twhile len( worklist ) > 0:\r\n\t\tcurrnode = worklist.pop()\r\n\t\tcurrslice = data_bib[ currnode.get_name() ]\r\n\t\ttgt_reg = currslice.get_target_reg()\r\n\t\tif tgt_reg == \"END\":\r\n\t\t# Do not process this node any further\r\n\t\t\tpass\r\n\t\telif tgt_reg == \"\" or (( len( currslice.get_lines()) > 0) and \\\r\n\t\t\tcurrslice.endea != currslice.get_lines()[-1][0]):\r\n\t\t\t# Nothing much happening here, just proceed to parent bocks\r\n\t\t\tif ua_mnem( currslice.endea ) == \"call\":\r\n\t\t\t\txrefs = get_short_crefs_from( currslice.endea )\r\n\t\t\telse:\r\n\t\t\t\txrefs = get_crefs_from( currslice.endea )\r\n\t\t\tfor ref in xrefs:\r\n\t\t\t\tnewslice = slice_node( ref, 0, currslice.reg )\r\n\t\t\t\tif graph.Get_Node( newslice.to_name() ) == 0:\r\n\t\t\t\t\tnewnode = graph.Add_Node( newslice.to_name() )\r\n\t\t\t\t\tworklist.insert( 0, newnode )\r\n\t\t\t\t\tdata_bib[ newslice.to_name() ] = newslice\r\n\t\t\t\tgraph.Add_Link( currnode.get_name(), newslice.to_name())\r\n\t\telse:\r\n\t\t\t# Register was modified, use new register\r\n\t\t\txrefs = get_crefs_from( currslice.endea )\r\n\t\t\tfor ref in xrefs:\r\n\t\t\t\tnewslice = slice_node( ref, 0, tgt_reg )\r\n\t\t\t\tif graph.Get_Node( newslice.to_name() ) == 0:\r\n\t\t\t\t\tnewnode = graph.Add_Node( newslice.to_name() )\r\n\t\t\t\t\tworklist.insert( 0, newnode )\r\n\t\t\t\t\tdata_bib[ newslice.to_name() ] = newslice\r\n\t\t\t\tgraph.Add_Link( currnode.get_name(), newslice.to_name())\r\n\t\t\txrefs = get_crefs_from( currslice.endea )\r\n\t\t\tfor ref in xrefs:\r\n\t\t\t\tnewslice = slice_node( ref, 0, currslice.reg )\r\n\t\t\t\tif graph.Get_Node( newslice.to_name() ) == 0:\r\n\t\t\t\t\tnewnode = graph.Add_Node( newslice.to_name() )\r\n\t\t\t\t\tworklist.insert( 0, newnode )\r\n\t\t\t\t\tdata_bib[ newslice.to_name() ] = newslice\r\n\t\t\t\tgraph.Add_Link( currnode.get_name(), newslice.to_name())\r\n\treturn [ graph, data_bib ]","def simplify_network(network):\n network_proj = ox.project_graph(network)\n simplified_proj = ox.consolidate_intersections(network_proj, rebuild_graph=True, tolerance=50, dead_ends=False)\n simplified = ox.project_graph(simplified_proj, network.graph[\"crs\"])\n return simplified","def manual_cliques(adj_list,cliques):\n G = nx.Graph()\n for clique in cliques:\n for n1 in clique:\n for n2 in clique:\n if n1 != n2:\n G.add_edge(adj_list[n1],adj_list[n2])\n \n n1 = cliques[0][0]\n for idx,clique in enumerate(cliques):\n if idx > 0:\n n2 = clique[2]\n G.add_edge(adj_list[n1],adj_list[n2])\n n1 = clique[0]\n \n #Attach head and tail cliques\n n1 = cliques[0][3]\n n2 = cliques[len(cliques) - 1][1]\n G.add_edge(adj_list[n1],adj_list[n2])\n return G","def SSC_test():\n \n # generating data\n\n D = 40 # Dimension of ambient space\n k = 4 # Number of subspaces\n d = 1\n N = 90 # Number of points in subspaces\n # Generating N points in d dim. subspaces\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\n for _ in range(k)]\n X = np.concatenate(Xi, axis=1)\n\n # Generating the ground-truth for evaluating clustering results\n lbls = [i * np.ones([1, N]) for i in range(k)]\n s = np.concatenate(lbls, axis=1)\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\n K = 0 #max(d1, d2)\n if Cst == 1:\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\n\n Xp = DataProjection(X, r, 'NormalProj')\n \n # testing clustering\n \n '''\n # using wrapper function\n Grps, sc = sparseSubspaceClustering(\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n '''\n \n '''\n # calling internal tools\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\n # Make small values 0\n eps = np.finfo(float).eps\n CMat[np.abs(CMat) < eps] = 0\n\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\n\n if Fail == False:\n CKSym = BuildAdjacency(CMatC, K)\n Grps = SpectralClustering(CKSym, n)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n else:\n print(\"Something failed\")\n '''\n \n labels, _, __ = KSubspaces(Xp.T, k, d)\n labels = BestMap(s, labels)\n Missrate = float(np.sum(s != labels)) / s.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))","def prog(args):\r\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\r\n mesh = stl.mesh.Mesh.from_file(i_fname)\r\n #rotate mesh since by default the rotation axis is along X\r\n mesh.rotate([0,1,0],np.pi/2)\r\n\r\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\r\n\r\n splt0_arr = np.array(split_list)\r\n splt1_arr = np.roll(splt0_arr,-1)\r\n\r\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\r\n\r\n #make splits\r\n pos_list=[]\r\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\r\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\r\n print(splt0, splt1)\r\n #pos = [r, th, z] sectionwise\r\n pos_list.append(pos[pos_idx])\r\n #add pedestal mesh\r\n\r\n for sect_num, pos in enumerate(pos_list):\r\n pos = cf.add_pedestal(pos, pedestal_params)\r\n profiles=np.zeros_like(pos)\r\n\r\n for i in np.arange(np.shape(pos)[0]):\r\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\r\n\r\n strokes = np.flipud(np.rot90(profiles))\r\n #transform data from longeron nodes [xyz] to:\r\n #a_arr - rotation angle around the rotation axis\r\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\r\n #z_arr - corresponding z coordiantes\r\n #v_arr - direction vector of the coresponding lateral mesh edge\r\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\r\n\r\n #make a summary plots\r\n cf.plot_loft_paths(profiles)\r\n cf.plot_loft_paths(pos)\r\n cf.plot_surf(a_arr,z_arr,r_arr)\r\n\r\n #collect data to the dictionary longeron wise\r\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\r\n 'r_arr':np.rot90(r_arr, k=-1),\r\n 'z_arr':np.rot90(z_arr, k=-1),\r\n 'v_arr':np.rot90(v_arr, k=-1)}\r\n\r\n #save result dictionary\r\n if not o_fname:\r\n o_fname = i_fname\r\n\r\n fname='{}_{}.pickle'.format(o_fname, sect_num)\r\n with open(fname, 'wb') as f:\r\n # Pickle the 'data' dictionary using the highest protocol available.\r\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\r\n\r\n print(fname, ' saved')","def __init__(self, device=\"cuda:0\", *args, **kwargs):\n # source_file_wtsd = \"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\"\n source_file_wtsd = \"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\"\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \"r\")[\"data\"][:].astype(np.long)).to(device)\n slices = [0, 157, 316]\n slices_labels = [[1359, 1172, 364, 145, 282, 1172, 1359, 189, 809, 737],\n [886, 748, 1148, 1422, 696, 684, 817, 854, 158, 774],\n [1240, 807, 1447, 69, 1358, 1240, 129, 252, 62, 807]]\n m1, m2 = [], []\n # widths, heights = [], []\n self.outer_cntr_ds, self.inner_cntr_ds = [], []\n for slc, labels in zip(slices, slices_labels):\n bg = wtsd[:, slc, :] == 1\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\n #\n # for l in labels:\n # mask = wtsd[:, slc, :] == l\n # cnt = find_contours(mask.cpu().numpy(), level=0)[0]\n #\n # # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # # img[cnt[:, 0], cnt[:, 1]] = 1\n # # plt.imshow(img);plt.show()\n #\n # ellipseT = fitEllipse(cnt.astype(np.int))\n # widths.append(ellipseT[1][1])\n # heights.append(ellipseT[1][0])\n #\n #\n #\n # self.masses = [np.array(m1).mean(), np.array(m2).mean()]\n # self.expected_ratio = np.array(widths).mean() / np.array(heights).mean()\n self.expected_ratio = 5.573091\n self.masses = [290229.3, 97252.3]","def buildConnectedSets(self, cars):","def show_subgraph(dfs_codes, nsupport, mapper):\n\tglobal __subgraph_count\n\n\tg = build_graph(dfs_codes)\n\tg.id = __subgraph_count\n\t__subgraph_count += 1\n\tg.gprint(nsupport, mapper)","def collect_subinstances(img_list, subinstance_size, clickable_size):\n num_files = len(img_list)\n step_size = subinstance_size // 2\n num_subinstances = 0\n for i in range(num_files):\n num_rows = int(np.ceil((2.0 * img_list[i].shape[0] / float(subinstance_size)) - 1.0))\n num_cols = int(np.ceil((2.0 * img_list[i].shape[1] / float(subinstance_size)) - 1.0))\n num_subinstances += num_rows * num_cols\n #print(str(i) + \"-th image: \" + \"num_rows = \" + str(num_rows) + \", num_cols = \" + str(num_cols) + \", #(sub_files) = \", str(num_subinstances))\n \n print(\"#(subinstances) =\", num_subinstances)\n \n expand = (subinstance_size // clickable_size)\n \n subinstance_list = [None] * expand * expand * num_subinstances\n subinstance_org_loc_list = [None] * expand * expand * num_subinstances\n \n patch_i = 0\n for i in range(num_files):\n num_rows = int(np.ceil((2.0 * img_list[i].shape[0] / float(subinstance_size)) - 1.0))\n num_cols = int(np.ceil((2.0 * img_list[i].shape[1] / float(subinstance_size)) - 1.0))\n for j in range(num_rows):\n for k in range(num_cols):\n for l in range(expand):\n for m in range(expand):\n try:\n subinstance_list[patch_i * expand * expand + l * expand + m ] \\\n = img_list[i][step_size * j + l * clickable_size : step_size * j + (l + 1) * clickable_size,\n step_size * k + m * clickable_size : step_size * k + (m + 1) * clickable_size]\n except IndexError:\n sys.stdout.write(\"ERROR: images are not normalized.\\n\")\n exit(0)\n subinstance_org_loc_list[patch_i * expand * expand + l * expand + m ] \\\n = (i, (step_size * j + l * clickable_size,\n step_size * k + m * clickable_size,\n clickable_size,\n clickable_size))\n patch_i += 1\n\n if patch_i != num_subinstances:\n sys.stdout.write(\"ERROR: the number of subinstances is not consistent.\\n\")\n exit(-1)\n return subinstance_list, subinstance_org_loc_list","def build_curvilinear_connection(debug):\n\n MV.connection = True\n MV.tangent_norm = Vector.norm\n MV.tangent_derivatives_MV = {}\n\n rcpr_bases_MV = []\n\n for (rbase, norm) in zip(MV.rcpr_bases_MV, MV.tangent_norm):\n rcpr_bases_MV.append(rbase / norm)\n\n MV.rcpr_bases_MV = rcpr_bases_MV\n\n for key in Vector.dtau_dict.keys():\n MV.tangent_derivatives_MV[key] = MV(Vector.dtau_dict[key])\n\n if debug:\n oprint('Tangent Vector Derivatives', MV.tangent_derivatives_MV, dict_mode=True)\n\n MV.left_connection = {}\n MV.right_connection = {}\n MV.left_wedge_connection = {}\n MV.right_wedge_connection = {}\n MV.left_dot_connection = {}\n MV.right_dot_connection = {}\n\n for base in MV.blades[1]:\n right_result = MV()\n left_result = MV()\n for (coord, rblade) in zip(MV.coords, MV.rcpr_bases_MV):\n left_result += rblade * MV.tangent_derivatives_MV[(base, coord)]\n right_result += MV.tangent_derivatives_MV[(base, coord)] * rblade\n left_result.obj = expand(left_result.obj)\n right_result.obj = expand(right_result.obj)\n left_result.discover_and_set_grade()\n right_result.discover_and_set_grade()\n MV.left_connection[base] = left_result.obj\n MV.right_connection[base] = right_result.obj\n MV.left_wedge_connection[base] = left_result.grade(2).obj\n MV.right_wedge_connection[base] = right_result.grade(2).obj\n MV.left_dot_connection[base] = left_result.grade(0).obj\n MV.right_dot_connection[base] = right_result.grade(0).obj\n\n for grade in MV.blades[2:]:\n for blade in grade:\n index = MV.blade_to_index[blade]\n N = len(index)\n left_result = MV()\n right_result = MV()\n for (coord, rblade) in zip(MV.coords, MV.rcpr_bases_MV):\n tmp = MV()\n for i in range(N):\n i_pre = index[:i]\n i_dtan = index[i]\n i_post = index[i + 1:]\n base = MV.blades[1][i_dtan]\n tmp += (MV(MV.index_to_blade[i_pre]) ^ MV.tangent_derivatives_MV[(base, coord)]) ^ MV(MV.index_to_blade[i_post])\n left_result += rblade * tmp\n right_result += tmp * rblade\n left_result.discover_and_set_grade()\n right_result.discover_and_set_grade()\n MV.left_connection[blade] = left_result.obj\n MV.right_connection[blade] = right_result.obj\n MV.left_wedge_connection[blade] = left_result.grade(N + 1).obj\n MV.right_wedge_connection[blade] = right_result.grade(N + 1).obj\n MV.left_dot_connection[blade] = left_result.grade(abs(N - 1)).obj\n MV.right_dot_connection[blade] = right_result.grade(abs(N - 1)).obj\n\n MV.connection = {'left': MV.left_connection, 'right': MV.right_connection,\n 'left_wedge': MV.left_wedge_connection, 'right_wedge': MV.right_wedge_connection,\n 'left_dot': MV.left_dot_connection, 'right_dot': MV.right_dot_connection}\n MV.grad.connection = MV.connection\n\n if debug:\n oprint('Left Mutlivector Connection', MV.left_connection,\n 'Right Mutlivector Connection', MV.right_connection,\n 'Left Wedge Mutlivector Connection', MV.left_wedge_connection,\n 'Right Wedge Mutlivector Connection', MV.right_wedge_connection,\n 'Left Dot Mutlivector Connection', MV.left_dot_connection,\n 'Right Dot Mutlivector Connection', MV.right_dot_connection, dict_mode=True)\n return","def vsn_func_1(ns, traj, vs_def_beads_ids):\n for ts in ns.aa2cg_universe.trajectory:\n traj[ts.frame] = ns.aa2cg_universe.atoms[vs_def_beads_ids].center_of_geometry(pbc=None)","def _compute_topology(self, initial_surfaces):\n\n nsurf = len(initial_surfaces)\n surfaces = numpy.zeros((nsurf, 3, 3, 3), float, 'F')\n\n for isurf in xrange(nsurf):\n surface = initial_surfaces[isurf]\n num_u, num_v = surface.shape[:2]\n mid_u1 = int(numpy.floor((num_u - 1) / 2.0))\n mid_u2 = int(numpy.ceil((num_u - 1) / 2.0))\n mid_v1 = int(numpy.floor((num_v - 1) / 2.0))\n mid_v2 = int(numpy.ceil((num_v - 1) / 2.0))\n\n for ind_u in xrange(2):\n for ind_v in xrange(2):\n surfaces[isurf, -ind_u, -ind_v] = surface[-ind_u, -ind_v]\n\n for ind_u in xrange(2):\n surfaces[isurf, -ind_u, 1] += 0.5 * surface[-ind_u, mid_v1] + \\\n 0.5 * surface[-ind_u, mid_v2]\n\n for ind_v in xrange(2):\n surfaces[isurf, 1, -ind_v] += 0.5 * surface[mid_u1, -ind_v] + \\\n 0.5 * surface[mid_u2, -ind_v]\n\n nvert, nedge, surf_ptrs \\\n = BSElib.computesurfconnectivities(nsurf, 1e-16, 1e-10, surfaces)\n\n edge_ptrs \\\n = BSElib.computeedgeconnectivities(nsurf, nedge, surf_ptrs)\n\n ngroup, surf_group, edge_group \\\n = BSElib.computegroups(nsurf, nedge, surf_ptrs)\n\n topology = [nvert, nedge, ngroup, \\\n surf_ptrs, edge_ptrs, \\\n surf_group, edge_group, \\\n ]\n\n return topology","def second_level_covariate(contrast_list, experiment_dir, first_level_dir, output_dir, cov_ls, mask_path='/data/group_mask.nii.gz', working_dir='workingdir'):\n # Gunzip - unzip the mask image\n gunzip = Node(Gunzip(in_file=mask_path), name=\"gunzip\")\n\n # covariates (a list of items which are a dictionary with keys which are 'vector' or 'name' or 'interaction' or 'centering' and with values which are any value)\n covariates_ls = [dict(vector=cov_ls, name='model_evidence')]\n\n # OneSampleTTestDesign - creates one sample T-Test Design\n onesamplettestdes = Node(OneSampleTTestDesign(covariates=covariates_ls),\n name=\"onesampttestdes\")\n\n # EstimateModel - estimates the model\n level2estimate = Node(EstimateModel(estimation_method={'Classical': 1}),name=\"level2estimate\")\n\n # EstimateContrast - estimates group contrast\n level2conestimate = Node(EstimateContrast(group_contrast=True),\n name=\"level2conestimate\")\n cont1 = ['Group', 'T', ['mean'], [1]]\n level2conestimate.inputs.contrasts = [cont1]\n\n # Threshold - thresholds contrasts\n level2thresh = Node(Threshold(contrast_index=1,\n use_topo_fdr=True,\n # use_fwe_correction=True,\n use_fwe_correction=False,\n extent_threshold=0,\n height_threshold=0.001,\n # height_threshold=0.05,\n height_threshold_type='p-value',\n extent_fdr_p_threshold=0.05),\n name=\"level2thresh\")\n\n # Infosource - a function free node to iterate over the list of subject names\n infosource = Node(IdentityInterface(fields=['contrast_id']),\n name=\"infosource\")\n infosource.iterables = [('contrast_id', contrast_list)]\n\n # SelectFiles - to grab the data (alternativ to DataGrabber)\n firstlev_dir = opj(experiment_dir, first_level_dir, '1stLevel')\n templates = {'cons': opj(firstlev_dir, 'sub-*',\n '{contrast_id}.nii')}\n selectfiles = Node(SelectFiles(templates,\n base_directory=experiment_dir,\n sort_filelist=True),\n name=\"selectfiles\")\n\n # Datasink - creates output folder for important outputs\n datasink = Node(DataSink(base_directory=experiment_dir,\n container=output_dir),\n name=\"datasink\")\n\n # Use the following DataSink output substitutions\n substitutions = [('_contrast_id_', '')]\n datasink.inputs.substitutions = substitutions\n\n # Initiation of the 2nd-level analysis workflow\n l2analysis = Workflow(name='l2analysis')\n l2analysis.base_dir = opj(experiment_dir, working_dir)\n\n # Connect up the 2nd-level analysis components\n l2analysis.connect([(infosource, selectfiles, [('contrast_id', 'contrast_id')]),\n (selectfiles, onesamplettestdes, [('cons', 'in_files')]),\n (gunzip, onesamplettestdes, [('out_file',\n 'explicit_mask_file')]),\n (onesamplettestdes, level2estimate, [('spm_mat_file', 'spm_mat_file')]),\n (level2estimate, level2conestimate, [('spm_mat_file', 'spm_mat_file'),\n ('beta_images', 'beta_images'),\n ('residual_image', 'residual_image')]),\n (level2conestimate, level2thresh, [('spm_mat_file',\n 'spm_mat_file'),\n ('spmT_images',\n 'stat_image'),\n ]),\n (level2conestimate, datasink, [('spm_mat_file',\n '2ndLevel.@spm_mat'),\n ('spmT_images',\n '2ndLevel.@T'),\n ('con_images',\n '2ndLevel.@con')]),\n (level2thresh, datasink, [('thresholded_map',\n '2ndLevel.@threshold')]),\n ])\n return l2analysis","def cfdProcessNodeTopology(self):\r\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\r\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)","def connect_back(simulation_dict, (index_from, blocks_per_dim_from), (index_to, blocks_per_dim_to), square_size, radius, context_factor):\n logging.info(\"Connecting back additional context from index %d to index %d\" % (index_from, index_to))\n logging.info(\"Connecting back additional context from layer size is %d, receiving layer size is %d\" % (blocks_per_dim_from, blocks_per_dim_to))\n logging.info(\"Radius of connectivity %d\" % radius)\n for x in range(blocks_per_dim_from):\n for y in range(blocks_per_dim_from):\n surround = get_fan_in((x, y),\n dim_x_l=blocks_per_dim_to,\n dim_y_l=blocks_per_dim_to,\n dim_x_u=blocks_per_dim_from,\n dim_y_u=blocks_per_dim_from,\n block_x=square_size,\n block_y=square_size,\n radius=radius)\n source = index_from + x * (blocks_per_dim_from) + y # unit in the higher layer\n for xy in surround:\n dest = index_to + xy[0] * blocks_per_dim_to + xy[1] # unit in the lower layer\n context_block = simulation_dict['stage0'][source]['output_block']\n delta_block2 = SharedArray.SharedNumpyArray_like(context_block)\n simulation_dict['stage0'][source]['delta_blocks'].append(delta_block2)\n # Connect the context block to the source\n simulation_dict['stage0'][dest]['context_blocks'].append((context_block, delta_block2, context_factor))","def __init__(self, device=\"cuda:0\", *args, **kwargs):\n source_file_wtsd = \"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\"\n source_file_wtsd = \"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\"\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \"r\")[\"data\"][:].astype(np.long)).to(device)\n slices = [0, 157, 316]\n label_1 = [1359, 886, 1240]\n label_2 = [1172, 748, 807]\n label_3 = [364, 1148, 1447]\n m1, m2, m3, m4, m5 = [], [], [], [], []\n self.outer_cntr_ds, self.inner_cntr_ds, self.celltype_1_ds, self.celltype_2_ds, self.celltype_3_ds = [], [], [], [], []\n for slc, l1, l2, l3 in zip(slices, label_1, label_2, label_3):\n bg = wtsd[:, slc, :] == 1\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\n\n mask = wtsd[:, slc, :] == l1\n m3.append(mask.long().sum().item())\n cnt3 = find_contours(mask.cpu().numpy(), level=0)[0]\n mask = wtsd[:, slc, :] == l2\n m4.append(mask.long().sum().item())\n cnt4 = find_contours(mask.cpu().numpy(), level=0)[0]\n mask = wtsd[:, slc, :] == l3\n m5.append(mask.long().sum().item())\n cnt5 = find_contours(mask.cpu().numpy(), level=0)[0]\n\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt1[:, 0], cnt1[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt2[:, 0], cnt2[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt3[:, 0], cnt3[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt4[:, 0], cnt4[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt5[:, 0], cnt5[:, 1]] = 1\n # plt.imshow(img);plt.show()\n\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\n self.celltype_1_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt3, tolerance=1.2)).to(device)))\n self.celltype_2_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt4, tolerance=1.2)).to(device)))\n self.celltype_3_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt5, tolerance=1.2)).to(device)))\n\n self.masses = [np.array(m1).mean(), np.array(m2).mean(), np.array(m3 + m4 + m5).mean()]\n self.fg_shape_descriptors = self.celltype_1_ds + self.celltype_2_ds + self.celltype_3_ds","def __init__(self, initial_surfaces):\n\n nsurf = len(initial_surfaces)\n nvert, nedge, ngroup, \\\n surf_ptrs, edge_ptrs, \\\n surf_group, edge_group \\\n = self._compute_topology(initial_surfaces)\n\n self._num = {\n 'surf': len(initial_surfaces),\n 'vert': nvert,\n 'edge': nedge,\n 'group': ngroup,\n }\n\n self._topo = {\n 'surf_ptrs': surf_ptrs,\n 'edge_ptrs': edge_ptrs,\n 'surf_group': surf_group,\n 'edge_group': edge_group,\n }\n\n self._mult = {\n 'vert': numpy.zeros(nvert, int),\n 'edge': numpy.zeros(nedge, int),\n 'diff_vert': numpy.zeros(nvert, int),\n 'diff_edge': numpy.zeros(nedge, int),\n }\n\n self._bspline = {\n 'order': 4 * numpy.ones(ngroup, int),\n 'num_cp': 4 * numpy.ones(ngroup, int),\n 'num_pt': 10 * numpy.ones(ngroup, int),\n }\n\n self._surf_indices = {\n 'df': numpy.zeros((nsurf, 2), int, 'F'),\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\n }\n\n self._edge_indices = {\n 'df': numpy.zeros((nedge, 2), int, 'F'),\n 'cp': numpy.zeros((nedge, 2), int, 'F'),\n 'pt': numpy.zeros((nedge, 2), int, 'F'),\n }\n\n self._str_indices = {\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\n }\n\n self._vert_indices = numpy.zeros(nvert, int)\n\n self._size = {\n 'df_str': 0,\n 'df': 0,\n 'cp': 0,\n 'cp_str': 0,\n 'pt_str': 0,\n 'pt': 0,\n }\n\n self.diff = {\n 'surf': numpy.zeros((nsurf, 3, 3), bool, 'F'),\n 'edge': numpy.zeros((nedge, 2), bool, 'F'),\n }\n\n self.hidden = numpy.zeros(nsurf, bool)\n\n self.jac = {\n 'd(df)/d(df_str)': None,\n 'd(cp)/d(df)': None,\n 'd(cp_str)/d(cp)': None,\n 'd(pt_str)/d(cp_str)': None,\n 'd(pt)/d(pt_str)': None,\n }\n\n self.vec = {\n 'df_str': None,\n 'df': None,\n 'cp': None,\n 'cp_str': None,\n 'pt_str': None,\n 'pt': None,\n }","def get_GNS_cut(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n x_e = {}\n # edge variables for s_1, t_1 cut\n for (u,v) in edges:\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_e = {}\n # edge variables for s_2, t_2 cut\n for (u,v) in edges:\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_e = {}\n # edge variables for s_2, t_1 cut\n for (u,v) in edges:\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(x_e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\n\n # 2. Constraints for s_2 - t_2 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_2):\n m.addConstr(y_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\n\n # 3. Constraints for s_2 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_1):\n m.addConstr(z_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\n\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\n for (u,v) in edges:\n m.addConstr(e[u,v] >= x_e[u,v])\n m.addConstr(e[u,v] >= y_e[u,v])\n m.addConstr(e[u,v] >= z_e[u,v])\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n print \"Min GNS cut value = \" + str(m.objVal)\n print \"GNS cut edges:\"\n\n for u,v in edges:\n if e[u,v].x != 0:\n print (u,v)\n print \"s1-t1 cut edges in GNS:\"\n for u,v in edges:\n if x_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t2 cut edges in GNS:\"\n for u,v in edges:\n if y_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t1 cut edges in GNS:\"\n for u,v in edges:\n if z_e[u,v].x != 0:\n print (u,v)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n\n except GurobiError:\n print ('Error report from Gurobi')","def clip(self, clip, s_entry, c_entry):\n\n # detect clip mode\n unionmode = not s_entry and not c_entry\n intersectionmode = s_entry and c_entry\n differencemode = not s_entry and c_entry\n\n # prep by removing repeat of startpoint at end\n first = self.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n first = clip.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n\n # TODO: maybe also remove repeat points anywhere?\n # ...\n \n # phase one - find intersections\n # ------------------------------\n anyintersection = False\n s_intsecs = []\n c_intsecs = []\n for s in self.iter(): # for each vertex Si of subject polygon do\n for c in clip.iter(): # for each vertex Cj of clip polygon do\n try:\n #print \"find isect %s - %s and %s - %s\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\n c, clip.next(c.__next__))\n \n iS = Vertex(i, alphaS, intersect=True, entry=False)\n iC = Vertex(i, alphaC, intersect=True, entry=False)\n\n iS.neighbour = iC\n iC.neighbour = iS\n \n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\n \n anyintersection = True\n \n except TypeError:\n pass # this simply means intersect() returned None\n\n # insert intersections into originals\n for iS,a,s,s_next in reversed(s_intsecs):\n if a == 0:\n self.replace(s, iS)\n elif a == 1:\n self.replace(s_next, iS)\n else:\n self.insert(iS, s, s_next)\n for iC,a,c,c_next in reversed(c_intsecs):\n if a == 0:\n self.replace(c, iC)\n elif a == 1:\n self.replace(c_next, iC)\n else:\n clip.insert(iC, c, c_next)\n\n #print \"testing if insert was done correctly\"\n for s in self.iter():\n #print s\n pass\n #print \"and\"\n for c in clip.iter():\n #print c\n pass\n \n\n # phase one and a half - no intersections between subject and clip, so correctly return results\n # --------------------\n def specialcase_insidetest():\n resultpolys = []\n if unionmode: # union\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so just return subject shell\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so just return clip shell\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so return both\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif intersectionmode: # intersection\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so no intersection to return\n pass\n elif differencemode: # difference\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n hole = Polygon()\n for c in clip.iter():\n hole.add(Vertex(c))\n polytuple = (clipped, [hole])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so there is no difference\n pass\n else:\n #clip polygon is entirely outside subject, so difference is simply the subject\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n # no need to continue so just return result\n return resultpolys\n \n if not anyintersection: \n return specialcase_insidetest()\n\n\n\n\n\n\n\n # phase two - identify entry/exit points\n # --------------------------------------\n\n # From K&K\n \n def mark_flags(poly, c, c_entry):\n \"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\"\n #print \"intersection\"\n #print \"\\t\",c\n # intersection is degenerate, is the start/endpoint of a line\n # so maybe delete intersection flag based on prev/next locations\n prevloc = testLocation(c.prev, poly)\n nextloc = testLocation(c.__next__, poly)\n if prevloc == \"on\" or nextloc == \"on\":\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\n prevloc = testLocation(prevmid, poly)\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\n nextloc = testLocation(nextmid, poly)\n if prevloc == \"in\" or nextloc == \"in\":\n poly.anyinside = True\n #print \"\\t %s -> degenintsec -> %s\" %(prevloc,nextloc)\n if prevloc == \"out\":\n if nextloc == \"out\":\n #just touching\n c.entry = \"en/ex\" if c_entry else \"ex/en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif nextloc == \"on\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif prevloc == \"in\":\n #union and difference should never go inside the other polygon\n #so this should only happen for intersectmode...\n if nextloc == \"in\":\n #just touching\n c.entry = \"ex/en\" if c_entry else \"en/ex\"\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"on\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif prevloc == \"on\":\n if nextloc == \"on\":\n c.entry = None\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n\n self.anyinside = False\n\n # set clip\n prevsingle = None\n for c in clip.iter():\n if c.intersect:\n mark_flags(self, c, c_entry)\n # set couple\n if c.entry in (\"ex\",\"en\"):\n if prevsingle and c.entry == prevsingle.entry:\n c.couple = prevsingle\n prevsingle.couple = c\n prevsingle = c\n # set crosschange\n # some modifications based on implementation in qt clipper source code\n #if c.entry == \"en/ex\" == c.neighbour.entry or c.entry == \"ex/en\" == c.neighbour.entry:\n if False: #c.entry == \"en/ex\" or c.entry == \"ex/en\":\n print(\"Maybe crosschange...\")\n # tri1\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\n dir1 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n # tri2\n #a,b,c = c.neighbour.prev, c.prev, c.next\n a,b,c = c.__next__, c.prev, c.neighbour.prev\n dir2 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n print(dir1,dir2)\n #if dir1 < 0 != dir2 < 0: # different orientation\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\n print(\"CROSSCHANGE!!!\")\n c.cross_change = True\n c.neighbour.cross_change = True # not sure if should set neighbour too\n\n # maybe early abort\n if not self.anyinside and intersectionmode:\n return []\n\n # what about perfect overlap???\n # ...\n\n if False: #DEBUG:\n print(\"view clip entries\")\n for c in clip.iter():\n print(c, c.entry)\n\n # find first isect where both neighbours have valid flag\n for c in clip.iter():\n if c.entry:\n s = c.neighbour\n mark_flags(clip, s, s_entry)\n if s.entry:\n first_c = c\n first_s = s\n # print 777,s.entry\n break\n\n else:\n return specialcase_insidetest()\n #raise Exception(\"weird special case, no neighbours that both have flag left\")\n \n # autoset subj, if neighbour of first is different, then set all as opposite\n # TODO: how deal with s_entry in case of different modes...?\n print(\"view first\")\n print(first_c, first_c.entry)\n print(first_s, first_s.entry)\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\n for c in clip.iter():\n if c.entry:\n if c.entry == \"en\": c.neighbour.entry = \"ex\"\n elif c.entry == \"ex\": c.neighbour.entry = \"en\"\n elif c.entry == \"en/ex\": c.neighbour.entry = \"ex/en\"\n elif c.entry == \"ex/en\": c.neighbour.entry = \"en/ex\"\n \n # else set all same\n else:\n for c in clip.iter():\n if c.entry:\n c.neighbour.entry = c.entry\n\n # set couple for subj (not sure if needed)\n prevsingle = None\n for s in self.iter():\n if s.entry:\n if s.entry in (\"ex\",\"en\"):\n if prevsingle and s.entry == prevsingle.entry:\n s.couple = prevsingle\n prevsingle.couple = s\n prevsingle = s\n\n if False: #DEBUG: \n print(\"view subj entries\")\n for s in self.iter():\n print(s, s.entry)\n\n\n\n\n\n # phase three - construct a list of clipped polygons\n # --------------------------------------------------\n\n ######\n # Defs\n def next_unprocessed(vert):\n origvert = vert\n while vert:\n if vert.entry and not (vert.checked or vert.neighbour.checked):\n #print \"vert, found next unproc\", vert, vert.checked, vert.neighbour.checked\n if vert.couple:\n # rule 1\n if vert.couple.entry and vert.entry:\n # rule 2\n if vert.couple.entry == \"en\" and vert.entry == \"en\":\n return vert.couple\n elif vert.couple.entry == \"ex\" and vert.entry == \"ex\":\n return vert\n # rule 3\n else:\n return vert\n \n vert = vert.__next__\n \n if vert == origvert:\n # if returned to first, return None\n return None\n\n def DeleteFlag1(cur, stat):\n if cur.entry == \"en/ex\":\n cur.entry = None\n if cur.cross_change:\n if stat == \"D3\":\n return \"D3\"\n else:\n return \"D4\"\n if stat == \"D3\":\n return \"D4\"\n else:\n return \"D3\"\n if cur.entry == \"ex/en\":\n if stat == \"D3\":\n cur.entry = \"en\"\n return \"D2\"\n else:\n cur.entry = \"ex\"\n return \"D1\"\n if cur.entry == \"en\":\n cur.entry = None\n return \"D1\"\n if cur.entry == \"ex\":\n cur.entry = None\n return \"D2\"\n\n def DeleteFlag2(cur, prev, stat):\n if cur.entry == \"en/ex\":\n if stat == \"D1\":\n cur.entry = \"ex\"\n else:\n cur.entry = \"en\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex/en\":\n if stat == \"D1\":\n cur.entry = \"en\"\n else:\n cur.entry = \"ex\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"en\":\n cur.entry = None\n if stat == \"D1\" and cur.couple and prev.couple == cur:\n return \"D1\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex\":\n cur.entry = None\n if stat != \"D1\" and cur.couple and prev.couple == cur:\n return \"D2\"\n else:\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n\n def proceed(cur, stat):\n cur.checked = True\n if stat == \"D1\":\n clipped.add(Vertex(cur))\n return cur.__next__\n elif stat == \"D2\":\n clipped.add(Vertex(cur))\n return cur.prev\n else:\n return cur.neighbour\n\n ####\n resultpolys = []\n\n self.first.checked = True\n cur = prev = start = next_unprocessed(self.first)\n\n while cur:\n # each new polygon\n print(\"new poly\")\n\n stat = DeleteFlag1(cur, \"D3\")\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n clipped = Polygon()\n cur = proceed(cur, stat)\n\n # collect vertexes\n while cur != start:\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n if cur.entry:\n if stat == \"D1\" or stat == \"D2\":\n stat = DeleteFlag2(cur, prev, stat)\n else:\n stat = DeleteFlag1(cur, stat)\n prev = cur\n cur = proceed(cur, stat)\n\n # return to first vertex\n clipped.add(Vertex(clipped.first))\n\n print(clipped)\n\n resultpolys.append((clipped,[]))\n cur = prev = start = next_unprocessed(self.first)\n\n\n\n # finally, sort into exteriors and holes\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\n for otherext,otherholes in resultpolys:\n if polyext == otherext:\n continue # don't compare to self\n if polyext.first.isInside(otherext):\n otherholes.append(polyext) #poly is within other so make into a hole\n del resultpolys[pindex] #and delete poly from being an independent poly\n return resultpolys","def refinemesh(prev_legs, state0_chaser, n_s):\n scored_points = np.array([])\n for leg in prev_legs:\n scored_point = [*leg.dv, leg.t_leg, leg.score]\n scored_points = np.append(scored_points, scored_point)\n scored_points = scored_points.reshape(len(prev_legs), 5)\n tri = Delaunay(scored_points[:, 0:4], qhull_options='QJ')\n m_max = max(scored_points[:, 4]) # Maximum trajectory score of all simplices of the triangulation\n if m_max == 0:\n print('algorithm.py: m_max = 0 because all leg scores are 0!!!')\n m_max = 1 # to avoid raising the dividing by 0 error if all leg scores are 0\n g_max = 1\n for q in tri.simplices:\n smplx_scores = scored_points[:, 4][q] # scores of the points defining the simplex\n aux = mean(smplx_scores)\n if g_max < aux:\n g_max = aux\n\n simplices_scored = []\n for q in tri.simplices:\n smplx_score = compute_simplexscore(q, scored_points, m_max, g_max)\n # simp_scored = [smplx_score, q_vec]\n simplices_scored.append([smplx_score, q])\n sorted_simp_scores = sorted(simplices_scored, reverse=True) # ranks the simplices based on score\n new_samples = samplewithinbestsimplices(sorted_simp_scores, tri.points, n_s)\n\n new_legs = []\n for s in new_samples:\n leg = Leg(s[0:3], s[3], state0_chaser)\n new_legs.append(leg)\n\n return new_legs","def add_sudoku_constraints(sg):\n for y in range(6):\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for x in range(6)]))\n for x in range(6):\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for y in range(6)]))\n for z in range(6):\n top = (z // 2) * 2\n left = (z % 2) * 3\n cells = [sg.grid[Point(y, x)] for y in range(top, top + 2) for x in range(left, left + 3)]\n sg.solver.add(Distinct(*cells))","def __init__(self, node_map, edge_list):\n self.node_map = node_map\n self.edge_list = edge_list\n self.sif_list = []\n categories = Categories()\n abbrev_map = categories.abbrev_category_map\n\n self.data_list = []\n for node_id in node_map:\n node = node_map[node_id]\n node.sif_id = abbrev_map[node.category] + \"_\" + node.label\n dict = {}\n dict[\"id\"] = node.id\n dict[\"label\"] = node.sif_id\n dict[\"category\"] = node.category\n node_dict = {}\n node_dict[\"data\"] = dict\n self.data_list.append(node_dict)\n\n edge_id = 0\n for edge in edge_list:\n dict = {}\n dict[\"id\"] = \"e\" + str(edge_id)\n dict[\"source\"] = edge.source_id\n dict[\"target\"] = edge.target_id\n node_dict = {}\n node_dict[\"data\"] = dict\n self.data_list.append(node_dict)\n\n s_node = self.node_map[edge.source_id]\n t_node = self.node_map[edge.target_id]\n self.sif_list.append([s_node.sif_id, t_node.sif_id])\n edge_id += 1","def update_nets_with_segments(pcb_data: List[Dict[str, Any]], nets: List[Net]):\n segments = get_all_dicts_by_key(pcb_data, 'segment')\n for segment in segments:\n start: Coords = get_dict_by_key(segment['segment'], 'start')['start']\n start[1] = str(-1*float(start[1]))\n end: Coords = get_dict_by_key(segment['segment'], 'end')['end']\n end[1] = str(-1 * float(end[1]))\n width: str = get_dict_by_key(segment['segment'], 'width')['width']\n layer_data: str = get_dict_by_key(segment['segment'], 'layer')['layer']\n layers: List[Layer] = convert_to_layers(layer_data)\n new_segment: Segment = Segment(start=start, end=end, width=width, layers=layers)\n net_id: str = get_dict_by_key(segment['segment'], 'net')['net']\n for net in nets:\n if float(net.net_id) == float(net_id):\n net.segments.append(new_segment)","def scc(graph, reverse_graph, nodes):\n\n out = defaultdict(list)\n track = Track()\n dfs_loop(reverse_graph, nodes, track)\n sorted_nodes = sorted(track.finish_time,\n key=track.finish_time.get, reverse=True)\n track.current_time = 0\n track.current_source = None\n track.explored = set()\n dfs_loop(graph, sorted_nodes, track)\n for lead, vertex in groupby(sorted(track.leader, key=track.leader.get),\n key=track.leader.get):\n out[lead] = list(vertex)\n\n return out","def __init__(self,clip_list):\n self.requested_clips=clip_list","def main():\n\n \"\"\"\n nodes, hd3 = erdos_rennie_like(100,8333,5)\n export('d3',hd3)\n\n nodes, hd5 = erdos_rennie_like(100,8333,6)\n export('d5',hd5)\n\n nodes, hd6 = erdos_rennie_like(100,8333,7)\n export('d6',hd6)\n \"\"\"\n\n \"\"\"\n nodes, sparse1 = erdos_rennie_like(600, 1200, 3)\n export('sparse_diag1', sparse1)\n\n nodes, sparse2 = erdos_rennie_like(600, 2400, 3)\n export('sparse_diag2',sparse2)\n\n nodes, sparse3 = erdos_rennie_like(600, 5800, 3)\n export('sparse_diag3',sparse3)\n\n nodes, sparse4 = erdos_rennie_like(600,11600, 3)\n export('sparse_diag4',sparse4)\n\n nodes, sparse5 = erdos_rennie_like(600,23200, 3)\n export('sparse_diag5',sparse5)\n \"\"\"\n\n nodes, size1 = erdos_rennie_like(100, 500, 3)\n nodes, size2 = erdos_rennie_like(200,1000,3)\n nodes,size3 = erdos_rennie_like(300,1500,3)\n nodes,size4 = erdos_rennie_like(400,2000,3)\n nodes,size5 = erdos_rennie_like(500,2500,3)\n\n export('size_diag1',size1)\n export('size_diag2',size2)\n export('size_diag3',size3)\n export('size_diag4',size4)\n export('size_diag5',size5)","def to_swc(self, contributors=\"\"):\n from . import __version__\n sx, sy, sz = np.diag(self.transform)[:3]\n\n swc_header = f\"\"\"# ORIGINAL_SOURCE CloudVolume {__version__}\n# CREATURE \n# REGION\n# FIELD/LAYER\n# TYPE\n# CONTRIBUTOR {contributors}\n# REFERENCE\n# RAW \n# EXTRAS \n# SOMA_AREA\n# SHINKAGE_CORRECTION \n# VERSION_NUMBER {__version__}\n# VERSION_DATE {datetime.datetime.utcnow().isoformat()}\n# SCALE {sx:.6f} {sy:.6f} {sz:.6f}\n\"\"\"\n\n def generate_swc(skel, offset):\n if skel.edges.size == 0:\n return \"\"\n\n index = defaultdict(set)\n visited = defaultdict(bool)\n for e1, e2 in skel.edges:\n index[e1].add(e2)\n index[e2].add(e1)\n\n stack = [ skel.edges[0,0] ]\n parents = [ -1 ]\n\n swc = \"\"\n\n while stack:\n node = stack.pop()\n parent = parents.pop()\n\n if visited[node]:\n continue\n\n swc += \"{n} {T} {x:0.6f} {y:0.6f} {z:0.6f} {R:0.6f} {P}\\n\".format(\n n=(node + 1 + offset),\n T=skel.vertex_types[node],\n x=skel.vertices[node][0],\n y=skel.vertices[node][1],\n z=skel.vertices[node][2],\n R=skel.radii[node],\n P=parent if parent == -1 else (parent + 1 + offset),\n )\n\n visited[node] = True\n \n for child in index[node]:\n stack.append(child)\n parents.append(node)\n\n return swc\n\n skels = self.components()\n\n swc = swc_header + \"\\n\"\n offset = 0\n for skel in skels:\n swc += generate_swc(skel, offset) + \"\\n\"\n offset += skel.vertices.shape[0]\n\n return swc","def makeSubapMap():\n a=numpy.zeros((sum(nsub),),numpy.int32)\n subFlag=subapFlag.copy()\n for i in range(NNGSCAM+NLGSOCAM+NBOBCAT):#ngs 1-3, truth, lgs, lofs, hofs\n tmp=subFlag[nsub[:i].sum():nsub[:i+1].sum()]\n tmp.shape=nsuby[i],nsubx[i]\n if i==NNGSCAM+NLGSOCAM:#lofs\n tmp[:]=sfNoObs*(i+1)\n elif i==1+NNGSCAM+NLGSOCAM:#hofs\n tmp[:]=sf14NoObs*(i+1)\n elif i==NNGSCAM:#lgs\n for j in range(4):\n jj=6-j\n tmp[j*2]=individualSubapFlag[jj]*(i+1)\n if j!=3:\n tmp[j*2+1]=individualSubapFlag[j]*(i+1)\n #jj=7-j\n #if jj<7:\n # tmp[j*2-1]=individualSubapFlag[jj]*(i+1)\n #tmp[j*2]=individualSubapFlag[j]*(i+1)\n else:\n tmp[:]=individualSubapFlag*(i+1)\n return subFlag","def nurbsToSubdiv(*args, addUnderTransform: bool=True, caching: bool=True, collapsePoles:\n bool=False, constructionHistory: bool=True, matchPeriodic: bool=False,\n maxPolyCount: Union[int, bool]=1000, name: AnyStr=\"\", nodeState: Union[int,\n bool]=0, object: bool=True, reverseNormal: bool=True, q=True, query=True,\n e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\n pass","def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\n # get activation for each seperated vc\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\n max_ch_index = max_ch_index.view(-1, L) # n, L\n\n all_activation_vcs = []\n\n for i in range(len(integrate_activation_vc)):\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\n all_activation_vcs.append(integrate_activation_vc_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n print(f\"unique_vc_i {unique_vc_i.shape}\")\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\n activate_vc_i[index_vc_i, :] = 0.\n all_activation_vcs.append(activate_vc_i)\n \n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\n \n # decompose each mask \n all_masks = []\n for i in range(len(sim_map_max)):\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\n all_masks.append(sim_map_max_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\n vc_sim_map_max_i[index_vc_i] = 0.\n all_masks.append(vc_sim_map_max_i)\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\n\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\"\n\n return all_activation_vcs, all_masks","def scoreCirc_CmosVoltageReference(circuit, gen, indi, makeRedundancyInMatrix): #TODO 6.9.2016 napisi cost function ki se sklada z evaluateCmosVoltageRef\n #----------#\n VREF = 1.5\n #----------#\n \n FullBigCircuitMatrix = deepcopy(circuit.fullRedundancyMatrix)\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\n\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\t#(ones/(all/2))\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\n \n results = None\n if OcSc > 1:\n score = 1e4*np.exp(OcSc)\n else:\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\n results = runme2.evaluateCmosVoltageRef(gen, indi)\n disfCount = 0\n \n \n #Vdd sweeps on 3 temperatures - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # -20 deg\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\n vdd_sweep_t1 = np.array(results['vout_vdd_temp1']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_t1)):\n disfCount = disfCount + 1\n vdd_s_t1 = 0\n vdd_s_t1_d = 0\n else:\n x = np.median(vdd_sweep_t1)\n vdd_s_t1 = abs(x - VREF) #if x > VREF else 0\n vdd_s_t1_d = np.max(vdd_sweep_t1) - np.min(vdd_sweep_t1)\n \n \n # 25 deg\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\n vdd_sweep_t2 = np.array(results['vout_vdd_temp2']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_t2)):\n disfCount = disfCount + 1\n vdd_s_t2 = 0\n vdd_s_t2_d = 0\n else:\n x = np.median(vdd_sweep_t2)\n vdd_s_t2 = abs(x - VREF) #if x > VREF else 0\n vdd_s_t2_d = np.max(vdd_sweep_t2) - np.min(vdd_sweep_t2) \n \n # 120 deg\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\n vdd_sweep_t3 = np.array(results['vout_vdd_temp3']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_t3)):\n disfCount = disfCount + 1\n vdd_s_t3 = 0\n vdd_s_t3_d = 0\n else:\n x = np.median(vdd_sweep_t3)\n vdd_s_t3 = abs(x - VREF) #if x > VREF else 0\n vdd_s_t3_d = np.max(vdd_sweep_t3) - np.min(vdd_sweep_t3) \n \n #Vdd sweeps on 3 loads - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # 10e6 Ohm\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\n vdd_sweep_r1 = np.array(results['vout_vdd_res1']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_r1)):\n disfCount = disfCount + 1\n vdd_s_r1 = 0\n vdd_s_r1_d = 0\n else:\n x = np.median(vdd_sweep_r1)\n vdd_s_r1 = abs(x - VREF) #if x > VREF else 0\n vdd_s_r1_d = np.max(vdd_sweep_r1) - np.min(vdd_sweep_r1)\n \n # 10e4 Ohm\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\n vdd_sweep_r2 = np.array(results['vout_vdd_res2']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_r2)):\n disfCount = disfCount + 1\n vdd_s_r2 = 0\n vdd_s_r2_d = 0\n else:\n x = np.median(vdd_sweep_r2)\n vdd_s_r2 = abs(x - VREF) #if x > VREF else 0\n vdd_s_r2_d = np.max(vdd_sweep_r2) - np.min(vdd_sweep_r2) \n \n # 10e2 Ohm\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\n vdd_sweep_r3 = np.array(results['vout_vdd_res3']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_r3)):\n disfCount = disfCount + 1\n vdd_s_r3 = 0\n vdd_s_r3_d = 0\n else:\n x = np.median(vdd_sweep_r3)\n vdd_s_r3 = abs(x - VREF) #if x > VREF else 0\n vdd_s_r3_d = np.max(vdd_sweep_r3) - np.min(vdd_sweep_r3) \n \n power = results['power']['nominal']\n if np.isnan(np.array(power, dtype=float)):\n disfCount = disfCount + 1\n powe = 0\n else:\n powe = power\n \n #---COST FUNCTION DEFINITION---#\n score = vdd_s_t1 + vdd_s_t1_d + \\\n\t vdd_s_t2 + vdd_s_t2_d + \\\n\t vdd_s_t3 + vdd_s_t3_d + \\\n\t vdd_s_r1 + vdd_s_r1_d + \\\n\t vdd_s_r2 + vdd_s_r2_d + \\\n\t vdd_s_r3 + vdd_s_r3_d + \\\n\t (100*powe)\n\n #print disfCount\n if disfCount > 0:\n score = np.exp(disfCount) * 1e3\n if np.isnan(score):\n score = 2e4\n score = score + (IcNc+1) #add small punishment if not all nodes connected\n\n #print \"\\t\\t\\t\\t\\tG_\" + str(gen) + \"_I_\" + str(indi) + \" SCORE:\", score\n \n filename = \"g_\" + str(gen) + \"_i_\" + str(indi) + \"_subckt.cir\"\n os.remove(filename) #cleanup current subcircuit\n\n return score, matrixDensity, matrixQuaziID, results","def build_splines(self, nsc, alpha=0.05, initial_beta=1.5):\n pass","def TNFR1_to_SecondaryComplex_Alternate():\n \n Parameter('TNFa_0' , 000) # 6000 corresponds to 100ng/ml TNFa\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\n Parameter('CompI_0' , 0) # complexes per cell\n Parameter('NFkB_0' , 0) # molecules per cell\n alias_model_components()\n \n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'unmod'), RIP1_0) # RIP1\n Initial(NFkB(bf=None), NFkB_0)\n \n # =========================================\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\n # -----------------------------------------\n # TNFa+ TNFR1 <-> TNFa:TNFR1\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\n \n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\n # [active]CompI:RIP1 >> [active]CompI + RIP1\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\n \n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\n \n # ------------------------------------------\n \n # -------------Complex I assembly----------------\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\n \n # --------------Complex I - RIP1 Modification-----------------\n # Complex I recruits RIP1\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\n #bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\n \n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\n #Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1))\n \n # De-ubiquitination and degradation or release of RIP1 from complex I\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='deub'), Parameter('k6',1e-3))\n \n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\n \n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'deub'), 'bDD', [1e-10,1])\n \n # Receptor recycle\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1e-3))\n \n # --------------RIP1 Ubiquitination---------------------------\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))","def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\n #Read in the image that is segmented/labelled for nuclei\n img=imread(img_dir)\n\n #save plots to show clusters\n fig = plt.figure(figsize=(6, 2))\n ax0 = fig.add_subplot(131)\n ax1 = fig.add_subplot(132)\n ax3 = fig.add_subplot(133)\n #show segmented image labels\n ax0.imshow(img,aspect='auto') \n ax0.axis('off')\n #nuclear centroid color-coded by their orientation\n img1=ax1.scatter(data[\"Y\"], data[\"X\"], c=data[\"angles\"],s=1)\n ax1.set_xlim(0,img.shape[0])\n ax1.set_ylim(img.shape[1],0)\n plt.colorbar(img1)\n ax1.axis('off')\n\n # plot the cluster assignments\n img3=ax3.scatter(data[data[\"clusters\"]> -1][\"Y\"], data[data[\"clusters\"]> -1][\"X\"], \n c=data[data[\"clusters\"]> -1][\"clusters\"],cmap=\"plasma\",s=1)\n ax3.set_xlim(0,img.shape[0])\n ax3.set_ylim(img.shape[1],0)\n ax3.axis('off')\n\n #add titles\n ax0.title.set_text('Segmented Image')\n ax1.title.set_text('Filtered Orientation')\n ax3.title.set_text('Clusters')\n\n if display_not_save:\n plt.show()\n else: \n plt.savefig((output_dir+\"/\"+img_dir.rsplit('/', 1)[-1][:-4]+\"_\"+str(dbscn_length)+\"_\"+ str(dbscn_min_size)+\".png\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\n fig.clf()\n plt.close(fig)\n plt.close('all')\n \n \n del fig,ax0,ax1,ax3,img1,img3","def initialize(self, simplified_circuit_list, numSubTreeComms=1, maxCacheSize=None):\n #tStart = _time.time() #DEBUG TIMER\n\n # opLabels : A list of all the distinct operation labels found in\n # simplified_circuit_list. Used in calc classes\n # as a convenient precomputed quantity.\n self.opLabels = self._get_opLabels(simplified_circuit_list)\n if numSubTreeComms is not None:\n self.distribution['numSubtreeComms'] = numSubTreeComms\n\n circuit_list = [tuple(mdl) for mdl in simplified_circuit_list.keys()]\n self.simplified_circuit_spamTuples = list(simplified_circuit_list.values())\n self.num_final_els = sum([len(v) for v in self.simplified_circuit_spamTuples])\n #self._compute_finalStringToEls() #depends on simplified_circuit_spamTuples\n self.recompute_spamtuple_indices(bLocal=True) # bLocal shouldn't matter here\n\n #Evaluation tree:\n # A list of tuples, where each element contains\n # information about evaluating a particular operation sequence:\n # (iStart, tuple_of_following_gatelabels )\n # and self.eval_order specifies the evaluation order.\n del self[:] # clear self (a list)\n\n #Final Indices\n # The first len(circuit_list) elements of the tree correspond\n # to computing the operation sequences requested in circuit_list. Doing\n # this make later extraction much easier (views can be used), but\n # requires a non-linear order of evaluation, held in the eval_order list.\n self.eval_order = []\n\n #initialize self as a list of Nones\n self.num_final_strs = len(circuit_list)\n self[:] = [None] * self.num_final_strs\n\n #Sort the operation sequences \"alphabetically\", so that it's trivial to find common prefixes\n sorted_strs = sorted(list(enumerate(circuit_list)), key=lambda x: x[1])\n\n #DEBUG\n #print(\"SORTED\"); print(\"\\n\".join(map(str,sorted_strs)))\n\n #PASS1: figure out what's worth keeping in the cache:\n if maxCacheSize is None or maxCacheSize > 0:\n curCacheSize = 0\n cacheIndices = [] # indices into circuit_list/self of the strings to cache\n dummy_self = [None] * self.num_final_strs; cache_hits = {}\n for k, (iStr, circuit) in enumerate(sorted_strs):\n L = len(circuit)\n for i in range(curCacheSize - 1, -1, -1): # from curCacheSize-1 -> 0\n candidate = circuit_list[cacheIndices[i]]\n Lc = len(candidate)\n if L >= Lc > 0 and circuit[0:Lc] == candidate:\n iStart = i\n remaining = circuit[Lc:]\n if iStr in cache_hits: cache_hits[cacheIndices[i]] += 1 # tally cache hit\n else: cache_hits[cacheIndices[i]] = 1 # TODO: use default dict?\n break\n else: # no break => no prefix\n iStart = None\n remaining = circuit[:]\n\n cacheIndices.append(iStr)\n iCache = curCacheSize\n curCacheSize += 1; assert(len(cacheIndices) == curCacheSize)\n dummy_self[iStr] = (iStart, remaining, iCache)\n\n #PASS #2: for real this time: construct tree but only cache items w/hits\n curCacheSize = 0\n cacheIndices = [] # indices into circuit_list/self of the strings to cache\n # (store persistently as prefixes of other string -- this need not be all\n # of the strings in the tree)\n\n for k, (iStr, circuit) in enumerate(sorted_strs):\n L = len(circuit)\n\n #find longest existing prefix for circuit by working backwards\n # and finding the first string that *is* a prefix of this string\n # (this will necessarily be the longest prefix, given the sorting)\n for i in range(curCacheSize - 1, -1, -1): # from curCacheSize-1 -> 0\n candidate = circuit_list[cacheIndices[i]]\n Lc = len(candidate)\n if L >= Lc > 0 and circuit[0:Lc] == candidate: # \">=\" allows for duplicates\n iStart = i # NOTE: this is an index into the *cache*, not necessarily self\n remaining = circuit[Lc:]\n break\n else: # no break => no prefix\n iStart = None\n remaining = circuit[:]\n\n # if/where this string should get stored in the cache\n if (maxCacheSize is None or curCacheSize < maxCacheSize) and cache_hits.get(iStr, 0) > 0:\n cacheIndices.append(iStr)\n iCache = curCacheSize\n curCacheSize += 1; assert(len(cacheIndices) == curCacheSize)\n else: # don't store in the cache\n iCache = None\n\n #Add info for this string\n self[iStr] = (iStart, remaining, iCache)\n self.eval_order.append(iStr)\n\n #FUTURE: could perform a second pass, and if there is\n # some threshold number of elements which share the\n # *same* iStart and the same beginning of the\n # 'remaining' part then add a new \"extra\" element\n # (beyond the #circuits index) which computes\n # the shared prefix and insert this into the eval\n # order.\n\n self.cachesize = curCacheSize\n self.myFinalToParentFinalMap = None # this tree has no \"children\",\n self.myFinalElsToParentFinalElsMap = None # i.e. has not been created by a 'split'\n self.parentIndexMap = None\n self.original_index_lookup = None\n self.subTrees = [] # no subtrees yet\n assert(self.generate_circuit_list() == circuit_list)\n assert(None not in circuit_list)","def __init__(self, dcs, suppliers, neighbor_threshold):\n\n nodes = []\n locations = dcs + suppliers\n total_space = sum([dc.max_cube for dc in dcs])\n for loc in locations:\n weight = 0\n if type(loc) == DistributionCenter:\n weight = loc.max_cube / total_space\n node = Node(loc, weight)\n nodes.append(node)\n\n for node1 in nodes:\n for node2 in nodes:\n if node1 != node2:\n if type(node1.location) == Supplier and type(node2.location) == DistributionCenter:\n node1.neighbors.append(node2)\n elif type(node1.location) == DistributionCenter and type(node2.location) == Supplier:\n node1.neighbors.append(node2)\n elif type(node1.location) == DistributionCenter and type(node2.location) == DistributionCenter:\n if node1.location.distance(node2.location) < neighbor_threshold:\n node1.neighbors.append(node2)\n\n self.nodes = {n.location.id: n for n in nodes}"],"string":"[\n \"def GetMatchedSubContourListsCollapsing(scListA, scListB):\\n\\n if (\\n scListA == scListB\\n ): # if we got the same object for some reason, just return 2 shallow clones\\n return scListA, scListB\\n\\n scsMatchedInB = [] # This keeps us from looping over both lists\\n\\n scsMatchedInB, removeFromA, removeFromB = FindMatchesAndRemovals(scListA, scListB)\\n unMatchedInB = [\\n i for i in range(len(scListB)) if i not in scsMatchedInB\\n ] # This lets us skip the indexes that already matched\\n\\n _, removeFromB_2, removeFromA_2 = FindMatchesAndRemovals(\\n scListB, scListA, searchInds=unMatchedInB\\n ) # FLIP\\n\\n removeFromA = sorted(list(set(removeFromA + removeFromA_2)))\\n removeFromB = sorted(list(set(removeFromB + removeFromB_2)))\\n\\n scListANew = deepcopy(scListA)\\n scListBNew = deepcopy(scListB)\\n\\n for i in removeFromA[::-1]:\\n RemoveSubContour(scListA, i)\\n for i in removeFromB[::-1]:\\n RemoveSubContour(scListB, i)\\n\\n return scListANew, scListBNew\",\n \"def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\\n # number of nodes\\n nx = 5 # along x\\n ny = 5 # along y\\n\\n # getting integration points\\n nint = 4\\n points, weights = get_points_weights(nint=nint)\\n\\n # geometry\\n a = 3 # along x\\n b = 3 # along y\\n\\n # material properties\\n E = 200e9\\n nu = 0.3\\n laminaprop = (E, E, nu)\\n stack = [0]\\n h = 0.001\\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\\n\\n # creating mesh\\n x = np.linspace(0, a, nx)\\n y = np.linspace(0, b, ny)\\n xmesh, ymesh = np.meshgrid(x, y)\\n\\n # node coordinates and position in the global matrix\\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\\n nids = 1 + np.arange(ncoords.shape[0])\\n nid_pos = dict(zip(nids, np.arange(len(nids))))\\n\\n # identifying nodal connectivity for plate elements\\n # similar than Nastran's CQUAD4\\n #\\n # ^ y\\n # |\\n #\\n # 4 ________ 3\\n # | |\\n # | | --> x\\n # | |\\n # |_______|\\n # 1 2\\n\\n\\n nids_mesh = nids.reshape(nx, ny)\\n n1s = nids_mesh[:-1, :-1].flatten()\\n n2s = nids_mesh[1:, :-1].flatten()\\n n3s = nids_mesh[1:, 1:].flatten()\\n n4s = nids_mesh[:-1, 1:].flatten()\\n\\n num_elements = len(n1s)\\n print('num_elements', num_elements)\\n\\n N = DOF*nx*ny\\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n init_k_KC0 = 0\\n init_k_KG = 0\\n\\n plates = []\\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\\n plate = BFSPlate2D()\\n plate.n1 = n1\\n plate.n2 = n2\\n plate.n3 = n3\\n plate.n4 = n4\\n plate.c1 = DOF*nid_pos[n1]\\n plate.c2 = DOF*nid_pos[n2]\\n plate.c3 = DOF*nid_pos[n3]\\n plate.c4 = DOF*nid_pos[n4]\\n plate.ABD = lam.ABD\\n plate.lex = a/(nx - 1)\\n plate.ley = b/(ny - 1)\\n plate.init_k_KC0 = init_k_KC0\\n plate.init_k_KG = init_k_KG\\n update_KC0(plate, points, weights, Kr, Kc, Kv)\\n init_k_KC0 += KC0_SPARSE_SIZE\\n init_k_KG += KG_SPARSE_SIZE\\n plates.append(plate)\\n\\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\\n\\n # applying boundary conditions\\n\\n # locating nodes\\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\\n\\n x = ncoords[:, 0]\\n y = ncoords[:, 1]\\n\\n # applying boundary conditions\\n # simply supported\\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\\n bk[2::DOF] = check\\n check = isclose(x, 0) | isclose(x, a)\\n bk[3::DOF] = check\\n # point supports\\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\\n bk[0::DOF] = check\\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\\n bk[1::DOF] = check\\n\\n # unconstrained nodes\\n bu = ~bk # logical_not\\n\\n # defining external force vector\\n fext = np.zeros(KC0.shape[0], dtype=float)\\n\\n # applying unitary load along u at x=a\\n # nodes at vertices get 1/2 the force\\n for plate in plates:\\n pos1 = nid_pos[plate.n1]\\n pos2 = nid_pos[plate.n2]\\n pos3 = nid_pos[plate.n3]\\n pos4 = nid_pos[plate.n4]\\n if isclose(x[pos3], a):\\n Nxx = -1\\n xi = +1\\n elif isclose(x[pos1], 0):\\n Nxx = +1\\n xi = -1\\n else:\\n continue\\n lex = plate.lex\\n ley = plate.ley\\n indices = []\\n c1 = DOF*pos1\\n c2 = DOF*pos2\\n c3 = DOF*pos3\\n c4 = DOF*pos4\\n cs = [c1, c2, c3, c4]\\n for ci in cs:\\n for i in range(DOF):\\n indices.append(ci + i)\\n fe = np.zeros(4*DOF, dtype=float)\\n for j in range(nint):\\n eta = points[j]\\n plate.update_Nu(xi, eta)\\n Nu = np.asarray(plate.Nu)\\n fe += ley/2*weights[j]*Nu*Nxx\\n fext[indices] += fe\\n\\n Kuu = KC0[bu, :][:, bu]\\n fextu = fext[bu]\\n\\n # static solver\\n uu = spsolve(Kuu, fextu)\\n u = np.zeros(KC0.shape[0], dtype=float)\\n u[bu] = uu\\n\\n if plot_static:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n uplot = u[0::DOF].reshape(nx, ny).T\\n vplot = u[1::DOF].reshape(nx, ny).T\\n print('u extremes', uplot.min(), uplot.max())\\n print('v extremes', vplot.min(), vplot.max())\\n levels = np.linspace(uplot.min(), uplot.max(), 300)\\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n # eigenvalue solver\\n\\n # getting integration points\\n for plate in plates:\\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\\n KGuu = KG[bu, :][:, bu]\\n\\n # solving modified generalized eigenvalue problem\\n # Original: (KC0 + lambda*KG)*v = 0\\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\\n num_eigenvalues = 5\\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\\n tol=1e-6, sigma=1., mode='cayley')\\n eigvals = -1./eigvals\\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\\n eigvecs[bu, :] = eigvecsu\\n\\n if plot_lb:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n mode = 0\\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\\n levels = np.linspace(wplot.min(), wplot.max(), 300)\\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\\n assert isclose(kc, 6.6, rtol=0.05)\",\n \"def construct_network(self):\\n r = 0\\n n = self.nbr_0_splxs\\n for k in range(n):\\n self.splxs.append((0, (0, k)))\\n self.nbr_splxs += 1\\n r, edge = self.find_next_edge(r)\\n # this while loop finds the new edge to treat and add it to the 1-splx list and then finds out if a 2-splx is created\\n while edge != (-1, -1):\\n # Add the new edge\\n self.one_splxs.append((edge, self.nbr_splxs))\\n self.splxs.append((1, self.nbr_1_splxs))\\n self.nbr_1_splxs += 1\\n self.nbr_splxs += 1\\n self.dist_appearance.append(r)\\n a, b = edge\\n # find out if a 2-splx has been created\\n for i in range(self.nbr_1_splxs - 1):\\n c, d = self.one_splxs[i][0]\\n if d == a:\\n for j in range(i + 1, self.nbr_1_splxs - 1):\\n e, f = self.one_splxs[j][0]\\n if e == c and f == b:\\n self.two_splxs.append((self.nbr_1_splxs - 1, i, j))\\n self.splxs.append((2, self.nbr_2_splxs))\\n self.nbr_2_splxs += 1\\n self.nbr_splxs += 1\\n self.dist_appearance.append(r)\\n # find the next edge to treat\\n r, edge = self.find_next_edge(r)\\n print(\\\"Network created\\\")\\n return ()\",\n \"def build_csls_subgraphs(self):\\n # Graph for calculating only score\\n scores_s2t = self.build_eval_graph(\\n \\\"ScoreS2T\\\", self.src_ten, self.tgt_ten, en_knn=False, en_mean=False\\n )\\n scores_t2s = self.build_eval_graph(\\n \\\"ScoreT2S\\\", self.tgt_ten, self.src_ten, en_knn=False, en_mean=False\\n )\\n # Graphs for calculating average between source and target\\n avg1_s2t = self.build_eval_graph(\\\"Avg1\\\", self.src_ten, self.tgt_ten, knn=10)\\n avg2_s2t = self.build_eval_graph(\\\"Avg2\\\", self.tgt_ten, self.src_ten, knn=10)\\n # Graph for selecting top 100 elements\\n top100_matches = tf.nn.top_k(self.score_ph, 100)\\n # Graph for selecting top 2 elements\\n top2_matches = tf.nn.top_k(self.score_ph, 2)\\n # Graph for calculating similarity\\n csls_mean_score = self.build_sim_graph(\\\"SimGraph\\\")\\n\\n # Dictionary\\n csls_graphs = {\\n \\\"ScoreGraph\\\": scores_s2t,\\n \\\"ScoreG_T2S\\\": scores_t2s,\\n \\\"Avg1S2T\\\": avg1_s2t,\\n \\\"Avg2S2T\\\": avg2_s2t,\\n \\\"Top100\\\": top100_matches,\\n \\\"Top2\\\": top2_matches,\\n \\\"CSLS_Criteria\\\": csls_mean_score,\\n }\\n return csls_graphs\",\n \"def __init__(self,\\n name,\\n vertices_location,\\n connectivity,\\n connectivity_ids=None,\\n connectivity_label=None,\\n connectivity_label_metadata=None,\\n connectivity_colormap = None,\\n connector_size=2.6,\\n global_deselect_alpha=0.2,\\n global_select_alpha=1.0,\\n skeleton_linewidth=2.0):\\n super(Microcircuit, self).__init__( name )\\n\\n if not connectivity_ids is None:\\n self.connectivity_ids = connectivity_ids\\n\\n if not connectivity_label is None:\\n self.connectivity_labels = connectivity_label\\n\\n if not connectivity_label_metadata is None:\\n\\n for semanticdict in connectivity_label_metadata:\\n # name needs to be based on convention, TODO: best from ontology id rather than string!\\n # TODO: use microcircuit convention\\n if semanticdict.has_key(\\\"name\\\"):\\n name = semanticdict[\\\"name\\\"]\\n if \\\"skeleton\\\" in name:\\n self.con_skeleton = int(semanticdict[\\\"value\\\"])\\n elif \\\"presynaptic\\\" in name:\\n self.con_pre = int(semanticdict[\\\"value\\\"])\\n elif \\\"postsynaptic\\\" in name:\\n self.con_post = int(semanticdict[\\\"value\\\"])\\n\\n else:\\n # TODO: default\\n self.con_skeleton = 1\\n self.con_pre = 2\\n self.con_post = 3\\n\\n # selection stores integer ids from connectivity_selectionID\\n # when selected\\n self.skeleton_selection = []\\n\\n # use the connectivity labels to extract the connectivity for the skeletons\\n self.index_skeleton = np.where(self.connectivity_labels == self.con_skeleton)[0]\\n self.index_allpre = np.where(self.connectivity_labels == self.con_pre)[0]\\n self.index_allpost = np.where(self.connectivity_labels == self.con_post)[0]\\n \\n self.vertices = vertices_location\\n self.connectivity = connectivity\\n\\n connectivity_skeleton = self.connectivity[self.index_skeleton]\\n self.vertices_skeleton = self.vertices[ connectivity_skeleton.ravel() ]\\n \\n # we have a simplified connectivity now\\n self.connectivity_skeleton = np.array( range(len(self.vertices_skeleton)), dtype = np.uint32 )\\n self.connectivity_skeleton = self.connectivity_skeleton.reshape( (len(self.connectivity_skeleton)/2, 2) )\\n self.connectivity_ids_skeleton = self.connectivity_ids[ self.index_skeleton ]\\n\\n # look up the start and end vertex id\\n # map these to _skeleton arrays, and further to actor???\\n\\n # colors for skeletons\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_skeleton ):\\n self.connectivity_skeleton_colors = np.repeat(connectivity_colormap[self.con_skeleton], len(self.connectivity_skeleton), axis=0).astype( np.float32 )\\n\\n ##########\\n # Incoming connectors\\n ##########\\n\\n # extract the pre connectivity and create cones\\n # store the indices for to be used to create the vector scatter\\n # by itself, it represent implicitly the index used to select/deselect the vectors\\n if len(self.index_allpre) == 0:\\n if DEBUG:\\n print \\\"no presynaptic connection\\\"\\n self.pre_actor = None\\n else:\\n self.vertices_pre = self.vertices[ connectivity[self.index_allpre].ravel() ]\\n self.pre_p1 = self.vertices_pre[::2, :] # data is NOT copied here\\n self.pre_p2 = self.vertices_pre[1::2, :]\\n pren = len(self.index_allpre)\\n r1 = np.ones( pren, dtype = np.float32 ) * connector_size\\n r2 = np.zeros( pren, dtype = np.float32 )\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_pre ):\\n preval = np.ones( pren, dtype = np.dtype(type(self.con_pre)) ) * self.con_pre\\n else:\\n preval = None\\n self.pre_actor = VectorScatter( \\\"PreConnector\\\", self.pre_p1, self.pre_p2, r1, r2, values = preval,\\n resolution = 8, colormap = connectivity_colormap )\\n # len(self.index_pre) = len(self.pre_p1) = len(preval)\\n\\n ##########\\n # Outgoing connectors\\n ##########\\n\\n # extract the post connectivity and create cones\\n if len(self.index_allpost) == 0:\\n if DEBUG:\\n print \\\"no postsynaptic connection\\\"\\n self.post_actor = None\\n else:\\n self.vertices_post = self.vertices[ connectivity[self.index_allpost].ravel() ]\\n self.post_p1 = self.vertices_post[::2, :]\\n self.post_p2 = self.vertices_post[1::2, :]\\n postn = len(self.index_allpost)\\n r1 = np.zeros( postn, dtype = np.float32 )\\n r2 = np.ones( postn, dtype = np.float32 ) * connector_size\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_post ):\\n postval = np.ones( postn, dtype = np.dtype(type(self.con_post)) ) * self.con_post\\n else:\\n postval = None\\n self.post_actor = VectorScatter( \\\"PostConnector\\\", self.post_p1, self.post_p2, r1, r2, values = postval,\\n resolution = 8, colormap = connectivity_colormap )\\n\\n ##########\\n # Skeletons\\n ##########\\n self.skeleton = Skeleton( name = \\\"Polygon Lines\\\",\\n vertices = self.vertices_skeleton,\\n connectivity = self.connectivity_skeleton,\\n connectivity_colors = self.connectivity_skeleton_colors,\\n connectivity_ID = self.connectivity_ids_skeleton,\\n linewidth = skeleton_linewidth,\\n global_deselect_alpha = global_deselect_alpha,\\n global_select_alpha = global_select_alpha )\\n\\n self.connectivity_skeletononly_ids = None\\n self.connectivity_preonly_ids = None\\n self.connectivity_postonly_ids = None\\n\\n self.global_deselect_alpha = global_deselect_alpha\\n self.global_select_alpha = global_select_alpha\",\n \"def sub_graph_merging(self):\",\n \"def LimitPointsBetweenSubContourNodes(scList, numInteriorPointsDict, interpolate=True):\\n limIntPtsFunc = (\\n limitInteriorPointsInterpolating if interpolate else limitInteriorPoints\\n )\\n for sc in scList:\\n sc.points = limIntPtsFunc(sc.points, numInteriorPointsDict[tuple(sc.values)])\",\n \"def sweep_CPPN(genotype, E1, subp_1, subp_2, norm_in, canvas):\\n\\n\\t# get value from widget field\\n\\tinnov_num = E1.get()\\n\\n\\t# find index of desired connection\\n\\tindex = -1\\n\\tfor con_ind in range(len(genotype.connections)):\\n\\t\\tif(genotype.connections[con_ind].getInnovationNumber() == innov_num):\\n\\t\\t\\tindex = con_ind\\n\\told_weight = genotype.connections[con_ind].getWeight()\\n\\n\\tsweep_weight = 10\\n\\twhile(sweep_weight > -10):\\n\\t\\tgenotype.connections[con_ind].setWeight(sweep_weight)\\n\\t\\t# clear both subplots so new graphs can be placed into the GUI\\n\\t\\tsubp_1.clear()\\n\\t\\tsubp_2.clear()\\n\\n\\t\\t# create graphs again and put graphs onto them\\n\\t\\toutputs = []\\n\\t\\tfor ins in norm_in:\\n\\t\\t\\toutputs.append(genotype.getOutput(ins)[0])\\n\\t\\toutputs_np = np.array(outputs, copy=True)\\n\\t\\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\\n\\n\\t\\tgraph_genotype_GUI(genotype, subp_2)\\n\\n\\t\\tcanvas.show()\\n\\t\\tcanvas.get_tk_widget().pack()\\n\\t\\tsweep_weight -= .5\\n\\t\\ttime.sleep(TIME_DELAY)\\n\\n\\t# reset the graphs to their old state with the original weight\\n\\tgenotype.connections[con_ind].setWeight(old_weight)\\n\\t# clear both subplots so new graphs can be placed into the GUI\\n\\tsubp_1.clear()\\n\\tsubp_2.clear()\\n\\n\\t# create graphs again and put graphs onto them\\n\\toutputs = []\\n\\tfor ins in norm_in:\\n\\t\\toutputs.append(genotype.getOutput(ins)[0])\\n\\toutputs_np = np.array(outputs, copy=True)\\n\\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\\n\\n\\tgraph_genotype_GUI(genotype, subp_2)\\n\\n\\tcanvas.show()\\n\\tcanvas.get_tk_widget().pack()\",\n \"def connect_synfluct(self, PF_BG_rate=6, PF_BG_cv=1, STL_BG_rate=20, STL_BG_cv=1):\\n \\n if self.do_run:\\n \\n for m in self.ST_stims:\\n del m \\n del self.ST_stims\\n \\n for m in self.PF_stims:\\n del m \\n del self.PF_stims\\n \\n self.ST_stims = []\\n self.PF_stims = []\\n \\n \\n for n in range(self.n_celltypes):\\n \\n for i, gid in enumerate(self.gidlist[n]): # for every cell in the gidlist \\n \\n PF_syn_list = self.cells[n][i].createsyn_PF()\\n \\n for d in PF_syn_list:\\n d.input.newnetstim.number = 1e9\\n d.input.newnetstim.noise = PF_BG_cv\\n d.input.newnetstim.interval = 1000.0 / PF_BG_rate\\n d.input.newnetstim.start = 0\\n \\n self.PF_stims.append(PF_syn_list)\\n \\n ST_stim_list = self.cells[n][i].createsyn_ST(record_all=0)\\n\\n for d in ST_stim_list:\\n d.newnetstim.number = 1e9\\n d.newnetstim.noise = STL_BG_cv\\n d.newnetstim.interval = 1000.0 / STL_BG_rate\\n d.newnetstim.start = 0\\n \\n self.ST_stims.append(ST_stim_list)\\n \\n if self.id == 0: print \\\"- PF and ST stimulation added.\\\"\",\n \"def test_construct_subcircuit_layers(self):\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=3)\\r\\n\\r\\n def circuit(params):\\r\\n # section 1\\r\\n qml.RX(params[0], wires=0)\\r\\n # section 2\\r\\n qml.RY(params[1], wires=0)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n # section 3\\r\\n qml.RX(params[2], wires=0)\\r\\n qml.RY(params[3], wires=1)\\r\\n qml.RZ(params[4], wires=2)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n # section 4\\r\\n qml.RX(params[5], wires=0)\\r\\n qml.RY(params[6], wires=1)\\r\\n qml.RZ(params[7], wires=2)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n return qml.expval(qml.PauliX(0)), qml.expval(qml.PauliX(1)), qml.expval(qml.PauliX(2))\\r\\n\\r\\n circuit = qml.QNode(circuit, dev)\\r\\n\\r\\n params = np.ones([8])\\r\\n tapes = circuit.metric_tensor(params, only_construct=True)\\r\\n\\r\\n # this circuit should split into 4 independent\\r\\n # sections or layers when constructing subcircuits\\r\\n assert len(tapes) == 4\\r\\n\\r\\n # first layer subcircuit\\r\\n assert len(tapes[0].operations) == 1\\r\\n assert isinstance(tapes[0].operations[0], qml.Hadamard) # PauliX decomp\\r\\n\\r\\n # second layer subcircuit\\r\\n assert len(tapes[1].operations) == 4\\r\\n assert isinstance(tapes[1].operations[0], qml.RX)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\\r\\n assert isinstance(tapes[1].operations[2], qml.S)\\r\\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\\r\\n\\r\\n # # third layer subcircuit\\r\\n assert len(tapes[2].operations) == 8\\r\\n assert isinstance(tapes[2].operations[0], qml.RX)\\r\\n assert isinstance(tapes[2].operations[1], qml.RY)\\r\\n assert isinstance(tapes[2].operations[2], qml.CNOT)\\r\\n assert isinstance(tapes[2].operations[3], qml.CNOT)\\r\\n # PauliX decomp\\r\\n assert isinstance(tapes[2].operations[4], qml.Hadamard)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[2].operations[5], qml.PauliZ)\\r\\n assert isinstance(tapes[2].operations[6], qml.S)\\r\\n assert isinstance(tapes[2].operations[7], qml.Hadamard)\\r\\n\\r\\n # # fourth layer subcircuit\\r\\n assert len(tapes[3].operations) == 13\\r\\n assert isinstance(tapes[3].operations[0], qml.RX)\\r\\n assert isinstance(tapes[3].operations[1], qml.RY)\\r\\n assert isinstance(tapes[3].operations[2], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[3], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[4], qml.RX)\\r\\n assert isinstance(tapes[3].operations[5], qml.RY)\\r\\n assert isinstance(tapes[3].operations[6], qml.RZ)\\r\\n assert isinstance(tapes[3].operations[7], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[8], qml.CNOT)\\r\\n # PauliX decomp\\r\\n assert isinstance(tapes[3].operations[9], qml.Hadamard)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[3].operations[10], qml.PauliZ)\\r\\n assert isinstance(tapes[3].operations[11], qml.S)\\r\\n assert isinstance(tapes[3].operations[12], qml.Hadamard)\",\n \"def osnc(pl, refnd):\\n return [refnd[i] for i in pl]\",\n \"def subCruise(self, footprints):\\n sub = Cruise()\\n sub.V = [v for v in self.V if v.uid in footprints]\\n sub.E = []\\n sub.neighbours = {}\\n sub.resorts = {}\\n for key, value in self.neighbours.items():\\n sub.neighbours[key] = []\\n if key in footprints:\\n sub.V.extend([self.V[v] for v in value if self.V[v] not in sub.V])\\n sub.E.extend([(key, v) for v in value])\\n sub.neighbours.get(key).extend(value)\\n for v in value:\\n sub.neighbours[v] = [key]\\n\\n p = set(sub.V)\\n #sorted_resorts = sorted(self.resorts, key=len, reverse=True)\\n for key, resort in self.resorts.items():\\n s = set(resort.footprints)\\n if len(tuple(s & p)) > 0:\\n sub.resorts[key] = Resort(list(tuple(s & p)))\\n p -= s\\n if len(tuple(p)) == 0:\\n break\\n\\n addresstamp = reduce(lambda x, y: x + y, [v.addresstamp for v in sub.V])\\n sub.upperleft = list(map(min, zip(*addresstamp)))\\n sub.bottomright = list(map(max, zip(*addresstamp)))\\n sub.upperright = [sub.bottomright[0], sub.upperleft[1]]\\n sub.bottomleft = [sub.upperleft[0], sub.bottomright[1]]\\n (sub.W, sub.H) = (sub.upperright[0] - sub.bottomleft[0], sub.bottomleft[1] - sub.upperright[1])\\n sub.grid = self.grid[np.ix_(list(range(sub.upperleft[1],sub.bottomleft[1])), list(range(sub.upperleft[0],sub.bottomright[0])))]\\n\\n assert sub.W >= 0\\n assert sub.H >= 0\\n return sub\",\n \"def generate_connectivity_constraint(problem, b_list, add_S):\\n\\n # Constructing A_iq and b_iq for inequality (38) for all S in add_S as sp.coo matrix\\n A_iq_row = []\\n A_iq_col = []\\n A_iq_data = []\\n\\n constraint_idx = 0\\n # For each base\\n for b, S_v_t in product(b_list, add_S):\\n pre_S_transition = problem.graph.pre_tran_vt(S_v_t)\\n pre_S_connectivity = problem.graph.pre_conn_vt(S_v_t)\\n for v, t in S_v_t:\\n # add y\\n A_iq_row.append(constraint_idx)\\n A_iq_col.append(problem.get_yb_idx(b, v, t))\\n A_iq_data.append(1)\\n for v0, v1, t0 in pre_S_transition:\\n A_iq_row.append(constraint_idx)\\n A_iq_col.append(problem.get_x_idx(b, v0, v1, t0))\\n A_iq_data.append(-1)\\n for v0, v1, t1 in pre_S_connectivity:\\n A_iq_row.append(constraint_idx)\\n A_iq_col.append(problem.get_xbar_idx(b, v0, v1, t1))\\n A_iq_data.append(-1)\\n constraint_idx += 1\\n A_iq_38 = sp.coo_matrix(\\n (A_iq_data, (A_iq_row, A_iq_col)), shape=(constraint_idx, problem.num_vars)\\n )\\n\\n return Constraint(A_iq=A_iq_38, b_iq=np.zeros(constraint_idx))\",\n \"def cfdProcessElementTopology(self):\\r\\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \\r\\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\\r\\n\\r\\n ## (list of lists) list of face indices forming each element\\r\\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n #populates self.elementNeighbours\\r\\n for iFace in range(self.numberOfInteriorFaces):\\r\\n own=self.owners[iFace]\\r\\n nei=self.neighbours[iFace]\\r\\n \\r\\n #adds indices of neighbour cells\\r\\n self.elementNeighbours[own].append(nei)\\r\\n self.elementNeighbours[nei].append(own)\\r\\n \\r\\n #adds interior faces\\r\\n self.elementFaces[own].append(iFace)\\r\\n self.elementFaces[nei].append(iFace)\\r\\n \\r\\n #adds boundary faces ('patches')\\r\\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\\r\\n own=self.owners[iFace]\\r\\n self.elementFaces[own].append(iFace)\\r\\n \\r\\n ## List of lists containing points forming each element\\r\\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n \\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\\r\\n \\r\\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\\r\\n \\r\\n ## Upper coefficient indices (owners)\\r\\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n ## Lower coefficient indices (owners)\\r\\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n ## Element number from 1 to numberOfElements + 1\\r\\n iNb=1\\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n \\r\\n #skip if it is a boundary face\\r\\n if faceIndex > self.numberOfInteriorFaces-1:\\r\\n continue\\r\\n \\r\\n own = self.owners[faceIndex]\\r\\n nei = self.neighbours[faceIndex]\\r\\n \\r\\n if iElement == own:\\r\\n self.upperAnbCoeffIndex[faceIndex] = iNb\\r\\n elif iElement == nei:\\r\\n self.lowerAnbCoeffIndex[faceIndex] = iNb\\r\\n \\r\\n iNb = iNb +1\",\n \"def TNFR1_to_SecondaryComplex():\\n \\n Parameter('TNFa_0' , 5000) # 3000 corresponds to 50ng/ml TNFa\\n Parameter('TNFR1_0' , 200) # 200 receptors per cell\\n Parameter('TRADD_0' , 1000) # molecules per cell (arbitrarily assigned)1000\\n Parameter('CompI_0' , 0) # complexes per cell\\n Parameter('RIP1_0' , 20000) # molecules per cell 20000\\n Parameter('NFkB_0' , 0) # molecules per cell\\n \\n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\\n Initial(RIP1(bDD=None, bRHIM = None, state = 'ub'), RIP1_0) # RIP1\\n Initial(NFkB(bf=None), NFkB_0)\\n\\n # =========================================\\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\\n # -----------------------------------------\\n # TNFa+ TNFR1 <-> TNFa:TNFR1\\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub \\n \\n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\\n # [active]CompI:RIP1 >> [active]CompI + RIP1\\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\\n\\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it. \\n\\n # ------------------------------------------\\n \\n # -------------Complex I assembly----------------\\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [KF, KR])\\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [KF, KR])\\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), KC)\\n \\n # --------------Complex I - RIP1 Modification-----------------\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[KF, KR])\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR]) \\n \\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'),KC)\\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [Parameter('k2', 0), KR])\\n #Rule('RIP1_rel', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod') + RIP1(bDD=None, bRHIM = None, state = 'unmod'), KC3)\\n #bind(CompI(bDD=None, state = 'mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR])\\n #Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod'),KC3)\\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), KC)\\n Rule('NFkB_expression', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), KE)\\n # --------------RIP1 Ubiquitination---------------------------\\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), KC2)\\n # Rule('RIP1_deUb', RIP1(bDD=None, bRHIM = None, state='ub')>> RIP1(bDD=None, bRHIM = None, state='unmod'), KR)\",\n \"def make_m2_crv(TSUGITE_list, SHIGUCHI_list):\\n \\\"\\\"\\\"\\n 1 Get information from TSUGITE_list and SHIGUCHI_list.\\n \\\"\\\"\\\"\\n # TSUGITE\\n # Left----------------------------------------------------------------------\\n # material2\\n m2_left_list = TSUGITE_list[0]\\n m2_left_upper = m2_left_list[0]\\n m2_left_middle = m2_left_list[1]\\n m2_left_lower = m2_left_list[2]\\n\\n # SHIGUCHI\\n m2_KUMIKI_points1 = SHIGUCHI_list[4]\\n m2_KUMIKI_points2 = SHIGUCHI_list[5]\\n\\n m2_KUMIKI_points1.reverse()\\n\\n m2_left_upper.extend(m2_KUMIKI_points1)\\n m2_left_upper.append(m2_left_upper[0])\\n m2_left_upper_crv = rs.AddPolyline(m2_left_upper)\\n\\n m2_left_middle.extend(m2_KUMIKI_points1)\\n m2_left_middle.append(m2_left_middle[0])\\n m2_left_middle_crv = rs.AddPolyline(m2_left_middle)\\n\\n m2_left_lower.extend(m2_KUMIKI_points1)\\n m2_left_lower.append(m2_left_lower[0])\\n m2_left_lower_crv = rs.AddPolyline(m2_left_lower)\\n\\n m2_left_crvs = [m2_left_upper_crv, m2_left_middle_crv, m2_left_lower_crv]\\n\\n # Right---------------------------------------------------------------------\\n m2_right_list = TSUGITE_list[1]\\n m2_right_upper = m2_right_list[0]\\n m2_right_middle = m2_right_list[1]\\n m2_right_lower = m2_right_list[2]\\n\\n # SHIGUCHI\\n m2_KUMIKI_points1 = SHIGUCHI_list[0]\\n m2_KUMIKI_points2 = SHIGUCHI_list[1]\\n\\n # Extend\\n # material2\\n m2_right_upper.reverse()\\n m2_right_middle.reverse()\\n m2_right_lower.reverse()\\n\\n # m2_KUMIKI_points1.reverse()\\n\\n m2_right_upper.extend(m2_KUMIKI_points1)\\n m2_right_upper.append(m2_right_upper[0])\\n m2_right_upper_crv = rs.AddPolyline(m2_right_upper)\\n\\n m2_right_middle.extend(m2_KUMIKI_points1)\\n m2_right_middle.append(m2_right_middle[0])\\n m2_right_middle_crv = rs.AddPolyline(m2_right_middle)\\n\\n m2_right_lower.extend(m2_KUMIKI_points1)\\n m2_right_lower.append(m2_right_lower[0])\\n m2_right_lower_crv = rs.AddPolyline(m2_right_lower)\\n\\n m2_right_crvs = [m2_right_upper_crv, m2_right_middle_crv, m2_right_lower_crv]\\n\\n return m2_left_crvs, m2_right_crvs\",\n \"def plot_simplex(self, num_contours: int = 100, num_sub_div: int = 8,\\n color_map: str = 'viridis', border: bool = True, ax: Axes = None) -> Axes:\\n\\n corners = array([[0, 0], [1, 0], [0.5, 0.75 ** 0.5]])\\n triangle = Triangulation(corners[:, 0], corners[:, 1])\\n mid_points = [\\n (corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2\\n for i in range(3)\\n ]\\n\\n def to_barycentric(cartesian):\\n \\\"\\\"\\\"\\n Converts 2D Cartesian to barycentric coordinates.\\n\\n :param cartesian: A length-2 sequence containing the x and y value.\\n \\\"\\\"\\\"\\n s = [(corners[i] - mid_points[i]).dot(cartesian - mid_points[i]) / 0.75\\n for i in range(3)]\\n s_clipped = clip(a=s, a_min=0, a_max=1)\\n return s_clipped / norm(s_clipped, ord=1)\\n\\n refiner = UniformTriRefiner(triangle)\\n tri_mesh = refiner.refine_triangulation(subdiv=num_sub_div)\\n f = [self._method(to_barycentric(xy))\\n for xy in zip(tri_mesh.x, tri_mesh.y)]\\n ax = ax or new_axes()\\n ax.tricontourf(tri_mesh, f, num_contours, cmap=color_map)\\n ax.set_aspect('equal')\\n ax.set_xlim(0, 1)\\n ax.set_ylim(0, 0.75 ** 0.5)\\n ax.set_axis_off()\\n if border:\\n ax.triplot(triangle, linewidth=1)\\n\\n return ax\",\n \"def update_CPPN(genotype, E1, E2, subp_1, subp_2, norm_in, num_x, num_y, canvas):\\n\\n\\t# get values from fields, should all be comma separated\\n\\tinnov_nums = E1.get().split(\\\",\\\")\\n\\tnew_weights = E2.get().split(\\\",\\\")\\n\\n\\t# get all values from the above lists\\n\\tfor innov_num, new_weight in zip(innov_nums, new_weights):\\n\\t\\t# search through connections to find the correct\\n\\t\\t# weight to change\\n\\t\\tfor con in genotype.connections:\\n\\t\\t\\tif(con.getInnovationNumber() == int(innov_num)):\\n\\t\\t\\t\\tcon.setWeight(float(new_weight))\\n\\n\\t# clear both subplots so new graphs can be placed into the GUI\\n\\tsubp_1.clear()\\n\\tsubp_2.clear()\\n\\n\\t# create graphs again and put graphs onto them\\n\\toutputs = []\\n\\tfor ins in norm_in:\\n\\t\\toutputs.append(genotype.getOutput(ins)[0])\\n\\toutputs_np = np.array(outputs, copy=True)\\n\\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\\n\\n\\tgraph_genotype_GUI(genotype, subp_2)\\n\\n\\tcanvas.show()\\n\\tcanvas.get_tk_widget().pack()\",\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def subdListComponentConversion(*args, border: bool=True, fromEdge: bool=True, fromFace:\\n bool=True, fromUV: bool=True, fromVertex: bool=True, internal:\\n bool=True, toEdge: bool=True, toFace: bool=True, toUV:\\n bool=True, toVertex: bool=True, uvShell: bool=True,\\n uvShellBorder: bool=True, **kwargs)->List[AnyStr]:\\n pass\",\n \"def TNFR1_to_SecondaryComplex():\\n \\n Parameter('TNFa_0' , 6000) # 6000 corresponds to 100ng/ml TNFa\\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\\n Parameter('CompI_0' , 0) # complexes per cell\\n Parameter('NFkB_0' , 0) # molecules per cell\\n alias_model_components()\\n \\n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'ub'), RIP1_0) # RIP1\\n Initial(NFkB(bf=None), NFkB_0)\\n \\n # =========================================\\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\\n # -----------------------------------------\\n # TNFa+ TNFR1 <-> TNFa:TNFR1\\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\\n \\n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\\n # [active]CompI:RIP1 >> [active]CompI + RIP1\\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\\n \\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\\n \\n # ------------------------------------------\\n \\n # -------------Complex I assembly----------------\\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\\n \\n # --------------Complex I - RIP1 Modification-----------------\\n # Complex I recruits RIP1\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\\n \\n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1e-3))\\n\\n # De-ubiquitination and degradation or release of RIP1 from complex I\\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'), Parameter('k6',1))\\n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\\n \\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [1e-10,1])\\n \\n # Receptor recycle\\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1))\\n \\n # --------------RIP1 Ubiquitination---------------------------\\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))\",\n \"def modelTheGraph(contourset):\\r\\n cntr_data = pd.DataFrame(columns=['level', 'node_x', 'node_y', 'path'])\\r\\n frames = list()\\r\\n start_time_model_graph = time.time()\\r\\n for level_index in range(len(contourset.collections)):\\r\\n path_counter = 0\\r\\n indices = np.arange(0, len(contourset.collections[level_index].get_paths()))\\r\\n array_list = np.take(contourset.collections[level_index].get_paths(), indices)\\r\\n for item in array_list.flat:\\r\\n node_x = item.vertices[:, 0].tolist()\\r\\n node_y = item.vertices[:, 1].tolist()\\r\\n frames.append([level_index, node_x, node_y, path_counter])\\r\\n path_counter += 1\\r\\n df = pd.DataFrame(frames, columns=['level', 'node_x', 'node_y', 'path'])\\r\\n df1 = df[['level', 'node_y', 'path']]\\r\\n df2 = df[['level', 'node_x', 'path']]\\r\\n lst_col = 'node_y'\\r\\n r1 = pd.DataFrame({\\r\\n col: np.repeat(df1[col].values, df1[lst_col].str.len())\\r\\n for col in df1.columns.drop(lst_col)}\\r\\n ).assign(**{lst_col: np.concatenate(df1[lst_col].values)})[df1.columns]\\r\\n lst_col2 = 'node_x'\\r\\n r2 = pd.DataFrame({\\r\\n col: np.repeat(df2[col].values, df2[lst_col2].str.len())\\r\\n for col in df2.columns.drop(lst_col2)}\\r\\n ).assign(**{lst_col2: np.concatenate(df2[lst_col2].values)})[df2.columns]\\r\\n cntr_data['level'] = r1['level'].tolist()\\r\\n cntr_data['node_x'] = r2['node_x'].tolist()\\r\\n cntr_data['node_y'] = r1['node_y'].tolist()\\r\\n cntr_data['path'] = r1['path'].tolist()\\r\\n print(\\\"For modeling the graph %s seconds\\\" % (time.time() - start_time_model_graph))\\r\\n\\r\\n return cntr_data\",\n \"def addGrids(self, grid, label):\\n self.grid = grid\\n self.label = label\\n self.H = len(grid)\\n self.W = len(grid[0])\\n self.visited = [[False] * self.W for _ in range(self.H)]\\n self.clusters = [self._resort_size(r, c) for r, c in product(range(self.H), range(self.W)) if self.grid[r][c] != 0 and not self.visited[r][c]]\\n self.subsets = []\\n\\n assert len(self.V) == len(self.neighbours.keys())\\n\\n if len(self.V) == 0 or not any(self.neighbours.values()):\\n for addresstamp in self.clusters:\\n footprint = Footprint(self.source, label, addresstamp)\\n self.source += 1\\n self.neighbours[footprint.uid] = []\\n for v in self.V:\\n if v.is_overlappedFootprint(footprint):\\n self.E.append((v, footprint))\\n self.neighbours.get(v.uid).append(footprint.uid)\\n self.neighbours.get(footprint.uid).append(v.uid)\\n self.resorts[v] = Resort([footprint])\\n self.V.append(footprint)\\n return\\n\\n connected_footprints = []\\n for sub in self.recursive_findDenseZones(self.neighbours):\\n self.subsets.append(sub)\\n connected_footprints.extend(sub.getFootprintId())\\n for addresstamp in self.clusters:\\n footprint = Footprint(self.source, label, addresstamp)\\n self.source += 1\\n self.neighbours[footprint.uid] = []\\n if len(addresstamp) == 1:\\n self.V.append(footprint)\\n continue\\n new_sub = 1\\n for sub in self.subsets:\\n if sub.check_collision(footprint):\\n new_sub = 0\\n new_resort = 1\\n for key, resort in sub.resorts.items():\\n if resort.getLastFootprint().is_overlappedFootprint(footprint):\\n new_resort = 0\\n for n in resort.footprints:\\n self.E.append((n, footprint))\\n self.neighbours.get(n.uid).append(footprint.uid)\\n self.neighbours.get(footprint.uid).append(n.uid)\\n sub.resorts[key].addFootprint(footprint)\\n self.resorts[key].addFootprint(footprint)\\n break\\n if new_resort:\\n sub.resorts[footprint] = Resort([footprint])\\n self.resorts[footprint] = Resort([footprint])\\n break\\n if new_sub:\\n min_distance = sqrt(self.H**2 + self.W**2)\\n closest = None\\n for key, resort in self.resorts.items():\\n if footprint.distance_from_resort(resort) < min_distance:\\n min_distance = footprint.distance_from_resort(resort)\\n closest = key\\n assert closest\\n for n in self.resorts[closest].footprints:\\n self.E.append((n, footprint))\\n self.neighbours.get(n.uid).append(footprint.uid)\\n self.neighbours.get(footprint.uid).append(n.uid)\\n self.V.append(footprint)\",\n \"def pool_snps(parent1, parent2):\",\n \"def discretize(self, obstacle_collection, drone_poses, goal_poses):\\n cyl_c1_list = []\\n cyl_c2_list = []\\n cyl_r_list = []\\n cyl_dir_list = []\\n for obs in obstacle_collection.obstacles:\\n if isinstance(obs, Cylinder):\\n if obs.axis == 'x':\\n cyl_dir_list.append(0)\\n cyl_c1_list.append(obs.position.y + abs(MIN_Y))\\n cyl_c2_list.append(obs.position.z)\\n elif obs.axis == 'y':\\n cyl_dir_list.append(1)\\n cyl_c1_list.append(obs.position.x + abs(MIN_X))\\n cyl_c2_list.append(obs.position.z)\\n elif obs.axis == 'z':\\n cyl_dir_list.append(2)\\n cyl_c1_list.append(obs.position.x + abs(MIN_X))\\n cyl_c2_list.append(obs.position.y + abs(MIN_Y))\\n\\n cyl_r_list.append(obs.radius)\\n\\n x_dim = MAX_X - MIN_X\\n y_dim = MAX_Y - MIN_Y\\n z_dim = MAX_Z\\n mesh_nodes = mesh.generateMesh([x_dim, y_dim, z_dim],\\n cyl_c1_list, cyl_c2_list, cyl_r_list, cyl_dir_list,\\n self.__angle, self.__size, self.__approximation,\\n self.__radiusedge, self.__ratio)\\n for _ in mesh_nodes:\\n self.__nodes.append(MeshNode())\\n for n in mesh_nodes:\\n self.__nodes[n.index].x = n.x - abs(MIN_X)\\n self.__nodes[n.index].y = n.y - abs(MIN_Y)\\n self.__nodes[n.index].z = n.z\\n for edge in n.adj:\\n self.__nodes[n.index].add_edge(self.__nodes[edge])\\n\\n def add_node(n):\\n for node in self.__nodes:\\n # Only short edges that are not on the ground or through obstacles\\n if n.dist(node) < MESH_EDGE_DIST and (n.z > DRONE_HEIGHT or node.z > DRONE_HEIGHT):\\n valid_edge = True\\n for obs in obstacle_collection.obstacles:\\n if isinstance(obs, Cylinder):\\n cylinder_seg = Segment(Point(obs.position), Point(obs.position))\\n if obs.axis == 'x':\\n cylinder_seg.b += Point(1000, 0, 0)\\n elif obs.axis == 'y':\\n cylinder_seg.b += Point(0, 1000, 0)\\n else:\\n cylinder_seg.b += Point(0, 0, 1000)\\n edge_seg = Segment(Point(n.position()), Point(node.position()))\\n\\n if cylinder_seg.min_distance(edge_seg) < obs.radius:\\n valid_edge = False\\n if valid_edge:\\n n.add_edge(node)\\n\\n # Adding drone nodes\\n drone_nodes = {}\\n if drone_poses is not None:\\n for drone_id in drone_poses:\\n p = drone_poses[drone_id].position\\n drone_nodes[drone_id] = MeshNode(p.x, p.y, p.z)\\n add_node(drone_nodes[drone_id])\\n\\n # Adding goal nodes\\n goal_nodes = {}\\n if goal_poses is not None:\\n for drone_id in goal_poses:\\n p = goal_poses[drone_id]\\n goal_nodes[drone_id] = MeshNode(p.x, p.y, p.z)\\n add_node(goal_nodes[drone_id])\\n\\n return drone_nodes, goal_nodes\",\n \"def _build_topology(self):\\n\\t\\t# childSection.connect(parentSection, [parentX], [childEnd])\\n\\t\\tfor i in range(self._axonNodes-1):\\n\\t\\t\\tself.node[i].connect(self.mysa[2*i],0,1)\\n\\t\\t\\tself.mysa[2*i].connect(self.flut[2*i],0,1)\\n\\t\\t\\tself.flut[2*i].connect(self.stin[6*i],0,1)\\n\\t\\t\\tself.stin[6*i].connect(self.stin[6*i+1],0,1)\\n\\t\\t\\tself.stin[6*i+1].connect(self.stin[6*i+2],0,1)\\n\\t\\t\\tself.stin[6*i+2].connect(self.stin[6*i+3],0,1)\\n\\t\\t\\tself.stin[6*i+3].connect(self.stin[6*i+4],0,1)\\n\\t\\t\\tself.stin[6*i+4].connect(self.stin[6*i+5],0,1)\\n\\t\\t\\tself.stin[6*i+5].connect(self.flut[2*i+1],0,1)\\n\\t\\t\\tself.flut[2*i+1].connect(self.mysa[2*i+1],0,1)\\n\\t\\t\\tself.mysa[2*i+1].connect(self.node[i+1],0,1)\",\n \"def create_subbasin_graph():\\n subbasin_to_downstream = pd.read_csv(module_dir + '/../data/simulations_shervan/test.rvh', sep='\\\\s+', skiprows=7, nrows=724, names=['subbasin', 'downstream_subbasin'], usecols=[1,2])\\n subbasin_to_downstream['subbasin'] = subbasin_to_downstream['subbasin']\\n subbasin_to_downstream['downstream_subbasin'] = 'sub' + subbasin_to_downstream['downstream_subbasin'].astype(str)\\n subbasin_to_downstream['edge'] = 1\\n\\n for subbasin in subbasin_to_downstream['subbasin'].unique():\\n is_sink = 1 if len(subbasin_to_downstream[(subbasin_to_downstream['subbasin'] == subbasin) & subbasin_to_downstream['edge'] == 1]) == 0 else 0\\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': subbasin, 'downstream_subbasin': subbasin, 'edge': is_sink}, ignore_index=True)\\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': 'sub-1', 'downstream_subbasin': 'sub-1', 'edge': 1}, ignore_index=True)\\n \\n adj = subbasin_to_downstream.pivot(index='subbasin', columns='downstream_subbasin', values='edge').fillna(0) \\n adj = adj.sort_index(axis=0).sort_index(axis=1)\\n \\n G = nx.from_numpy_matrix(adj.values, parallel_edges=False, create_using=nx.DiGraph())\\n label_mapping = dict(zip(range(len(adj.values)), adj.index))\\n G = nx.relabel_nodes(G, label_mapping)\\n \\n return G\",\n \"def labeled_subsimplex(\\n label_func, init, disc\\n): # pylint: disable=too-many-locals,too-many-statements\\n init = np.asarray(init, float)\\n dim = init.size\\n # Base vertex of the subsimplex currently being used\\n dinit = _discretize_mixture(init, disc)\\n base = np.append(dinit, 0)\\n base[0] += 1\\n # permutation array of [1,dim] where v0 = base,\\n # v{i+1} = [..., vi_{perms[i] - 1} - 1, vi_{perms[i]} + 1, ...]\\n perms = np.arange(1, dim + 1)\\n # Array of labels for each vertex\\n labels = np.arange(dim + 1)\\n labels[dim] = label_func(dinit / disc)\\n # Vertex used to label initial vertices (vertex[-1] == 0)\\n label_vertex = base[:-1].copy()\\n # Last index moved\\n index = dim\\n # Most recent created index, should be set to\\n new_vertex = None\\n\\n while labels[index] < dim:\\n # Find duplicate index. this is O(dim) but not a bottleneck\\n (dup_labels,) = np.nonzero(labels == labels[index])\\n (index,) = dup_labels[dup_labels != index]\\n\\n # Flip simplex over at index\\n if index == 0:\\n base[perms[0]] += 1\\n base[perms[0] - 1] -= 1\\n perms = np.roll(perms, -1)\\n labels = np.roll(labels, -1)\\n index = dim\\n\\n elif index == dim:\\n base[perms[-1] - 1] += 1\\n base[perms[-1]] -= 1\\n perms = np.roll(perms, 1)\\n labels = np.roll(labels, 1)\\n index = 0\\n\\n else: # 0 < index < dim\\n perms[index - 1], perms[index] = perms[index], perms[index - 1]\\n\\n # Compute actual value of flipped vertex\\n new_vertex = base.copy()\\n new_vertex[perms[:index]] += 1\\n new_vertex[perms[:index] - 1] -= 1\\n\\n utils.check(\\n np.all(new_vertex >= 0) and new_vertex.sum() == disc + 1,\\n \\\"vertex rotation failed, check labeling function\\\",\\n )\\n\\n # Update label of new vertex\\n if new_vertex[-1] == 2:\\n labels[index] = dim\\n elif new_vertex[-1] == 0:\\n labels[index] = np.argmax(new_vertex[:-1] - label_vertex)\\n else: # == 1\\n labels[index] = label_func(new_vertex[:-1] / disc)\\n utils.check(\\n 0 <= labels[index] < dim and new_vertex[labels[index]],\\n \\\"labeling function was not proper (see help)\\\",\\n )\\n\\n # Average out all vertices in simplex we care about\\n current = base\\n if index == 0: # pragma: no cover\\n count = 0\\n mean = np.zeros(dim)\\n else: # pragma: no cover\\n count = 1\\n mean = current.astype(float)\\n for i, j in enumerate(perms, 1):\\n current[j] += 1\\n current[j - 1] -= 1\\n if i != index:\\n count += 1\\n mean += (current - mean) / count\\n return mean[:-1] / disc\",\n \"def CD95_to_SecondaryComplex():\\n\\n Parameter('Fas_0' , 6000) # 6000 corresponds to 100ng/ml Fas (J Immunol 2005)\\n Parameter('CD95_0' , 4817) # 4817receptors per cell (J Immunol 2005)\\n Parameter('FADD_0' , 8030) # 8300 molecules per cell (J Immunol 2005)\\n Parameter('flip_L_0', 390220) # 39022 molecules per cell (J Immunol 2005)\\n Parameter('flip_S_0', 390220) # molecules per cell assummed both isoforms w/conc.\\n Parameter('proC8_0' , 16057) # procaspase 8 molecules per cell 16057 (J Immunol 2005)\\n Parameter('C8_0' , 0) # active caspase 8 dimers per cell.\\n Parameter('Bar_0' , 1.0e3) # Bar molecules per cell. (Hela Cells)\\n alias_model_components()\\n \\n Initial(Fas(blig=None), Fas_0) #Fas Ligand\\n Initial(CD95(blig=None, bDD=None), CD95_0) #Fas Receptor (CD95)\\n Initial(FADD(bDD=None, bDED1=None, bDED2=None), FADD_0) #FADD\\n Initial(flip_L(bDED=None), flip_L_0) #c-Flip[L]\\n Initial(flip_S(bDED=None), flip_S_0) #c-Flip[S]\\n Initial(proC8(bDED=None), proC8_0) #procaspase 8\\n Initial(C8(bf=None, state = 'A'), C8_0) #caspase 8\\n Initial(Bar(bC8=None), Bar_0) #bifunctional apoptosis regulator\\n \\n # =========================================\\n # CD95 ligation and formation of Secondary Complex rules\\n # -----------------------------------------\\n # Fas + CD95 <-> Fas:CD95\\n # Fas:CD95 + FADD <-> Fas:CD95:FADD\\n # Fas:CD95:FADD + proC8 <-> Fas:CD95:FADD:proC8\\n \\n # Fas:CD95:FADD:proC8 + proC8 <-> Fas:CD95:FADD:proC8:proC8 -> Fas:CD95:FADD + C8\\n # Fas:CD95:FADD:proC8 + flip_L <-> Fas:CD95:FADD:proC8:flip_L\\n # Fas:CD95:FADD:proC8 + flip_S <-> Fas:CD95:FADD:proC8:flip_S\\n \\n # Fas:CD95:FADD:proC8:flip_L <-> Fas:CD95 + FADD:proC8:flip_L\\n # Fas:CD95:FADD:proC8:flip_S <-> Fas:CD95 + FADD:proC8:flip_S\\n # ------------------------------------------\\n \\n # ==========================================\\n # Regulation (downstream of CD95) of Caspase 8 activity\\n # ------------------------------------------\\n # C8 + BAR <-> C8:BAR\\n # C8 + TRAF2 >> TRAF2\\n \\n # -------------DISC assembly----------------\\n alias_model_components()\\n bind(Fas(blig=None), 'blig', CD95(blig = None, bDD = None), 'blig', [1.89e-7, 1e-4])\\n bind(CD95(blig = ANY, bDD = None), 'bDD', FADD(bDD = None, bDED1 =None, bDED2 = None), 'bDD', [1.04e-6, 0.2]) # (J Immunol 2005)\\n bind(FADD(bDD = ANY, bDED1 = None, bDED2 = None),'bDED1', proC8(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n \\n # For simplicity allow proC8 to bind FADD before any c-Flip do.\\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', flip_L(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', flip_S(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n \\n \\n # procaspase 8 dimerization and activation\\n bind(FADD(bDD = ANY, bDED2 = None, bDED1 = ANY), 'bDED2', proC8(bDED = None), 'bDED', [7.27e-06, 0.018]) # (J Immunol 2005)\\n \\n Rule('C8_activation', FADD(bDED1 = ANY, bDED2 = ANY)%proC8(bDED=ANY)%proC8(bDED = ANY) >> FADD(bDED1 = None, bDED2 = None) + C8(bf = None, state = 'A'), Parameter('k1', 0.3)) # (J Immunol 2005)\\n\\n # caspase 8 inhibition by BAR\\n bind(Bar(bC8 = None), 'bC8', C8(bf = None, state = 'A'), 'bf', [1e-6, 1e-3])\\n \\n # release of secondary complex from the DISC\\n bind(FADD(bDD = None, bDED2 = ANY, bDED1 = ANY), 'bDD', CD95(blig = ANY, bDD=None), 'bDD', [1e-10, 1e-3])\",\n \"def test_scipy_graph_to_cugraph_graph():\\n dpr = mg.resolver\\n scipy_sparse_matrix = ss.csr_matrix(\\n np.array(\\n [\\n [0, 1, 1, 0, 0],\\n [0, 0, 1, 0, 0],\\n [1, 0, 0, 0, 0],\\n [0, 0, 1, 0, 0],\\n [0, 0, 0, 0, 0],\\n ],\\n dtype=bool,\\n )\\n )\\n x = dpr.wrappers.Graph.ScipyGraph(scipy_sparse_matrix, np.arange(5))\\n\\n sources = [0, 0, 1, 2, 3]\\n destinations = [1, 2, 2, 0, 2]\\n cdf = cudf.DataFrame({\\\"Source\\\": sources, \\\"Destination\\\": destinations})\\n g = cugraph.DiGraph()\\n g.from_cudf_edgelist(cdf, source=\\\"Source\\\", destination=\\\"Destination\\\")\\n intermediate = dpr.wrappers.Graph.CuGraph(g, cudf.Series(range(5)))\\n\\n y = dpr.translate(x, CuGraph)\\n dpr.assert_equal(y, intermediate)\\n assert len(dpr.plan.translate(x, CuGraph)) == 1\",\n \"def new_resolve_unique_contigs(scaffold_list, unique_contigs_list):\\n \\n contig_location = {}\\n s_l = copy.deepcopy(scaffold_list)\\n \\n #first deal with any scaffolds that have more than one copy of a unique contig\\n to_remove = []\\n for scaf in s_l: \\n for contig in unique_contigs_list:\\n if scaf.count(contig) > 1:\\n scaffold_parts = split_siamese(contig, scaf)\\n to_remove.append(scaf)\\n s_l.extend(scaffold_parts)\\n break \\n for scaf in to_remove:\\n s_l.remove(scaf) \\n\\n\\n for contig in unique_contigs_list:\\n #if contig[:4] == \\\"five\\\": \\n finds = find_unique_contig(contig, s_l)\\n\\n if len(finds) > 1:\\n contig_location[contig] = finds\\n\\n sc_ov = {}\\n sc_ov = make_scaff_overlap_dict(contig_location)\\n\\n #This is the new bit that takes just the first conflicted contig \\n first_k = list(sc_ov.items())[0:1]\\n first_sc_ov = dict(first_k)\\n new_scaffold_list = combine_overlapping_contigs(first_sc_ov, s_l)\\n\\n #Split off unique scaffolds attached by their 3' ends to multiple scaffolds\\n \\n for contig in contig_location:\\n if contig[:5] == \\\"three\\\":\\n for scaf in contig_location[contig]:\\n conflict = False\\n if scaf.index(contig) == 1:\\n conflict = True\\n new_left_scaf = scaf[:3]\\n new_right_scaf = scaf[3:]\\n if scaf.index(contig) == len(scaf) - 2:\\n conflict = True\\n new_left_scaf = scaf[:-3]\\n new_right_scaf = scaf[-3:]\\n if conflict:\\n new_left_scaf.append(\\\"link_conflict6\\\")\\n new_right_scaf.insert(0,\\\"link_conflict6\\\")\\n if len(new_left_scaf) >= 4: \\n new_scaffold_list.append(new_left_scaf)\\n if len(new_right_scaf) >= 4:\\n new_scaffold_list.append(new_right_scaf)\\n if scaf in new_scaffold_list:\\n new_scaffold_list.remove(scaf)\\n\\n return new_scaffold_list\",\n \"def getContactRoute(ss_def, contacts_def):\\n control = 0 # to control the while loop until the length of all SSEs\\n i = 0 # i, j are the indices of the SSE array\\n j = 0\\n map_route = []\\n while control != len(ss_def) - 1:\\n\\n # [20, 64, 28, 24, 56, 28, 24, 40, 24, 24, 88] 11\\n if control == 0:\\n control += 1\\n i, j = getTopRank(ss_def, contacts_def) # get the largest intra contact smotif\\n map_route.append([i, j, 'start'])\\n else:\\n if i == 0:\\n ti = j\\n j += 1\\n control += 1\\n direction = 'right'\\n map_route.append([ti, j, direction])\\n elif j == len(ss_def) - 1: # -1 to deal with array index\\n tj = i\\n i -= 1\\n control += 1\\n direction = 'left'\\n map_route.append([i, tj, direction])\\n else:\\n ti, tj, new_direction = nextSS(map_route, ss_def, contacts_def)\\n control += 1\\n map_route.append([ti, tj, new_direction])\\n return map_route\",\n \"def _build_graph_general(self): \\n\\n #Find a canonical coloring scheme\\n #Each node has a color that is determined by the non-mapped aspects\\n nodecolors=set()\\n for nl in self.net.iter_node_layers():\\n nodecolors.add(self._slice_node_layer_not_allowed(nl))\\n nodecolors_sorted=sorted(list(nodecolors))\\n del nodecolors\\n self._assert_full_order(nodecolors_sorted)\\n self.colormap=dict( ((color,colorid) for colorid,color in enumerate(nodecolors_sorted) ))\\n\\n #each aux node has a color that is determined by the aspect\\n self.auxcolormap=dict( ((auxcolor, auxcolorid+len(self.colormap)) for auxcolorid,auxcolor in enumerate(sorted(self.asp)) ) )\\n\\n\\n #Add the underlying network\\n #node-layers:\\n for nl in self.net.iter_node_layers():\\n nlid=self._get_node_id(nl)\\n color=self._slice_node_layer_not_allowed(nl)\\n colorid=self.colormap[color]\\n self.add_node(nlid,colorid)\\n\\n #edges between node-layers:\\n for nl1 in self.net.iter_node_layers():\\n for nl2 in self.net[nl1]:\\n nl1id=self._get_node_id(nl1)\\n nl2id=self._get_node_id(nl2)\\n self.add_link(nl1id,nl2id)\\n\\n\\n #Add the auxiliary nodes and edges\\n #add the aux nodes\\n for a in self.asp:\\n for elayer in self.net.slices[a]:\\n auxid=self._get_auxnode_id( (a,elayer) )\\n auxcolorid=self.auxcolormap[a]\\n self.add_node(auxid,auxcolorid)\\n \\n #add the aux edges\\n for nl in self.net.iter_node_layers():\\n for a in self.asp:\\n nlid=self._get_node_id(nl)\\n auxid=self._get_auxnode_id( (a,nl[a]) )\\n self.add_link(nlid,auxid)\",\n \"def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n hspc=(max_x-min_x)/x_divisions\\n vspc=(max_y-min_y)/y_divisions\\n\\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n pshp.set_property('position',\\\"%.1f\\\" % hval)\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n pshp.set_property('position',\\\"%.1f\\\" % vval)\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True) \\n\\n return layer\",\n \"def create_map_coloring_csp():\\n csp = CSP()\\n states = [ 'WA', 'NT', 'Q', 'NSW', 'V', 'SA', 'T' ]\\n edges = { 'SA': [ 'WA', 'NT', 'Q', 'NSW', 'V' ], 'NT': [ 'WA', 'Q' ], 'NSW': [ 'Q', 'V' ] }\\n colors = [ 'red', 'green', 'blue' ]\\n for state in states:\\n csp.add_variable(state, colors)\\n for state, other_states in edges.items():\\n for other_state in other_states:\\n csp.add_constraint_one_way(state, other_state, lambda i, j: i != j)\\n csp.add_constraint_one_way(other_state, state, lambda i, j: i != j)\\n return csp\",\n \"def make_sub_data_train(data, config):\\n sub_input_sequence = []\\n sub_label_sequence = []\\n\\n\\tfor scale in range(2,5):\\t \\n\\n\\t for i in range(len(data)):\\n\\n\\t\\t#input_, label_, = preprocess(data[i], config.scale) # do bicbuic only one scale\\n\\t\\tinput_, label_, = preprocess(data[i], scale) # do bicbuic turn around all scale\\n\\t\\n\\t\\tif len(input_.shape) == 3: # is color\\n\\t\\t h, w, c = input_.shape\\n\\t\\telse:\\n\\t\\t h, w = input_.shape # is grayscale\\n\\t\\n\\t\\t#checkimage(input_)\\t\\t\\n\\n\\t\\tnx, ny = 0, 0\\n\\t\\tfor x in range(0, h - config.image_size + 1, config.stride):\\n\\t\\t nx += 1; ny = 0\\n\\t\\t for y in range(0, w - config.image_size + 1, config.stride):\\n\\t\\t\\tny += 1\\n\\n\\t\\t\\tsub_input = input_[x: x + config.image_size, y: y + config.image_size] # 41 * 41\\n\\t\\t\\tsub_label = label_[x: x + config.label_size, y: y + config.label_size] # 41 * 41\\n\\n\\n\\t\\t\\t# Reshape the subinput and sublabel\\n\\t\\t\\tsub_input = sub_input.reshape([config.image_size, config.image_size, config.c_dim])\\n\\t\\t\\tsub_label = sub_label.reshape([config.label_size, config.label_size, config.c_dim])\\n\\n\\t\\t\\t# Normialize\\n\\t\\t\\tsub_input = sub_input / 255.0\\n\\t\\t\\tsub_label = sub_label / 255.0\\n\\t\\t\\t\\n\\t\\t\\t#cv2.imshow(\\\"im1\\\",sub_input)\\n\\t\\t\\t#cv2.imshow(\\\"im2\\\",sub_label)\\n\\t\\t\\t#cv2.imshow(\\\"residual\\\",sub_input - sub_label)\\n\\t\\t\\t#cv2.waitKey(0)\\n\\n\\t\\t\\t# Rotate 90,180,270\\n\\t\\t\\tfor angle in range(0,360,90):\\t\\n\\t\\t\\t\\tsub_input = rotate(sub_input,angle)\\t\\n\\t\\t\\t\\tsub_label = rotate(sub_label,angle)\\t\\n\\t\\t\\n\\t\\t\\t\\t# Add to sequence\\n\\t\\t\\t\\tsub_input_sequence.append(sub_input)\\n\\t\\t\\t\\tsub_label_sequence.append(sub_label)\\n\\n\\t\\t\\t\\tcv2.imshow(\\\"im1\\\",sub_input)\\n\\t\\t\\t\\tcv2.imshow(\\\"im2\\\",sub_label)\\n\\t\\t\\t\\tcv2.imshow(\\\"residual\\\",sub_input - sub_label)\\n\\t\\t\\t\\tcv2.waitKey(1)\\n\\t\\t\\t\\t\\n\\n \\n # NOTE: The nx, ny can be ignore in train\\n return sub_input_sequence, sub_label_sequence, nx, ny\",\n \"def AddContour(self,polyData):\\n #research\\n # called by drawIsoSurfaces\\n profprint()\\n # print polyData\\n scene = slicer.mrmlScene\\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\\n #??? i suppose here is a bug:\\n print 'modelNodes: ',modelNodes\\n print 'self.ContourNode: ', self.contourNode\\n #!!! self.contourNode is None\\n \\n #bugfix>>>>\\n modelNode = slicer.vtkMRMLModelNode()\\n self.contourNode = modelNode.GetID()\\n # print 'self.ContourNode: ', self.contourNode\\n #<<<bugfix\\n \\n # contourNode = slicer.util.getNode(self.contourNode)\\n # print 'contourNode: ',contourNode\\n if self.contourNode != None:\\n slicer.mrmlScene.RemoveNode(self.contourNode.GetStorageNode())\\n self.contourNode.RemoveAllDisplayNodeIDs()\\n slicer.mrmlScene.RemoveNode(self.contourNode)\\n \\n #modelNode = slicer.vtkMRMLModelNode()\\n modelNode.SetScene(scene)\\n modelNode.SetAndObservePolyData(polyData)\\n # display node\\n displayNode = slicer.vtkMRMLModelDisplayNode()\\n \\n modelNode.SetName('Contours')\\n \\n scene.AddNode(displayNode)\\n scene.AddNode(modelNode)\\n \\n displayNode.SetVisibility(1)\\n displayNode.SetOpacity(0.06)\\n displayNode.SetSliceIntersectionVisibility(1)\\n displayNode.SetScalarVisibility(1)\\n displayNode.SetActiveScalarName('ImageScalars') \\n displayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileHotToColdRainbow2.txt')\\n displayNode.SetScalarRange(10,40)\\n displayNode.SetBackfaceCulling(0)\\n displayNode.SetScene(scene)\\n scene.AddNode(displayNode)\\n modelNode.SetAndObserveDisplayNodeID(displayNode.GetID())\\n # add to scene\\n displayNode.SetInputPolyData(modelNode.GetPolyData())\\n scene.AddNode(modelNode)\\n\\n #self.contourNode = modelNode.GetID()\\n\\n qt.QApplication.processEvents()\",\n \"def CD95_to_SecondaryComplex():\\n \\n Parameter('Fas_0' , 000) # 3000 corresponds to 50ng/ml Fas\\n Parameter('CD95_0' , 200) # 200 receptors per cell\\n Parameter('FADD_0' , 1.0e3) # molecules per cell (arbitrarily assigned)1000\\n Parameter('flip_L_0', 1.0e4) # molecules per cell\\n Parameter('flip_S_0', 1.0e4) # molecules per cell\\n Parameter('proC8_0' , 2.0e4) # procaspase 8 molecules per cell 20000\\n Parameter('C8_0' , 0) # active caspase 8 dimers per cell.\\n Parameter('Bar_0' , 1.0e3) # Bar molecules per cell.\\n \\n Initial(Fas(blig=None), Fas_0) #Fas Ligand\\n Initial(CD95(blig=None, bDD=None), CD95_0) #Fas Receptor (CD95)\\n Initial(FADD(bDD=None, bDED1=None, bDED2=None), FADD_0) #FADD\\n Initial(flip_L(bDED=None), flip_L_0) #c-Flip[L]\\n Initial(flip_S(bDED=None), flip_S_0) #c-Flip[S]\\n Initial(proC8(bDED=None), proC8_0) #procaspase 8\\n Initial(C8(bC8=None), C8_0) #caspase 8\\n Initial(Bar(bC8=None), Bar_0) #bifunctional apoptosis regulator\",\n \"def nodeSeparate(self,compInfo, ifSub, subname, subcktName,numNodesSub):\\n node = []\\n nodeTemp = []\\n nodeDic = {}\\n pinInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\\n pinProtectedInit = 'Modelica.Electrical.Analog.Interfaces.Pin '\\n protectedNode = []\\n print \\\"CompInfo coming to nodeSeparate function: compInfo\\\",compInfo\\n \\n #Removing '[' and ']' from compInfo for Digital node\\n for i in range(0,len(compInfo),1):\\n compInfo[i] = compInfo[i].replace(\\\"[\\\",\\\"\\\").replace(\\\"]\\\",\\\"\\\")\\n \\n \\n for eachline in compInfo:\\n words = eachline.split()\\n if eachline[0] in ['m', 'e', 'g', 't','M','E','G','T']:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n nodeTemp.append(words[3])\\n nodeTemp.append(words[4])\\n elif eachline[0] in ['q', 'j','J','Q']:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n nodeTemp.append(words[3])\\n elif eachline[0]=='x' or eachline[0]=='X':\\n templine = eachline.split()\\n for i in range(0,len(templine),1):\\n if templine[i] in subcktName:\\n point = i \\n nodeTemp.extend(words[1:point])\\n else:\\n nodeTemp.append(words[1])\\n nodeTemp.append(words[2])\\n for i in nodeTemp:\\n if i not in node:\\n node.append(i)\\n \\n for i in range(0, len(node),1):\\n nodeDic[node[i]] = 'n' + node[i]\\n if ifSub == '0':\\n if i != len(node)-1:\\n pinInit = pinInit + nodeDic[node[i]] + ', '\\n else:\\n pinInit = pinInit + nodeDic[node[i]]\\n else:\\n nonprotectedNode = self.getSubInterface(subname, numNodesSub) \\n if node[i] in nonprotectedNode:\\n continue\\n else:\\n protectedNode.append(node[i])\\n if ifSub == '1':\\n if len(nonprotectedNode) > 0:\\n for i in range(0, len(nonprotectedNode),1):\\n if i != len(nonprotectedNode)-1:\\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]] + ','\\n else:\\n pinProtectedInit = pinProtectedInit + nodeDic[nonprotectedNode[i]]\\n if len(protectedNode) > 0:\\n for i in range(0, len(protectedNode),1):\\n if i != len(protectedNode)-1: \\n pinInit = pinInit + nodeDic[protectedNode[i]] + ','\\n else:\\n pinInit = pinInit + nodeDic[protectedNode[i]]\\n pinInit = pinInit + ';'\\n pinProtectedInit = pinProtectedInit + ';'\\n print \\\"Node---->\\\",node\\n print \\\"nodeDic----->\\\",nodeDic\\n print \\\"PinInit----->\\\",pinInit\\n print \\\"pinProtectedinit--->\\\",pinProtectedInit\\n return node, nodeDic, pinInit, pinProtectedInit\",\n \"def _mn_contour_ ( self , npoint , par1 , par2 , nsigma = 1 ) :\\n if npoint < 4 : raise ValueError ( 'contour: npoint (%s) must be >= 4' % npoint )\\n if not par1 in self : raise ValueError ( 'contour: par1(%s) is not in Minuit' % par1 )\\n if not par2 in self : raise ValueError ( 'contour: par2(%s) is not in Minuit' % par2 )\\n if par1 == par2 : raise ValueError ( 'contour: par1 == par2(%s) ' % par2 )\\n #\\n ## save old error defintion\\n #\\n old_err_def = self.GetErrorDef()\\n #\\n ## set new error definition\\n #\\n self.SetErrorDef ( nsigma * nsigma )\\n \\n graph = self.Contour ( npoint , par1 , par2 )\\n\\n #\\n ## restore old error defininion\\n #\\n status = self.GetStatus()\\n self.SetErrorDef ( old_err_def ) \\n #\\n if graph and 0 == status : return graph\\n logger.error ( 'TMinuit::Contour: status %i' % status ) \\n return graph\",\n \"def __init__(self,hdu_list,i_bin,fsk,mask_binary,masked_fraction,contaminants=None) :\\n #Read numbers map\\n self.fsk,nmap=read_flat_map(None,hdu=hdu_list[2*i_bin])\\n compare_infos(fsk,self.fsk)\\n\\n #Read N(z)\\n self.nz_data=hdu_list[2*i_bin+1].data.copy()\\n\\n #Make sure other maps are compatible\\n if not self.fsk.is_map_compatible(mask_binary) :\\n raise ValueError(\\\"Mask size is incompatible\\\")\\n if not self.fsk.is_map_compatible(masked_fraction) :\\n raise ValueError(\\\"Mask size is incompatible\\\")\\n if contaminants is not None :\\n for ic,c in enumerate(contaminants) :\\n if not self.fsk.is_map_compatible(c) :\\n raise ValueError(\\\"%d-th contaminant template is incompatible\\\"%ic)\\n \\n #Translate into delta map\\n self.masked_fraction=masked_fraction\\n self.weight=masked_fraction*mask_binary\\n goodpix=np.where(mask_binary>0.1)[0]\\n self.goodpix=goodpix\\n self.mask_binary=mask_binary\\n self.Ngal = np.sum(nmap*mask_binary)\\n ndens=np.sum(nmap*mask_binary)/np.sum(self.weight)\\n self.ndens_perad=ndens/(np.radians(self.fsk.dx)*np.radians(self.fsk.dy))\\n self.delta=np.zeros_like(self.weight)\\n self.delta[goodpix]=nmap[goodpix]/(ndens*masked_fraction[goodpix])-1\\n\\n #Reshape contaminants\\n conts=None\\n if contaminants is not None :\\n conts=[[c.reshape([self.fsk.ny,self.fsk.nx])] for c in contaminants]\\n\\n #Form NaMaster field\\n self.field=nmt.NmtFieldFlat(np.radians(self.fsk.lx),np.radians(self.fsk.ly),\\n self.weight.reshape([self.fsk.ny,self.fsk.nx]),\\n [self.delta.reshape([self.fsk.ny,self.fsk.nx])],\\n templates=conts)\",\n \"def AddContour(self, polyData):\\r\\n # research\\r\\n # called by drawIsoSurfaces\\r\\n profprint()\\r\\n # print polyData\\r\\n scene = slicer.mrmlScene\\r\\n modelNodes = slicer.util.getNodes('vtkMRMLModelNode*')\\r\\n # ??? i suppose here is a bug:\\r\\n print 'modelNodes: ', modelNodes\\r\\n print 'self.ContourNode: ', self.contourNode\\r\\n #!!! self.contourNode is None\\r\\n\\r\\n # bugfix>>>>\\r\\n modelNode = slicer.vtkMRMLModelNode()\\r\\n self.contourNode = modelNode.GetID()\\r\\n # print 'self.ContourNode: ', self.contourNode\\r\\n # <<<bugfix\\r\\n\\r\\n # contourNode = slicer.util.getNode(self.contourNode)\\r\\n # print 'contourNode: ',contourNode\\r\\n if self.contourNode != None:\\r\\n slicer.mrmlScene.RemoveNode(self.contourNode.GetStorageNode())\\r\\n self.contourNode.RemoveAllDisplayNodeIDs()\\r\\n slicer.mrmlScene.RemoveNode(self.contourNode)\\r\\n\\r\\n # modelNode = slicer.vtkMRMLModelNode()\\r\\n modelNode.SetScene(scene)\\r\\n modelNode.SetAndObservePolyData(polyData)\\r\\n # display node\\r\\n displayNode = slicer.vtkMRMLModelDisplayNode()\\r\\n\\r\\n modelNode.SetName('Contours')\\r\\n\\r\\n scene.AddNode(displayNode)\\r\\n scene.AddNode(modelNode)\\r\\n\\r\\n displayNode.SetVisibility(1)\\r\\n displayNode.SetOpacity(0.06)\\r\\n displayNode.SetSliceIntersectionVisibility(1)\\r\\n displayNode.SetScalarVisibility(1)\\r\\n displayNode.SetActiveScalarName('ImageScalars')\\r\\n displayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileHotToColdRainbow2.txt')\\r\\n displayNode.SetScalarRange(10, 40)\\r\\n displayNode.SetBackfaceCulling(0)\\r\\n displayNode.SetScene(scene)\\r\\n scene.AddNode(displayNode)\\r\\n modelNode.SetAndObserveDisplayNodeID(displayNode.GetID())\\r\\n # add to scene\\r\\n displayNode.SetInputPolyData(modelNode.GetPolyData())\\r\\n scene.AddNode(modelNode)\\r\\n\\r\\n # self.contourNode = modelNode.GetID()\\r\\n\\r\\n qt.QApplication.processEvents()\",\n \"def _decomposition_with_many_workers(control_wires, target_wire, work_wires):\\n num_work_wires_needed = len(control_wires) - 2\\n work_wires = work_wires[:num_work_wires_needed]\\n\\n work_wires_reversed = list(reversed(work_wires))\\n control_wires_reversed = list(reversed(control_wires))\\n\\n gates = []\\n\\n for i in range(len(work_wires)):\\n ctrl1 = control_wires_reversed[i]\\n ctrl2 = work_wires_reversed[i]\\n t = target_wire if i == 0 else work_wires_reversed[i - 1]\\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\\n\\n gates.append(qml.Toffoli(wires=[*control_wires[:2], work_wires[0]]))\\n\\n for i in reversed(range(len(work_wires))):\\n ctrl1 = control_wires_reversed[i]\\n ctrl2 = work_wires_reversed[i]\\n t = target_wire if i == 0 else work_wires_reversed[i - 1]\\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\\n\\n for i in range(len(work_wires) - 1):\\n ctrl1 = control_wires_reversed[i + 1]\\n ctrl2 = work_wires_reversed[i + 1]\\n t = work_wires_reversed[i]\\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\\n\\n gates.append(qml.Toffoli(wires=[*control_wires[:2], work_wires[0]]))\\n\\n for i in reversed(range(len(work_wires) - 1)):\\n ctrl1 = control_wires_reversed[i + 1]\\n ctrl2 = work_wires_reversed[i + 1]\\n t = work_wires_reversed[i]\\n gates.append(qml.Toffoli(wires=[ctrl1, ctrl2, t]))\\n\\n return gates\",\n \"def create_network(num_subs):\\n\\n # Need one host for each subscriber, one for a publisher, and one for a broker\\n n_hosts = num_subs + 2\\n\\n topo = SingleSwitchTopo(n=n_hosts)\\n\\n return Mininet(topo=topo, controller=OVSController)\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def getCV(file1, type, imgOri,iteration):\\n del s_arrays[:]\\n del shapesContours[:]\\n\\n if type == 'shapes':\\n spContours = getContours(imgOri,iteration)\\n file1.write(str(len(spContours)) + '\\\\n')\\n print(len(spContours))\\n spContours = clean_Con(spContours)\\n file1.write(str(len(spContours)) + '\\\\n')\\n print(len(spContours))\\n cv2.drawContours(imgOri, spContours, -1, (0, 255, 128), 5)\\n # del s_arrays[:]\\n # for each shape\\n for cons in spContours:\\n sampleComVector = []\\n x, y, w, h = cv2.boundingRect(cons)\\n cv2.rectangle(imgOri, (x, y), (x + w, y + h), (100, 100, 100), 1)\\n\\n # move the points to center\\n for point in cons:\\n sampleComVector.append(complex(point[0][0] - x, (point[0][1] - y)))\\n # sampleComVectors store CV of all testees contours\\n s_arrays.append(sampleComVector)\\n # sampleContours store all testees contours, same order with sampleComVectors\\n shapesContours.append(cons)\\n\\n elif type == 'temp':\\n # Automatically find templete contour\\n templetTrue = imgOri\\n tpContour = getContours(templetTrue,iteration)\\n for contour in tpContour:\\n x, y, w, h = cv2.boundingRect(contour)\\n #\\n for point in contour:\\n # -x and -y are to make left and upper boundry start from 0\\n t_array.append(complex(point[0][0] - x, (point[0][1] - y)))\",\n \"def _update_attributes(self,circuit_graph,name,lib_name,lib_graph, Gsub):\\n #PnR can route primitive power but not subckt power\\n if lib_name in self.all_lef:\\n pg = []\\n else:\\n pg = self.pg\\n G1 = circuit_graph\\n num = len([key for key in Gsub\\n if 'net' not in G1.nodes[key][\\\"inst_type\\\"]])\\n # Define ports for subblock\\n matched_ports = {}\\n ports_weight = {}\\n G2 = lib_graph.copy()\\n for g1_n, g2_n in Gsub.items():\\n if 'net' in G2.nodes[g2_n][\\\"inst_type\\\"]:\\n if 'external' in G2.nodes[g2_n][\\\"net_type\\\"]:\\n if num > 1 and g1_n in pg:\\n # remove power connections\\n G2=nx.relabel_nodes(G2,{g2_n:g1_n},copy=False)\\n else:\\n matched_ports[g2_n] = g1_n\\n ports_weight[g2_n] = []\\n for nbr in list(G2.neighbors(g2_n)):\\n ports_weight[g2_n].append(G2.get_edge_data(g2_n, nbr)['weight'])\\n else:\\n G2.nodes[g2_n]['values'] = G1.nodes[g1_n]['values']\\n G2.nodes[g2_n]['real_inst_type'] = G1.nodes[g1_n]['real_inst_type']\\n return matched_ports,ports_weight,G2\",\n \"def subdevice(self, center, leads, leads2):\\n\\n center = self.__s2m__(center,0)\\n\\n center_t = self.subsystem(center,center).simplified()\\n leads_t = []\\n connections_t = []\\n\\n for l_i,(l,l2) in enumerate(zip(leads,leads2)):\\n\\n l = self.__s2m__(l,0)\\n l2 = self.__s2m__(l2,0)\\n\\n # Lead\\n l_t = self.subsystem(l,l).simplified()\\n\\n # Lead replica\\n l2_t = self.subsystem(l2,l2).simplified()\\n\\n # Hoppings\\n l_b = self.subsystem(l,l2).simplified()\\n l_f = self.subsystem(l2,l).simplified()\\n\\n # Check if the lead belongs to the scattering region\\n if not set(l).issubset(set(center)):\\n raise ValueError(\\\"Lead {:d} does not completely belong to the central region\\\".format(l_i))\\n\\n # Check absence of overlap\\n center_without_lead = set(center) - set(l)\\n if self.subsystem(center_without_lead,l2).absmax() != 0 or self.subsystem(l2,center_without_lead).absmax() != 0:\\n raise ValueError(\\\"Lead replica {:d} interacts with the central region\\\".format(l_i))\\n\\n leads_t.append(TightBinding({\\n 0: l_t,\\n 1: l_f,\\n -1: l_b,\\n }))\\n\\n c = numpy.eye(self.shape[0], dtype = numpy.int)\\n connections_t.append(c[numpy.ix_(l, center)])\\n\\n return MultiterminalDevice(center_t, leads_t, connections_t)\",\n \"def simplify(self):\\n \\n added_clumps = []\\n staying_tunnels = []\\n removed_clumps = set()\\n \\n for tunnel in self.tunnels:\\n tunnel_end_distance = self.get_distance(tunnel.start, tunnel.end)\\n if tunnel_end_distance - tunnel.start.distance_from_wall < 0 or \\\\\\n tunnel_end_distance - tunnel.end.distance_from_wall < 0:\\n removed_clumps.add(tunnel.start.node)\\n removed_clumps.add(tunnel.end.node)\\n new_node = tunnel.merge_endpoints()\\n added_clumps.append(new_node)\\n else:\\n staying_tunnels.append(tunnel)\\n #print removed_clumps\\n \\n new_clumps = []\\n \\n for clump in list(self.clumps) + added_clumps:\\n if clump not in removed_clumps:\\n new_clumps.append(clump)\\n else:\\n removed_clumps.remove(clump)\\n\\n if removed_clumps:\\n raise Exception(\\\"Some removed clumps couldn't be found in the main set and I'm scared\\\")\\n \\n self.clumps = new_clumps\\n self.tunnels = staying_tunnels\",\n \"def dfsCC(G,vis,u):\\r\\n\\tvis[u] = True\\r\\n\\tfor v in G[u]:\\r\\n\\t\\tif vis[v] == False:\\r\\n\\t\\t\\tdfsCC(G,vis,v)\\r\\n\\treturn\",\n \"def __init__(self, nodes, infimum=1e-8):\\n self.nodes, (self.nn, self.dim) = nodes, nodes.shape\\n\\n # generate anisotropic simplices\\n delaunay = Delaunay(self.nodes)\\n simplices = delaunay.simplices\\n volumes = np.linalg.det(self.nodes[simplices[:, :-1]] - self.nodes[simplices[:, [-1]]])\\n valid_indices = [i for i, v in enumerate(volumes) if np.abs(v) > infimum]\\n simplices = simplices[valid_indices, :]\\n volumes = volumes[valid_indices]\\n\\n # generate mask of convex hull\\n mask = np.expand_dims(self.nodes[delaunay.convex_hull], axis=1) - np.expand_dims(self.nodes, axis=(0, 2))\\n self.mask = np.min(np.abs(np.linalg.det(mask)), axis=0) == 0\\n\\n # generate isotropic simplices\\n def reverse(spx): return spx[[0, 2, 1] + list(range(3, spx.__len__()))]\\n self.simplices = np.array([spx if flag else reverse(spx) for spx, flag in zip(simplices, volumes > 0)])\\n self.nt = self.simplices.shape[0]\\n\\n # generate isotropic surfaces of simplices.\\n self.surfaces = np.stack([np.roll(self.simplices, -k, 1) if k * self.dim % 2 else reverse(np.roll(self.simplices, -k, 1).T).T for k in range(self.dim + 1)], axis=1)[:, :, 1:]\\n\\n # generate minors and determinants of `tensor` in isotropic mode.\\n # +- x_{t,0,0} & \\\\cdots & x_{t,0,ND-1} & 1 -+\\n # tensor[t, :, :] = | \\\\vdots & \\\\ddots & \\\\vdots & \\\\vdots |\\n # +- x_{t,ND,0} & \\\\cdots & x_{t,ND,ND-1} & 1 -+\\n tensor = np.concatenate([self.nodes[self.simplices, :], np.ones(shape=(self.simplices.__len__(), self.dim + 1, 1))], axis=-1)\\n self.determinants = np.abs(volumes)\\n self.minors = np.einsum(\\\"tij,t->tji\\\", np.linalg.inv(tensor), self.determinants)\",\n \"def simplify(uniques, intersections, tolerance):\\n uniques_sm = [u.simplify(tolerance=tolerance) for u in uniques]\\n\\n intersections_sm = [[None for i in range(len(uniques))] for j in range(len(uniques))]\\n for i,s1 in enumerate(intersections):\\n for j,s2 in enumerate(s1):\\n if type(s2) is not shapely.geometry.GeometryCollection():\\n intersections_sm[i][j] = s2.simplify(tolerance=tolerance)\\n return uniques_sm, intersections_sm\",\n \"def __init__(self, _dicom_dir, _contour_dir, inner_outer='inner'):\\n\\n self.data = []\\n\\n #list of indices for labeled masks\\n self.labeled = []\\n\\n # iterate through all .dcm in the patient's dicom folder\\n dicom_files = os.listdir(_dicom_dir)\\n for dicom_file in dicom_files:\\n if not dicom_file.endswith('.dcm'):\\n pass\\n else:\\n idx = int(dicom_file[:-4])\\n\\n dcm = self.load_dicoms(_dicom_dir + \\\"/\\\" + dicom_file)\\n height, width = dcm.shape\\n\\n ctr_i_b = None\\n ctr_o_b = None\\n if inner_outer == 'inner':\\n ctr_i_b = self.load_contours(_contour_dir+'/i-contours/'+\\n 'IM-0001-{:04d}-icontour-manual.txt'.format(idx), width, height)\\n elif inner_outer == 'outer':\\n ctr_o_b = self.load_contours(_contour_dir+'/o-contours/'+\\n 'IM-0001-{:04d}-ocontour-manual.txt'.format(idx), width, height)\\n elif inner_outer == 'both':\\n ctr_i_b = self.load_contours(_contour_dir+'/i-contours/'+\\n 'IM-0001-{:04d}-icontour-manual.txt'.format(idx), width, height)\\n ctr_o_b = self.load_contours(_contour_dir+'/o-contours/'+\\n 'IM-0001-{:04d}-ocontour-manual.txt'.format(idx), width, height)\\n else:\\n ctr_i_b = None\\n ctr_o_b = None\\n\\n # if either inner or outer exists for given idx, add to self.labeled\\n if ctr_i_b is not None:\\n self.labeled.append(idx)\\n elif ctr_o_b is not None:\\n self.labeled.append(idx)\\n\\n self.data.append((idx, dcm, ctr_i_b, ctr_o_b))\",\n \"def __init__(self, prefix, downstream, upstream, root):\\n super(SubGraph, self).__init__(prefix, downstream, upstream, root)\",\n \"def method2(self):\\n cres=np.zeros(self.NL,dtype=float) # List of invariants\\n # The U matrices from Fukui's method; storage...\\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n for il in range(self.NL):\\n # ... and calculation of U matrices for each layer\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.LDM[il,ix ,iy ,:,:]\\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\\n \\n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\\n \\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\\n \\n return cres\",\n \"def smallClosNetwork():\\n \\n # Build a graph for Jupiter topo\\n switch_nodes, edges = tp.tree_topo()\\n G = build_graph(edges)\\n nodes, host_nodes, tors, anodes, snodes = tp.getnodes()\\n\\n print('**** is_connected(G)', nx.is_connected(G))\\n \\n \\n # Get the routing path of all nodes\\n table_file_name = '../outputs/tree_routing_table.txt'\\n if((os.path.isfile(table_file_name)) == False):\\n table = all_routing(G, tors+['e1'], table_file_name)\\n else:\\n json_data = open(table_file_name).read()\\n table = json.loads(json_data)\\n \\n print('**** Got routing table!')\\n\\n seeds, polys = cf.get_seeds_table_tree(switch_nodes) #\\n \\n return G, tors, edges, table, seeds, polys\",\n \"def SLTrace(self,NSL=100,Pts=[]):\\n TOF_end=[]\\n SL_end=[]\\n \\n for i in range(4): #4 Subgrids\\n \\n if(len(Pts)==0):\\n nsl=int(NSL*self.theta[i]/2/np.pi)\\n Pts_init=PointOnUnitEdge(nsl) #Generating the start point along the well edge(alpha=0)\\n else:\\n nsl=len(Pts)\\n Pts_init=Pts\\n \\n for j in range(nsl): #nsl streamlines\\n GridID=i\\n temp_trace=self.SubGrids[GridID].Trace1SL(Pts=Pts_init[j])\\n \\n SLtemp=RotateSL(temp_trace[3],Single=1,angle=self.SubGrids[GridID].RotateAngle)\\n SLtemp=TranslateSL(SLtemp,Single=1,new_origin=self.SubGrids[GridID].NewOrigin)\\n TOFtemp=temp_trace[5]\\n \\n flag=True\\n while (flag==True): #the streamline will continue travel in another subgrid\\n Pts_end=temp_trace[2][-1]\\n temp_neighbor=self.NeighborTest(GridID,Pts_end) #test of crossing trace of a streamline\\n flag=temp_neighbor[0]\\n if(flag==True):\\n temp_trace=[]\\n SLtemp2=[]\\n TOFtemp2=[]\\n \\n GridID_next=temp_neighbor[1]\\n Pts_init_next=temp_neighbor[2]\\n #Pts and TOF base starts from previous node\\n temp_trace=self.SubGrids[GridID_next].Trace1SL(Pts=Pts_init_next,TOF_base=TOFtemp[-1])\\n\\n SLtemp2=RotateSL(temp_trace[3],Single=1,angle=self.SubGrids[GridID_next].RotateAngle)\\n SLtemp2=TranslateSL(SLtemp2,Single=1,new_origin=self.SubGrids[GridID_next].NewOrigin)\\n TOFtemp2=temp_trace[5]\\n \\n #SLtemp=np.append(SLtemp,SLtemp2,axis=0)\\n #TOFtemp=np.append(TOFtemp,TOFtemp2,axis=0)\\n SLtemp=np.append(SLtemp,SLtemp2[1:],axis=0)\\n TOFtemp=np.append(TOFtemp,TOFtemp2[1:],axis=0)\\n \\n SL_end.append(SLtemp[-1])\\n TOF_end.append(TOFtemp[-1])\\n #Add all nodes and TOF into SL list\\n self.SL.append(SLtemp)\\n self.TOF.append(TOFtemp)\\n \\n \\n #Plot the stremline\\n plt.figure(figsize=(3, 3))\\n plt.ylim(bottom=0,top=50)\\n plt.xlim(left=0,right=50)\\n plt.axes().set_aspect('equal')\\n plt.title(r'Streamline in Physical Space ($x,y$)')\\n \\n #Grid edge\\n Bound_vert=[self.Pts[0],self.Pts[1],self.Pts[2],self.Pts[3],self.Pts[0]]\\n Internal_edge=[self.Pts[0],self.Pts[2],self.Pts[3],self.Pts[1]]\\n \\n plt.plot(*np.asarray(Bound_vert).T,lw=3,color='red')\\n plt.plot(*np.asarray(Internal_edge).T,lw=2,ls='--',color='red')\\n \\n #Streamline\\n for i in range(len(self.SL)):\\n plt.plot(*np.asarray(self.SL[i]).T,lw=1,marker='o',markersize=0,color='blue')\\n \\n\\n\\n plt.show()\\n return self.SL,self.TOF,SL_end,TOF_end\",\n \"def simplified_graph(input_smiles, iso_flag=True):\\n mol = Chem.MolFromSmiles(input_smiles)\\n for atom in mol.GetAtoms():\\n atom.SetFormalCharge(0)\\n if atom.IsInRing():\\n atom.SetAtomicNum(6)\\n atom.SetIsAromatic(False)\\n for bond in atom.GetBonds():\\n bond.SetBondType(Chem.BondType.SINGLE)\\n if not iso_flag:\\n atom.SetChiralTag(Chem.ChiralType.CHI_OTHER)\\n return Chem.MolToSmiles(mol, isomericSmiles=True)\",\n \"def drawShadedContours(xlist, ylist, zmatrix, levels):\\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))\",\n \"def monolayer_4band():\\n a = 0.222\\n ax = 0.438\\n ay = 0.332\\n theta = 96.79 * (pi / 180)\\n phi = 103.69 * (pi / 180)\\n\\n lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])\\n\\n h = a * sin(phi - pi / 2)\\n s = 0.5 * ax - a * cos(theta / 2)\\n lat.add_sublattices(\\n ('A', [0, 0, h], 0),\\n ('B', [s, 0, 0], 0),\\n ('C', [ax/2, ay/2, 0], 0),\\n ('D', [ax/2 + s, ay/2, h], 0)\\n )\\n\\n lat.register_hopping_energies({\\n 't1': -1.22,\\n 't2': 3.665,\\n 't3': -0.205,\\n 't4': -0.105,\\n 't5': -0.055\\n })\\n\\n lat.add_hoppings(\\n # t1\\n ([-1, 0], 'A', 'D', 't1'),\\n ([-1, -1], 'A', 'D', 't1'),\\n ([ 0, 0], 'B', 'C', 't1'),\\n ([ 0, -1], 'B', 'C', 't1'),\\n # t2\\n ([ 0, 0], 'A', 'B', 't2'),\\n ([ 0, 0], 'C', 'D', 't2'),\\n # t3\\n ([ 0, 0], 'A', 'D', 't3'),\\n ([ 0, -1], 'A', 'D', 't3'),\\n ([ 1, 1], 'C', 'B', 't3'),\\n ([ 1, 0], 'C', 'B', 't3'),\\n # t4\\n ([ 0, 0], 'A', 'C', 't4'),\\n ([ 0, -1], 'A', 'C', 't4'),\\n ([-1, 0], 'A', 'C', 't4'),\\n ([-1, -1], 'A', 'C', 't4'),\\n ([ 0, 0], 'B', 'D', 't4'),\\n ([ 0, -1], 'B', 'D', 't4'),\\n ([-1, 0], 'B', 'D', 't4'),\\n ([-1, -1], 'B', 'D', 't4'),\\n # t5\\n ([-1, 0], 'A', 'B', 't5'),\\n ([ 0, 1], 'A', 'B', 't5'),\\n ([ 0, -1], 'A', 'B', 't5'),\\n ([-1, 0], 'C', 'D', 't5'),\\n ([ 0, 1], 'C', 'D', 't5'),\\n ([ 0, -1], 'C', 'D', 't5'),\\n )\\n\\n return lat\",\n \"def test_1_1_2D_rec_init(self): # TODO: REMOVE FUNC AFTER SPLIT\\n check = [(-1.0, -2.0), (7.0, 6.0), (7.0, -2.0), (-1.0, 6.0), (3.0, 2.0)]\\n nn_checks = {(-1.0, -2.0): [(7, -2), (3.0, 2.0), (-1, 6)],\\n (7.0, 6.0): [(7, -2), (3.0, 2.0), (-1, 6)],\\n (7.0, -2.0): [(7, 6), (3.0, 2.0), (-1, -2)]}\\n init_triangulation(2, 0, check, nn_checks, bounds=[(-1, 7), (-2, 6)])\",\n \"def complex_network_mapping(graph):\\n vect = []\\n\\n n = nx.number_of_nodes(graph)\\n e = nx.number_of_edges(graph)\\n print n, e\\n\\n# adj = nx.adjacency_matrix(graph).toarray()\\n# adj_bin = np.where(adj > 0, 1., 0.)\\n# adj_conn = 1 - adj\\n adj_bin = nx.adjacency_matrix(graph).toarray()\\n adj_bin = np.array(adj_bin, dtype=np.float)\\n\\n # Node Betweenness binary\\n bt_bin = nx.betweenness_centrality(graph).values()\\n avg_btb = np.mean(bt_bin)\\n vect.append(avg_btb)\\n\\n # Edge betweenness\\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\\n vect.append(np.mean(ebt))\\n\\n # Eigen vector centrality binary\\n evc_bin = eigenvector_centrality_und(adj_bin)\\n avg_evcb = np.mean(evc_bin)\\n vect.append(avg_evcb)\\n\\n # Flow coefficient\\n _, flow_bin, _ = flow_coef_bd(adj_bin)\\n avg_flow = np.mean(flow_bin)\\n vect.append(avg_flow)\\n\\n # Kcoreness centrality\\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\\n avg_kcor = np.mean(kcor_bin)\\n vect.append(avg_kcor)\\n\\n # Degree assortivity\\n dac = nx.degree_assortativity_coefficient(graph)\\n vect.append(dac)\\n\\n # Page rank centrality\\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\\n# avg_pgr = np.mean(pgr_wei)\\n# vect.append(avg_pgr)\\n\\n # Rich club coefficient\\n# rcc = nx.rich_club_coefficient(graph).values()\\n# avg_rcc = np.mean(rcc)\\n# vect.append(avg_rcc)\\n\\n # Transitivity\\n tr = nx.transitivity(graph)\\n vect.append(tr)\\n\\n # average clustering\\n avg_clst = nx.average_clustering(graph)\\n vect.append(avg_clst)\\n\\n glb_ef = efficiency_bin(adj_bin)\\n vect.append(glb_ef)\\n\\n return vect\",\n \"def FindMatchesAndRemovals(scListA, scListB, searchInds=None):\\n scsMatchedInB = []\\n removeFromA = []\\n removeFromB = []\\n\\n if searchInds is None:\\n searchInds = list(range(len(scListA)))\\n\\n for ind in searchInds:\\n sca = scListA[ind]\\n # Look for each sc from A in B:\\n matchTuples = [\\n (i, scb) for i, scb in enumerate(scListB) if sca.values == scb.values\\n ]\\n matchInds, matches = zip(*matchTuples)\\n\\n if len(matches) == 0:\\n print(\\\"sc in A but not in B:\\\", sca.values, matches)\\n sp, ep = sca.startPointValues, sca.endPointValues\\n # get the values connected to the subcontour only at the corners:\\n opposingValues = tuple(\\n sorted(list(set(sp).union(ep).difference(sca.values)))\\n )\\n # get the sc's from B that have these values as their main values (aka, sca switched to this/these)\\n matchOppTuples = [\\n (i, scb)\\n for i, scb in enumerate(scListB)\\n if scb.values == opposingValues\\n ]\\n matchOppInds, matchesOpp = zip(*matchOppTuples)\\n\\n if matchesOpp == []:\\n print(\\\"Not Recoverable!\\\")\\n else:\\n print(\\n \\\"Recoverable: sc in A at index\\\",\\n ind,\\n sca.values,\\n \\\"matches to sc in B at index\\\",\\n matchOppInds[0],\\n matchesOpp[0].values,\\n )\\n print(scListA[ind])\\n removeFromA.append(\\n ind\\n ) # actually DO the removals later so we don't muck up the indexing!\\n removeFromB.append(matchOppInds[0])\\n scsMatchedInB.append(matchOppInds[0])\\n\\n if len(matchesOpp) > 1:\\n print(\\\"More than 1 match!\\\")\\n\\n elif len(matches) > 1:\\n print(\\\"sc in A matches multiple sc's in B:\\\", sca.values, matches)\\n else:\\n scsMatchedInB.append(matchInds[0])\\n\\n # Also check all the start and end points:\\n # This stuff isn't really being used right now...\\n sp1, sp2 = sca.startPointValues, matches[0].startPointValues\\n if sp1 != sp2:\\n print(\\\"start points don't match\\\", sp1, sp2)\\n ep1, ep2 = sca.endPointValues, matches[0].endPointValues\\n if ep1 != ep2:\\n print(\\\"end points don't match\\\", ep1, ep2)\\n\\n return scsMatchedInB, removeFromA, removeFromB\",\n \"def __init__(self, in_classes=1, channelscale=64):\\n super(DetectPatchAndSegm, self).__init__()\\n self.unetvgg1 = UNetSimple(in_classes=in_classes, channelscale=64, out_classes=2)#UNetVgg()\\n self.unetvgg2 = UNetSimple(in_classes=3, channelscale=128, out_classes=3)#in is 2 patches and original image\\n self.sft = nn.Softmax2d()\",\n \"def slice_graph_fwd( startea, reg ): \\r\\n\\tgraph = vcg_Graph.vcgGraph({\\\"title\\\":'\\\"Slice for %s\\\"' % reg, \\\\\\r\\n\\t\\t\\\"manhattan_edges\\\":\\\"no\\\", \\\"layoutalgorithm\\\":\\\"maxdepth\\\"})\\r\\n\\t#\\r\\n\\t# Retrieve the name of the current basic block\\r\\n\\t# \\r\\n\\tworklist = []\\r\\n\\tdata_bib = {}\\r\\n\\tstartnode = slice_node( startea, 0, reg )\\r\\n\\trootnode = graph.Add_Node( startnode.to_name() )\\r\\n\\tdata_bib[ startnode.to_name() ] = startnode\\r\\n\\tworklist.insert( 0, rootnode )\\r\\n\\twhile len( worklist ) > 0:\\r\\n\\t\\tcurrnode = worklist.pop()\\r\\n\\t\\tcurrslice = data_bib[ currnode.get_name() ]\\r\\n\\t\\ttgt_reg = currslice.get_target_reg()\\r\\n\\t\\tif tgt_reg == \\\"END\\\":\\r\\n\\t\\t# Do not process this node any further\\r\\n\\t\\t\\tpass\\r\\n\\t\\telif tgt_reg == \\\"\\\" or (( len( currslice.get_lines()) > 0) and \\\\\\r\\n\\t\\t\\tcurrslice.endea != currslice.get_lines()[-1][0]):\\r\\n\\t\\t\\t# Nothing much happening here, just proceed to parent bocks\\r\\n\\t\\t\\tif ua_mnem( currslice.endea ) == \\\"call\\\":\\r\\n\\t\\t\\t\\txrefs = get_short_crefs_from( currslice.endea )\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\txrefs = get_crefs_from( currslice.endea )\\r\\n\\t\\t\\tfor ref in xrefs:\\r\\n\\t\\t\\t\\tnewslice = slice_node( ref, 0, currslice.reg )\\r\\n\\t\\t\\t\\tif graph.Get_Node( newslice.to_name() ) == 0:\\r\\n\\t\\t\\t\\t\\tnewnode = graph.Add_Node( newslice.to_name() )\\r\\n\\t\\t\\t\\t\\tworklist.insert( 0, newnode )\\r\\n\\t\\t\\t\\t\\tdata_bib[ newslice.to_name() ] = newslice\\r\\n\\t\\t\\t\\tgraph.Add_Link( currnode.get_name(), newslice.to_name())\\r\\n\\t\\telse:\\r\\n\\t\\t\\t# Register was modified, use new register\\r\\n\\t\\t\\txrefs = get_crefs_from( currslice.endea )\\r\\n\\t\\t\\tfor ref in xrefs:\\r\\n\\t\\t\\t\\tnewslice = slice_node( ref, 0, tgt_reg )\\r\\n\\t\\t\\t\\tif graph.Get_Node( newslice.to_name() ) == 0:\\r\\n\\t\\t\\t\\t\\tnewnode = graph.Add_Node( newslice.to_name() )\\r\\n\\t\\t\\t\\t\\tworklist.insert( 0, newnode )\\r\\n\\t\\t\\t\\t\\tdata_bib[ newslice.to_name() ] = newslice\\r\\n\\t\\t\\t\\tgraph.Add_Link( currnode.get_name(), newslice.to_name())\\r\\n\\t\\t\\txrefs = get_crefs_from( currslice.endea )\\r\\n\\t\\t\\tfor ref in xrefs:\\r\\n\\t\\t\\t\\tnewslice = slice_node( ref, 0, currslice.reg )\\r\\n\\t\\t\\t\\tif graph.Get_Node( newslice.to_name() ) == 0:\\r\\n\\t\\t\\t\\t\\tnewnode = graph.Add_Node( newslice.to_name() )\\r\\n\\t\\t\\t\\t\\tworklist.insert( 0, newnode )\\r\\n\\t\\t\\t\\t\\tdata_bib[ newslice.to_name() ] = newslice\\r\\n\\t\\t\\t\\tgraph.Add_Link( currnode.get_name(), newslice.to_name())\\r\\n\\treturn [ graph, data_bib ]\",\n \"def simplify_network(network):\\n network_proj = ox.project_graph(network)\\n simplified_proj = ox.consolidate_intersections(network_proj, rebuild_graph=True, tolerance=50, dead_ends=False)\\n simplified = ox.project_graph(simplified_proj, network.graph[\\\"crs\\\"])\\n return simplified\",\n \"def manual_cliques(adj_list,cliques):\\n G = nx.Graph()\\n for clique in cliques:\\n for n1 in clique:\\n for n2 in clique:\\n if n1 != n2:\\n G.add_edge(adj_list[n1],adj_list[n2])\\n \\n n1 = cliques[0][0]\\n for idx,clique in enumerate(cliques):\\n if idx > 0:\\n n2 = clique[2]\\n G.add_edge(adj_list[n1],adj_list[n2])\\n n1 = clique[0]\\n \\n #Attach head and tail cliques\\n n1 = cliques[0][3]\\n n2 = cliques[len(cliques) - 1][1]\\n G.add_edge(adj_list[n1],adj_list[n2])\\n return G\",\n \"def SSC_test():\\n \\n # generating data\\n\\n D = 40 # Dimension of ambient space\\n k = 4 # Number of subspaces\\n d = 1\\n N = 90 # Number of points in subspaces\\n # Generating N points in d dim. subspaces\\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\\n for _ in range(k)]\\n X = np.concatenate(Xi, axis=1)\\n\\n # Generating the ground-truth for evaluating clustering results\\n lbls = [i * np.ones([1, N]) for i in range(k)]\\n s = np.concatenate(lbls, axis=1)\\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\\n K = 0 #max(d1, d2)\\n if Cst == 1:\\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\\n\\n Xp = DataProjection(X, r, 'NormalProj')\\n \\n # testing clustering\\n \\n '''\\n # using wrapper function\\n Grps, sc = sparseSubspaceClustering(\\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n '''\\n \\n '''\\n # calling internal tools\\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\\n # Make small values 0\\n eps = np.finfo(float).eps\\n CMat[np.abs(CMat) < eps] = 0\\n\\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\\n\\n if Fail == False:\\n CKSym = BuildAdjacency(CMatC, K)\\n Grps = SpectralClustering(CKSym, n)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n else:\\n print(\\\"Something failed\\\")\\n '''\\n \\n labels, _, __ = KSubspaces(Xp.T, k, d)\\n labels = BestMap(s, labels)\\n Missrate = float(np.sum(s != labels)) / s.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\",\n \"def prog(args):\\r\\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\\r\\n mesh = stl.mesh.Mesh.from_file(i_fname)\\r\\n #rotate mesh since by default the rotation axis is along X\\r\\n mesh.rotate([0,1,0],np.pi/2)\\r\\n\\r\\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\\r\\n\\r\\n splt0_arr = np.array(split_list)\\r\\n splt1_arr = np.roll(splt0_arr,-1)\\r\\n\\r\\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\\r\\n\\r\\n #make splits\\r\\n pos_list=[]\\r\\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\\r\\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\\r\\n print(splt0, splt1)\\r\\n #pos = [r, th, z] sectionwise\\r\\n pos_list.append(pos[pos_idx])\\r\\n #add pedestal mesh\\r\\n\\r\\n for sect_num, pos in enumerate(pos_list):\\r\\n pos = cf.add_pedestal(pos, pedestal_params)\\r\\n profiles=np.zeros_like(pos)\\r\\n\\r\\n for i in np.arange(np.shape(pos)[0]):\\r\\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\\r\\n\\r\\n strokes = np.flipud(np.rot90(profiles))\\r\\n #transform data from longeron nodes [xyz] to:\\r\\n #a_arr - rotation angle around the rotation axis\\r\\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\\r\\n #z_arr - corresponding z coordiantes\\r\\n #v_arr - direction vector of the coresponding lateral mesh edge\\r\\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\\r\\n\\r\\n #make a summary plots\\r\\n cf.plot_loft_paths(profiles)\\r\\n cf.plot_loft_paths(pos)\\r\\n cf.plot_surf(a_arr,z_arr,r_arr)\\r\\n\\r\\n #collect data to the dictionary longeron wise\\r\\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\\r\\n 'r_arr':np.rot90(r_arr, k=-1),\\r\\n 'z_arr':np.rot90(z_arr, k=-1),\\r\\n 'v_arr':np.rot90(v_arr, k=-1)}\\r\\n\\r\\n #save result dictionary\\r\\n if not o_fname:\\r\\n o_fname = i_fname\\r\\n\\r\\n fname='{}_{}.pickle'.format(o_fname, sect_num)\\r\\n with open(fname, 'wb') as f:\\r\\n # Pickle the 'data' dictionary using the highest protocol available.\\r\\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\\r\\n\\r\\n print(fname, ' saved')\",\n \"def __init__(self, device=\\\"cuda:0\\\", *args, **kwargs):\\n # source_file_wtsd = \\\"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\\\"\\n source_file_wtsd = \\\"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\\\"\\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \\\"r\\\")[\\\"data\\\"][:].astype(np.long)).to(device)\\n slices = [0, 157, 316]\\n slices_labels = [[1359, 1172, 364, 145, 282, 1172, 1359, 189, 809, 737],\\n [886, 748, 1148, 1422, 696, 684, 817, 854, 158, 774],\\n [1240, 807, 1447, 69, 1358, 1240, 129, 252, 62, 807]]\\n m1, m2 = [], []\\n # widths, heights = [], []\\n self.outer_cntr_ds, self.inner_cntr_ds = [], []\\n for slc, labels in zip(slices, slices_labels):\\n bg = wtsd[:, slc, :] == 1\\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\\n #\\n # for l in labels:\\n # mask = wtsd[:, slc, :] == l\\n # cnt = find_contours(mask.cpu().numpy(), level=0)[0]\\n #\\n # # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # # img[cnt[:, 0], cnt[:, 1]] = 1\\n # # plt.imshow(img);plt.show()\\n #\\n # ellipseT = fitEllipse(cnt.astype(np.int))\\n # widths.append(ellipseT[1][1])\\n # heights.append(ellipseT[1][0])\\n #\\n #\\n #\\n # self.masses = [np.array(m1).mean(), np.array(m2).mean()]\\n # self.expected_ratio = np.array(widths).mean() / np.array(heights).mean()\\n self.expected_ratio = 5.573091\\n self.masses = [290229.3, 97252.3]\",\n \"def buildConnectedSets(self, cars):\",\n \"def show_subgraph(dfs_codes, nsupport, mapper):\\n\\tglobal __subgraph_count\\n\\n\\tg = build_graph(dfs_codes)\\n\\tg.id = __subgraph_count\\n\\t__subgraph_count += 1\\n\\tg.gprint(nsupport, mapper)\",\n \"def collect_subinstances(img_list, subinstance_size, clickable_size):\\n num_files = len(img_list)\\n step_size = subinstance_size // 2\\n num_subinstances = 0\\n for i in range(num_files):\\n num_rows = int(np.ceil((2.0 * img_list[i].shape[0] / float(subinstance_size)) - 1.0))\\n num_cols = int(np.ceil((2.0 * img_list[i].shape[1] / float(subinstance_size)) - 1.0))\\n num_subinstances += num_rows * num_cols\\n #print(str(i) + \\\"-th image: \\\" + \\\"num_rows = \\\" + str(num_rows) + \\\", num_cols = \\\" + str(num_cols) + \\\", #(sub_files) = \\\", str(num_subinstances))\\n \\n print(\\\"#(subinstances) =\\\", num_subinstances)\\n \\n expand = (subinstance_size // clickable_size)\\n \\n subinstance_list = [None] * expand * expand * num_subinstances\\n subinstance_org_loc_list = [None] * expand * expand * num_subinstances\\n \\n patch_i = 0\\n for i in range(num_files):\\n num_rows = int(np.ceil((2.0 * img_list[i].shape[0] / float(subinstance_size)) - 1.0))\\n num_cols = int(np.ceil((2.0 * img_list[i].shape[1] / float(subinstance_size)) - 1.0))\\n for j in range(num_rows):\\n for k in range(num_cols):\\n for l in range(expand):\\n for m in range(expand):\\n try:\\n subinstance_list[patch_i * expand * expand + l * expand + m ] \\\\\\n = img_list[i][step_size * j + l * clickable_size : step_size * j + (l + 1) * clickable_size,\\n step_size * k + m * clickable_size : step_size * k + (m + 1) * clickable_size]\\n except IndexError:\\n sys.stdout.write(\\\"ERROR: images are not normalized.\\\\n\\\")\\n exit(0)\\n subinstance_org_loc_list[patch_i * expand * expand + l * expand + m ] \\\\\\n = (i, (step_size * j + l * clickable_size,\\n step_size * k + m * clickable_size,\\n clickable_size,\\n clickable_size))\\n patch_i += 1\\n\\n if patch_i != num_subinstances:\\n sys.stdout.write(\\\"ERROR: the number of subinstances is not consistent.\\\\n\\\")\\n exit(-1)\\n return subinstance_list, subinstance_org_loc_list\",\n \"def build_curvilinear_connection(debug):\\n\\n MV.connection = True\\n MV.tangent_norm = Vector.norm\\n MV.tangent_derivatives_MV = {}\\n\\n rcpr_bases_MV = []\\n\\n for (rbase, norm) in zip(MV.rcpr_bases_MV, MV.tangent_norm):\\n rcpr_bases_MV.append(rbase / norm)\\n\\n MV.rcpr_bases_MV = rcpr_bases_MV\\n\\n for key in Vector.dtau_dict.keys():\\n MV.tangent_derivatives_MV[key] = MV(Vector.dtau_dict[key])\\n\\n if debug:\\n oprint('Tangent Vector Derivatives', MV.tangent_derivatives_MV, dict_mode=True)\\n\\n MV.left_connection = {}\\n MV.right_connection = {}\\n MV.left_wedge_connection = {}\\n MV.right_wedge_connection = {}\\n MV.left_dot_connection = {}\\n MV.right_dot_connection = {}\\n\\n for base in MV.blades[1]:\\n right_result = MV()\\n left_result = MV()\\n for (coord, rblade) in zip(MV.coords, MV.rcpr_bases_MV):\\n left_result += rblade * MV.tangent_derivatives_MV[(base, coord)]\\n right_result += MV.tangent_derivatives_MV[(base, coord)] * rblade\\n left_result.obj = expand(left_result.obj)\\n right_result.obj = expand(right_result.obj)\\n left_result.discover_and_set_grade()\\n right_result.discover_and_set_grade()\\n MV.left_connection[base] = left_result.obj\\n MV.right_connection[base] = right_result.obj\\n MV.left_wedge_connection[base] = left_result.grade(2).obj\\n MV.right_wedge_connection[base] = right_result.grade(2).obj\\n MV.left_dot_connection[base] = left_result.grade(0).obj\\n MV.right_dot_connection[base] = right_result.grade(0).obj\\n\\n for grade in MV.blades[2:]:\\n for blade in grade:\\n index = MV.blade_to_index[blade]\\n N = len(index)\\n left_result = MV()\\n right_result = MV()\\n for (coord, rblade) in zip(MV.coords, MV.rcpr_bases_MV):\\n tmp = MV()\\n for i in range(N):\\n i_pre = index[:i]\\n i_dtan = index[i]\\n i_post = index[i + 1:]\\n base = MV.blades[1][i_dtan]\\n tmp += (MV(MV.index_to_blade[i_pre]) ^ MV.tangent_derivatives_MV[(base, coord)]) ^ MV(MV.index_to_blade[i_post])\\n left_result += rblade * tmp\\n right_result += tmp * rblade\\n left_result.discover_and_set_grade()\\n right_result.discover_and_set_grade()\\n MV.left_connection[blade] = left_result.obj\\n MV.right_connection[blade] = right_result.obj\\n MV.left_wedge_connection[blade] = left_result.grade(N + 1).obj\\n MV.right_wedge_connection[blade] = right_result.grade(N + 1).obj\\n MV.left_dot_connection[blade] = left_result.grade(abs(N - 1)).obj\\n MV.right_dot_connection[blade] = right_result.grade(abs(N - 1)).obj\\n\\n MV.connection = {'left': MV.left_connection, 'right': MV.right_connection,\\n 'left_wedge': MV.left_wedge_connection, 'right_wedge': MV.right_wedge_connection,\\n 'left_dot': MV.left_dot_connection, 'right_dot': MV.right_dot_connection}\\n MV.grad.connection = MV.connection\\n\\n if debug:\\n oprint('Left Mutlivector Connection', MV.left_connection,\\n 'Right Mutlivector Connection', MV.right_connection,\\n 'Left Wedge Mutlivector Connection', MV.left_wedge_connection,\\n 'Right Wedge Mutlivector Connection', MV.right_wedge_connection,\\n 'Left Dot Mutlivector Connection', MV.left_dot_connection,\\n 'Right Dot Mutlivector Connection', MV.right_dot_connection, dict_mode=True)\\n return\",\n \"def vsn_func_1(ns, traj, vs_def_beads_ids):\\n for ts in ns.aa2cg_universe.trajectory:\\n traj[ts.frame] = ns.aa2cg_universe.atoms[vs_def_beads_ids].center_of_geometry(pbc=None)\",\n \"def _compute_topology(self, initial_surfaces):\\n\\n nsurf = len(initial_surfaces)\\n surfaces = numpy.zeros((nsurf, 3, 3, 3), float, 'F')\\n\\n for isurf in xrange(nsurf):\\n surface = initial_surfaces[isurf]\\n num_u, num_v = surface.shape[:2]\\n mid_u1 = int(numpy.floor((num_u - 1) / 2.0))\\n mid_u2 = int(numpy.ceil((num_u - 1) / 2.0))\\n mid_v1 = int(numpy.floor((num_v - 1) / 2.0))\\n mid_v2 = int(numpy.ceil((num_v - 1) / 2.0))\\n\\n for ind_u in xrange(2):\\n for ind_v in xrange(2):\\n surfaces[isurf, -ind_u, -ind_v] = surface[-ind_u, -ind_v]\\n\\n for ind_u in xrange(2):\\n surfaces[isurf, -ind_u, 1] += 0.5 * surface[-ind_u, mid_v1] + \\\\\\n 0.5 * surface[-ind_u, mid_v2]\\n\\n for ind_v in xrange(2):\\n surfaces[isurf, 1, -ind_v] += 0.5 * surface[mid_u1, -ind_v] + \\\\\\n 0.5 * surface[mid_u2, -ind_v]\\n\\n nvert, nedge, surf_ptrs \\\\\\n = BSElib.computesurfconnectivities(nsurf, 1e-16, 1e-10, surfaces)\\n\\n edge_ptrs \\\\\\n = BSElib.computeedgeconnectivities(nsurf, nedge, surf_ptrs)\\n\\n ngroup, surf_group, edge_group \\\\\\n = BSElib.computegroups(nsurf, nedge, surf_ptrs)\\n\\n topology = [nvert, nedge, ngroup, \\\\\\n surf_ptrs, edge_ptrs, \\\\\\n surf_group, edge_group, \\\\\\n ]\\n\\n return topology\",\n \"def second_level_covariate(contrast_list, experiment_dir, first_level_dir, output_dir, cov_ls, mask_path='/data/group_mask.nii.gz', working_dir='workingdir'):\\n # Gunzip - unzip the mask image\\n gunzip = Node(Gunzip(in_file=mask_path), name=\\\"gunzip\\\")\\n\\n # covariates (a list of items which are a dictionary with keys which are 'vector' or 'name' or 'interaction' or 'centering' and with values which are any value)\\n covariates_ls = [dict(vector=cov_ls, name='model_evidence')]\\n\\n # OneSampleTTestDesign - creates one sample T-Test Design\\n onesamplettestdes = Node(OneSampleTTestDesign(covariates=covariates_ls),\\n name=\\\"onesampttestdes\\\")\\n\\n # EstimateModel - estimates the model\\n level2estimate = Node(EstimateModel(estimation_method={'Classical': 1}),name=\\\"level2estimate\\\")\\n\\n # EstimateContrast - estimates group contrast\\n level2conestimate = Node(EstimateContrast(group_contrast=True),\\n name=\\\"level2conestimate\\\")\\n cont1 = ['Group', 'T', ['mean'], [1]]\\n level2conestimate.inputs.contrasts = [cont1]\\n\\n # Threshold - thresholds contrasts\\n level2thresh = Node(Threshold(contrast_index=1,\\n use_topo_fdr=True,\\n # use_fwe_correction=True,\\n use_fwe_correction=False,\\n extent_threshold=0,\\n height_threshold=0.001,\\n # height_threshold=0.05,\\n height_threshold_type='p-value',\\n extent_fdr_p_threshold=0.05),\\n name=\\\"level2thresh\\\")\\n\\n # Infosource - a function free node to iterate over the list of subject names\\n infosource = Node(IdentityInterface(fields=['contrast_id']),\\n name=\\\"infosource\\\")\\n infosource.iterables = [('contrast_id', contrast_list)]\\n\\n # SelectFiles - to grab the data (alternativ to DataGrabber)\\n firstlev_dir = opj(experiment_dir, first_level_dir, '1stLevel')\\n templates = {'cons': opj(firstlev_dir, 'sub-*',\\n '{contrast_id}.nii')}\\n selectfiles = Node(SelectFiles(templates,\\n base_directory=experiment_dir,\\n sort_filelist=True),\\n name=\\\"selectfiles\\\")\\n\\n # Datasink - creates output folder for important outputs\\n datasink = Node(DataSink(base_directory=experiment_dir,\\n container=output_dir),\\n name=\\\"datasink\\\")\\n\\n # Use the following DataSink output substitutions\\n substitutions = [('_contrast_id_', '')]\\n datasink.inputs.substitutions = substitutions\\n\\n # Initiation of the 2nd-level analysis workflow\\n l2analysis = Workflow(name='l2analysis')\\n l2analysis.base_dir = opj(experiment_dir, working_dir)\\n\\n # Connect up the 2nd-level analysis components\\n l2analysis.connect([(infosource, selectfiles, [('contrast_id', 'contrast_id')]),\\n (selectfiles, onesamplettestdes, [('cons', 'in_files')]),\\n (gunzip, onesamplettestdes, [('out_file',\\n 'explicit_mask_file')]),\\n (onesamplettestdes, level2estimate, [('spm_mat_file', 'spm_mat_file')]),\\n (level2estimate, level2conestimate, [('spm_mat_file', 'spm_mat_file'),\\n ('beta_images', 'beta_images'),\\n ('residual_image', 'residual_image')]),\\n (level2conestimate, level2thresh, [('spm_mat_file',\\n 'spm_mat_file'),\\n ('spmT_images',\\n 'stat_image'),\\n ]),\\n (level2conestimate, datasink, [('spm_mat_file',\\n '2ndLevel.@spm_mat'),\\n ('spmT_images',\\n '2ndLevel.@T'),\\n ('con_images',\\n '2ndLevel.@con')]),\\n (level2thresh, datasink, [('thresholded_map',\\n '2ndLevel.@threshold')]),\\n ])\\n return l2analysis\",\n \"def cfdProcessNodeTopology(self):\\r\\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\\r\\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)\",\n \"def connect_back(simulation_dict, (index_from, blocks_per_dim_from), (index_to, blocks_per_dim_to), square_size, radius, context_factor):\\n logging.info(\\\"Connecting back additional context from index %d to index %d\\\" % (index_from, index_to))\\n logging.info(\\\"Connecting back additional context from layer size is %d, receiving layer size is %d\\\" % (blocks_per_dim_from, blocks_per_dim_to))\\n logging.info(\\\"Radius of connectivity %d\\\" % radius)\\n for x in range(blocks_per_dim_from):\\n for y in range(blocks_per_dim_from):\\n surround = get_fan_in((x, y),\\n dim_x_l=blocks_per_dim_to,\\n dim_y_l=blocks_per_dim_to,\\n dim_x_u=blocks_per_dim_from,\\n dim_y_u=blocks_per_dim_from,\\n block_x=square_size,\\n block_y=square_size,\\n radius=radius)\\n source = index_from + x * (blocks_per_dim_from) + y # unit in the higher layer\\n for xy in surround:\\n dest = index_to + xy[0] * blocks_per_dim_to + xy[1] # unit in the lower layer\\n context_block = simulation_dict['stage0'][source]['output_block']\\n delta_block2 = SharedArray.SharedNumpyArray_like(context_block)\\n simulation_dict['stage0'][source]['delta_blocks'].append(delta_block2)\\n # Connect the context block to the source\\n simulation_dict['stage0'][dest]['context_blocks'].append((context_block, delta_block2, context_factor))\",\n \"def __init__(self, device=\\\"cuda:0\\\", *args, **kwargs):\\n source_file_wtsd = \\\"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\\\"\\n source_file_wtsd = \\\"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\\\"\\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \\\"r\\\")[\\\"data\\\"][:].astype(np.long)).to(device)\\n slices = [0, 157, 316]\\n label_1 = [1359, 886, 1240]\\n label_2 = [1172, 748, 807]\\n label_3 = [364, 1148, 1447]\\n m1, m2, m3, m4, m5 = [], [], [], [], []\\n self.outer_cntr_ds, self.inner_cntr_ds, self.celltype_1_ds, self.celltype_2_ds, self.celltype_3_ds = [], [], [], [], []\\n for slc, l1, l2, l3 in zip(slices, label_1, label_2, label_3):\\n bg = wtsd[:, slc, :] == 1\\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\\n\\n mask = wtsd[:, slc, :] == l1\\n m3.append(mask.long().sum().item())\\n cnt3 = find_contours(mask.cpu().numpy(), level=0)[0]\\n mask = wtsd[:, slc, :] == l2\\n m4.append(mask.long().sum().item())\\n cnt4 = find_contours(mask.cpu().numpy(), level=0)[0]\\n mask = wtsd[:, slc, :] == l3\\n m5.append(mask.long().sum().item())\\n cnt5 = find_contours(mask.cpu().numpy(), level=0)[0]\\n\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt1[:, 0], cnt1[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt2[:, 0], cnt2[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt3[:, 0], cnt3[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt4[:, 0], cnt4[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt5[:, 0], cnt5[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n\\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\\n self.celltype_1_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt3, tolerance=1.2)).to(device)))\\n self.celltype_2_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt4, tolerance=1.2)).to(device)))\\n self.celltype_3_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt5, tolerance=1.2)).to(device)))\\n\\n self.masses = [np.array(m1).mean(), np.array(m2).mean(), np.array(m3 + m4 + m5).mean()]\\n self.fg_shape_descriptors = self.celltype_1_ds + self.celltype_2_ds + self.celltype_3_ds\",\n \"def __init__(self, initial_surfaces):\\n\\n nsurf = len(initial_surfaces)\\n nvert, nedge, ngroup, \\\\\\n surf_ptrs, edge_ptrs, \\\\\\n surf_group, edge_group \\\\\\n = self._compute_topology(initial_surfaces)\\n\\n self._num = {\\n 'surf': len(initial_surfaces),\\n 'vert': nvert,\\n 'edge': nedge,\\n 'group': ngroup,\\n }\\n\\n self._topo = {\\n 'surf_ptrs': surf_ptrs,\\n 'edge_ptrs': edge_ptrs,\\n 'surf_group': surf_group,\\n 'edge_group': edge_group,\\n }\\n\\n self._mult = {\\n 'vert': numpy.zeros(nvert, int),\\n 'edge': numpy.zeros(nedge, int),\\n 'diff_vert': numpy.zeros(nvert, int),\\n 'diff_edge': numpy.zeros(nedge, int),\\n }\\n\\n self._bspline = {\\n 'order': 4 * numpy.ones(ngroup, int),\\n 'num_cp': 4 * numpy.ones(ngroup, int),\\n 'num_pt': 10 * numpy.ones(ngroup, int),\\n }\\n\\n self._surf_indices = {\\n 'df': numpy.zeros((nsurf, 2), int, 'F'),\\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\\n }\\n\\n self._edge_indices = {\\n 'df': numpy.zeros((nedge, 2), int, 'F'),\\n 'cp': numpy.zeros((nedge, 2), int, 'F'),\\n 'pt': numpy.zeros((nedge, 2), int, 'F'),\\n }\\n\\n self._str_indices = {\\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\\n }\\n\\n self._vert_indices = numpy.zeros(nvert, int)\\n\\n self._size = {\\n 'df_str': 0,\\n 'df': 0,\\n 'cp': 0,\\n 'cp_str': 0,\\n 'pt_str': 0,\\n 'pt': 0,\\n }\\n\\n self.diff = {\\n 'surf': numpy.zeros((nsurf, 3, 3), bool, 'F'),\\n 'edge': numpy.zeros((nedge, 2), bool, 'F'),\\n }\\n\\n self.hidden = numpy.zeros(nsurf, bool)\\n\\n self.jac = {\\n 'd(df)/d(df_str)': None,\\n 'd(cp)/d(df)': None,\\n 'd(cp_str)/d(cp)': None,\\n 'd(pt_str)/d(cp_str)': None,\\n 'd(pt)/d(pt_str)': None,\\n }\\n\\n self.vec = {\\n 'df_str': None,\\n 'df': None,\\n 'cp': None,\\n 'cp_str': None,\\n 'pt_str': None,\\n 'pt': None,\\n }\",\n \"def get_GNS_cut(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n x_e = {}\\n # edge variables for s_1, t_1 cut\\n for (u,v) in edges:\\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_e = {}\\n # edge variables for s_2, t_2 cut\\n for (u,v) in edges:\\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_e = {}\\n # edge variables for s_2, t_1 cut\\n for (u,v) in edges:\\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(x_e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\\n\\n # 2. Constraints for s_2 - t_2 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_2):\\n m.addConstr(y_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\\n\\n # 3. Constraints for s_2 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_1):\\n m.addConstr(z_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\\n\\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\\n for (u,v) in edges:\\n m.addConstr(e[u,v] >= x_e[u,v])\\n m.addConstr(e[u,v] >= y_e[u,v])\\n m.addConstr(e[u,v] >= z_e[u,v])\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n print \\\"GNS cut edges:\\\"\\n\\n for u,v in edges:\\n if e[u,v].x != 0:\\n print (u,v)\\n print \\\"s1-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if x_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t2 cut edges in GNS:\\\"\\n for u,v in edges:\\n if y_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if z_e[u,v].x != 0:\\n print (u,v)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def clip(self, clip, s_entry, c_entry):\\n\\n # detect clip mode\\n unionmode = not s_entry and not c_entry\\n intersectionmode = s_entry and c_entry\\n differencemode = not s_entry and c_entry\\n\\n # prep by removing repeat of startpoint at end\\n first = self.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n first = clip.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n\\n # TODO: maybe also remove repeat points anywhere?\\n # ...\\n \\n # phase one - find intersections\\n # ------------------------------\\n anyintersection = False\\n s_intsecs = []\\n c_intsecs = []\\n for s in self.iter(): # for each vertex Si of subject polygon do\\n for c in clip.iter(): # for each vertex Cj of clip polygon do\\n try:\\n #print \\\"find isect %s - %s and %s - %s\\\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\\n c, clip.next(c.__next__))\\n \\n iS = Vertex(i, alphaS, intersect=True, entry=False)\\n iC = Vertex(i, alphaC, intersect=True, entry=False)\\n\\n iS.neighbour = iC\\n iC.neighbour = iS\\n \\n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\\n \\n anyintersection = True\\n \\n except TypeError:\\n pass # this simply means intersect() returned None\\n\\n # insert intersections into originals\\n for iS,a,s,s_next in reversed(s_intsecs):\\n if a == 0:\\n self.replace(s, iS)\\n elif a == 1:\\n self.replace(s_next, iS)\\n else:\\n self.insert(iS, s, s_next)\\n for iC,a,c,c_next in reversed(c_intsecs):\\n if a == 0:\\n self.replace(c, iC)\\n elif a == 1:\\n self.replace(c_next, iC)\\n else:\\n clip.insert(iC, c, c_next)\\n\\n #print \\\"testing if insert was done correctly\\\"\\n for s in self.iter():\\n #print s\\n pass\\n #print \\\"and\\\"\\n for c in clip.iter():\\n #print c\\n pass\\n \\n\\n # phase one and a half - no intersections between subject and clip, so correctly return results\\n # --------------------\\n def specialcase_insidetest():\\n resultpolys = []\\n if unionmode: # union\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so just return subject shell\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so just return clip shell\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so return both\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif intersectionmode: # intersection\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so no intersection to return\\n pass\\n elif differencemode: # difference\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n hole = Polygon()\\n for c in clip.iter():\\n hole.add(Vertex(c))\\n polytuple = (clipped, [hole])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so there is no difference\\n pass\\n else:\\n #clip polygon is entirely outside subject, so difference is simply the subject\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n # no need to continue so just return result\\n return resultpolys\\n \\n if not anyintersection: \\n return specialcase_insidetest()\\n\\n\\n\\n\\n\\n\\n\\n # phase two - identify entry/exit points\\n # --------------------------------------\\n\\n # From K&K\\n \\n def mark_flags(poly, c, c_entry):\\n \\\"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\\\"\\n #print \\\"intersection\\\"\\n #print \\\"\\\\t\\\",c\\n # intersection is degenerate, is the start/endpoint of a line\\n # so maybe delete intersection flag based on prev/next locations\\n prevloc = testLocation(c.prev, poly)\\n nextloc = testLocation(c.__next__, poly)\\n if prevloc == \\\"on\\\" or nextloc == \\\"on\\\":\\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\\n prevloc = testLocation(prevmid, poly)\\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\\n nextloc = testLocation(nextmid, poly)\\n if prevloc == \\\"in\\\" or nextloc == \\\"in\\\":\\n poly.anyinside = True\\n #print \\\"\\\\t %s -> degenintsec -> %s\\\" %(prevloc,nextloc)\\n if prevloc == \\\"out\\\":\\n if nextloc == \\\"out\\\":\\n #just touching\\n c.entry = \\\"en/ex\\\" if c_entry else \\\"ex/en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif prevloc == \\\"in\\\":\\n #union and difference should never go inside the other polygon\\n #so this should only happen for intersectmode...\\n if nextloc == \\\"in\\\":\\n #just touching\\n c.entry = \\\"ex/en\\\" if c_entry else \\\"en/ex\\\"\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif prevloc == \\\"on\\\":\\n if nextloc == \\\"on\\\":\\n c.entry = None\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n\\n self.anyinside = False\\n\\n # set clip\\n prevsingle = None\\n for c in clip.iter():\\n if c.intersect:\\n mark_flags(self, c, c_entry)\\n # set couple\\n if c.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and c.entry == prevsingle.entry:\\n c.couple = prevsingle\\n prevsingle.couple = c\\n prevsingle = c\\n # set crosschange\\n # some modifications based on implementation in qt clipper source code\\n #if c.entry == \\\"en/ex\\\" == c.neighbour.entry or c.entry == \\\"ex/en\\\" == c.neighbour.entry:\\n if False: #c.entry == \\\"en/ex\\\" or c.entry == \\\"ex/en\\\":\\n print(\\\"Maybe crosschange...\\\")\\n # tri1\\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\\n dir1 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n # tri2\\n #a,b,c = c.neighbour.prev, c.prev, c.next\\n a,b,c = c.__next__, c.prev, c.neighbour.prev\\n dir2 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n print(dir1,dir2)\\n #if dir1 < 0 != dir2 < 0: # different orientation\\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\\n print(\\\"CROSSCHANGE!!!\\\")\\n c.cross_change = True\\n c.neighbour.cross_change = True # not sure if should set neighbour too\\n\\n # maybe early abort\\n if not self.anyinside and intersectionmode:\\n return []\\n\\n # what about perfect overlap???\\n # ...\\n\\n if False: #DEBUG:\\n print(\\\"view clip entries\\\")\\n for c in clip.iter():\\n print(c, c.entry)\\n\\n # find first isect where both neighbours have valid flag\\n for c in clip.iter():\\n if c.entry:\\n s = c.neighbour\\n mark_flags(clip, s, s_entry)\\n if s.entry:\\n first_c = c\\n first_s = s\\n # print 777,s.entry\\n break\\n\\n else:\\n return specialcase_insidetest()\\n #raise Exception(\\\"weird special case, no neighbours that both have flag left\\\")\\n \\n # autoset subj, if neighbour of first is different, then set all as opposite\\n # TODO: how deal with s_entry in case of different modes...?\\n print(\\\"view first\\\")\\n print(first_c, first_c.entry)\\n print(first_s, first_s.entry)\\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\\n for c in clip.iter():\\n if c.entry:\\n if c.entry == \\\"en\\\": c.neighbour.entry = \\\"ex\\\"\\n elif c.entry == \\\"ex\\\": c.neighbour.entry = \\\"en\\\"\\n elif c.entry == \\\"en/ex\\\": c.neighbour.entry = \\\"ex/en\\\"\\n elif c.entry == \\\"ex/en\\\": c.neighbour.entry = \\\"en/ex\\\"\\n \\n # else set all same\\n else:\\n for c in clip.iter():\\n if c.entry:\\n c.neighbour.entry = c.entry\\n\\n # set couple for subj (not sure if needed)\\n prevsingle = None\\n for s in self.iter():\\n if s.entry:\\n if s.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and s.entry == prevsingle.entry:\\n s.couple = prevsingle\\n prevsingle.couple = s\\n prevsingle = s\\n\\n if False: #DEBUG: \\n print(\\\"view subj entries\\\")\\n for s in self.iter():\\n print(s, s.entry)\\n\\n\\n\\n\\n\\n # phase three - construct a list of clipped polygons\\n # --------------------------------------------------\\n\\n ######\\n # Defs\\n def next_unprocessed(vert):\\n origvert = vert\\n while vert:\\n if vert.entry and not (vert.checked or vert.neighbour.checked):\\n #print \\\"vert, found next unproc\\\", vert, vert.checked, vert.neighbour.checked\\n if vert.couple:\\n # rule 1\\n if vert.couple.entry and vert.entry:\\n # rule 2\\n if vert.couple.entry == \\\"en\\\" and vert.entry == \\\"en\\\":\\n return vert.couple\\n elif vert.couple.entry == \\\"ex\\\" and vert.entry == \\\"ex\\\":\\n return vert\\n # rule 3\\n else:\\n return vert\\n \\n vert = vert.__next__\\n \\n if vert == origvert:\\n # if returned to first, return None\\n return None\\n\\n def DeleteFlag1(cur, stat):\\n if cur.entry == \\\"en/ex\\\":\\n cur.entry = None\\n if cur.cross_change:\\n if stat == \\\"D3\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if stat == \\\"D3\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D3\\\":\\n cur.entry = \\\"en\\\"\\n return \\\"D2\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n return \\\"D1\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n return \\\"D1\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n return \\\"D2\\\"\\n\\n def DeleteFlag2(cur, prev, stat):\\n if cur.entry == \\\"en/ex\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"ex\\\"\\n else:\\n cur.entry = \\\"en\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"en\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n if stat == \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D1\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n if stat != \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D2\\\"\\n else:\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n\\n def proceed(cur, stat):\\n cur.checked = True\\n if stat == \\\"D1\\\":\\n clipped.add(Vertex(cur))\\n return cur.__next__\\n elif stat == \\\"D2\\\":\\n clipped.add(Vertex(cur))\\n return cur.prev\\n else:\\n return cur.neighbour\\n\\n ####\\n resultpolys = []\\n\\n self.first.checked = True\\n cur = prev = start = next_unprocessed(self.first)\\n\\n while cur:\\n # each new polygon\\n print(\\\"new poly\\\")\\n\\n stat = DeleteFlag1(cur, \\\"D3\\\")\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n clipped = Polygon()\\n cur = proceed(cur, stat)\\n\\n # collect vertexes\\n while cur != start:\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n if cur.entry:\\n if stat == \\\"D1\\\" or stat == \\\"D2\\\":\\n stat = DeleteFlag2(cur, prev, stat)\\n else:\\n stat = DeleteFlag1(cur, stat)\\n prev = cur\\n cur = proceed(cur, stat)\\n\\n # return to first vertex\\n clipped.add(Vertex(clipped.first))\\n\\n print(clipped)\\n\\n resultpolys.append((clipped,[]))\\n cur = prev = start = next_unprocessed(self.first)\\n\\n\\n\\n # finally, sort into exteriors and holes\\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\\n for otherext,otherholes in resultpolys:\\n if polyext == otherext:\\n continue # don't compare to self\\n if polyext.first.isInside(otherext):\\n otherholes.append(polyext) #poly is within other so make into a hole\\n del resultpolys[pindex] #and delete poly from being an independent poly\\n return resultpolys\",\n \"def refinemesh(prev_legs, state0_chaser, n_s):\\n scored_points = np.array([])\\n for leg in prev_legs:\\n scored_point = [*leg.dv, leg.t_leg, leg.score]\\n scored_points = np.append(scored_points, scored_point)\\n scored_points = scored_points.reshape(len(prev_legs), 5)\\n tri = Delaunay(scored_points[:, 0:4], qhull_options='QJ')\\n m_max = max(scored_points[:, 4]) # Maximum trajectory score of all simplices of the triangulation\\n if m_max == 0:\\n print('algorithm.py: m_max = 0 because all leg scores are 0!!!')\\n m_max = 1 # to avoid raising the dividing by 0 error if all leg scores are 0\\n g_max = 1\\n for q in tri.simplices:\\n smplx_scores = scored_points[:, 4][q] # scores of the points defining the simplex\\n aux = mean(smplx_scores)\\n if g_max < aux:\\n g_max = aux\\n\\n simplices_scored = []\\n for q in tri.simplices:\\n smplx_score = compute_simplexscore(q, scored_points, m_max, g_max)\\n # simp_scored = [smplx_score, q_vec]\\n simplices_scored.append([smplx_score, q])\\n sorted_simp_scores = sorted(simplices_scored, reverse=True) # ranks the simplices based on score\\n new_samples = samplewithinbestsimplices(sorted_simp_scores, tri.points, n_s)\\n\\n new_legs = []\\n for s in new_samples:\\n leg = Leg(s[0:3], s[3], state0_chaser)\\n new_legs.append(leg)\\n\\n return new_legs\",\n \"def add_sudoku_constraints(sg):\\n for y in range(6):\\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for x in range(6)]))\\n for x in range(6):\\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for y in range(6)]))\\n for z in range(6):\\n top = (z // 2) * 2\\n left = (z % 2) * 3\\n cells = [sg.grid[Point(y, x)] for y in range(top, top + 2) for x in range(left, left + 3)]\\n sg.solver.add(Distinct(*cells))\",\n \"def __init__(self, node_map, edge_list):\\n self.node_map = node_map\\n self.edge_list = edge_list\\n self.sif_list = []\\n categories = Categories()\\n abbrev_map = categories.abbrev_category_map\\n\\n self.data_list = []\\n for node_id in node_map:\\n node = node_map[node_id]\\n node.sif_id = abbrev_map[node.category] + \\\"_\\\" + node.label\\n dict = {}\\n dict[\\\"id\\\"] = node.id\\n dict[\\\"label\\\"] = node.sif_id\\n dict[\\\"category\\\"] = node.category\\n node_dict = {}\\n node_dict[\\\"data\\\"] = dict\\n self.data_list.append(node_dict)\\n\\n edge_id = 0\\n for edge in edge_list:\\n dict = {}\\n dict[\\\"id\\\"] = \\\"e\\\" + str(edge_id)\\n dict[\\\"source\\\"] = edge.source_id\\n dict[\\\"target\\\"] = edge.target_id\\n node_dict = {}\\n node_dict[\\\"data\\\"] = dict\\n self.data_list.append(node_dict)\\n\\n s_node = self.node_map[edge.source_id]\\n t_node = self.node_map[edge.target_id]\\n self.sif_list.append([s_node.sif_id, t_node.sif_id])\\n edge_id += 1\",\n \"def update_nets_with_segments(pcb_data: List[Dict[str, Any]], nets: List[Net]):\\n segments = get_all_dicts_by_key(pcb_data, 'segment')\\n for segment in segments:\\n start: Coords = get_dict_by_key(segment['segment'], 'start')['start']\\n start[1] = str(-1*float(start[1]))\\n end: Coords = get_dict_by_key(segment['segment'], 'end')['end']\\n end[1] = str(-1 * float(end[1]))\\n width: str = get_dict_by_key(segment['segment'], 'width')['width']\\n layer_data: str = get_dict_by_key(segment['segment'], 'layer')['layer']\\n layers: List[Layer] = convert_to_layers(layer_data)\\n new_segment: Segment = Segment(start=start, end=end, width=width, layers=layers)\\n net_id: str = get_dict_by_key(segment['segment'], 'net')['net']\\n for net in nets:\\n if float(net.net_id) == float(net_id):\\n net.segments.append(new_segment)\",\n \"def scc(graph, reverse_graph, nodes):\\n\\n out = defaultdict(list)\\n track = Track()\\n dfs_loop(reverse_graph, nodes, track)\\n sorted_nodes = sorted(track.finish_time,\\n key=track.finish_time.get, reverse=True)\\n track.current_time = 0\\n track.current_source = None\\n track.explored = set()\\n dfs_loop(graph, sorted_nodes, track)\\n for lead, vertex in groupby(sorted(track.leader, key=track.leader.get),\\n key=track.leader.get):\\n out[lead] = list(vertex)\\n\\n return out\",\n \"def __init__(self,clip_list):\\n self.requested_clips=clip_list\",\n \"def main():\\n\\n \\\"\\\"\\\"\\n nodes, hd3 = erdos_rennie_like(100,8333,5)\\n export('d3',hd3)\\n\\n nodes, hd5 = erdos_rennie_like(100,8333,6)\\n export('d5',hd5)\\n\\n nodes, hd6 = erdos_rennie_like(100,8333,7)\\n export('d6',hd6)\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n nodes, sparse1 = erdos_rennie_like(600, 1200, 3)\\n export('sparse_diag1', sparse1)\\n\\n nodes, sparse2 = erdos_rennie_like(600, 2400, 3)\\n export('sparse_diag2',sparse2)\\n\\n nodes, sparse3 = erdos_rennie_like(600, 5800, 3)\\n export('sparse_diag3',sparse3)\\n\\n nodes, sparse4 = erdos_rennie_like(600,11600, 3)\\n export('sparse_diag4',sparse4)\\n\\n nodes, sparse5 = erdos_rennie_like(600,23200, 3)\\n export('sparse_diag5',sparse5)\\n \\\"\\\"\\\"\\n\\n nodes, size1 = erdos_rennie_like(100, 500, 3)\\n nodes, size2 = erdos_rennie_like(200,1000,3)\\n nodes,size3 = erdos_rennie_like(300,1500,3)\\n nodes,size4 = erdos_rennie_like(400,2000,3)\\n nodes,size5 = erdos_rennie_like(500,2500,3)\\n\\n export('size_diag1',size1)\\n export('size_diag2',size2)\\n export('size_diag3',size3)\\n export('size_diag4',size4)\\n export('size_diag5',size5)\",\n \"def to_swc(self, contributors=\\\"\\\"):\\n from . import __version__\\n sx, sy, sz = np.diag(self.transform)[:3]\\n\\n swc_header = f\\\"\\\"\\\"# ORIGINAL_SOURCE CloudVolume {__version__}\\n# CREATURE \\n# REGION\\n# FIELD/LAYER\\n# TYPE\\n# CONTRIBUTOR {contributors}\\n# REFERENCE\\n# RAW \\n# EXTRAS \\n# SOMA_AREA\\n# SHINKAGE_CORRECTION \\n# VERSION_NUMBER {__version__}\\n# VERSION_DATE {datetime.datetime.utcnow().isoformat()}\\n# SCALE {sx:.6f} {sy:.6f} {sz:.6f}\\n\\\"\\\"\\\"\\n\\n def generate_swc(skel, offset):\\n if skel.edges.size == 0:\\n return \\\"\\\"\\n\\n index = defaultdict(set)\\n visited = defaultdict(bool)\\n for e1, e2 in skel.edges:\\n index[e1].add(e2)\\n index[e2].add(e1)\\n\\n stack = [ skel.edges[0,0] ]\\n parents = [ -1 ]\\n\\n swc = \\\"\\\"\\n\\n while stack:\\n node = stack.pop()\\n parent = parents.pop()\\n\\n if visited[node]:\\n continue\\n\\n swc += \\\"{n} {T} {x:0.6f} {y:0.6f} {z:0.6f} {R:0.6f} {P}\\\\n\\\".format(\\n n=(node + 1 + offset),\\n T=skel.vertex_types[node],\\n x=skel.vertices[node][0],\\n y=skel.vertices[node][1],\\n z=skel.vertices[node][2],\\n R=skel.radii[node],\\n P=parent if parent == -1 else (parent + 1 + offset),\\n )\\n\\n visited[node] = True\\n \\n for child in index[node]:\\n stack.append(child)\\n parents.append(node)\\n\\n return swc\\n\\n skels = self.components()\\n\\n swc = swc_header + \\\"\\\\n\\\"\\n offset = 0\\n for skel in skels:\\n swc += generate_swc(skel, offset) + \\\"\\\\n\\\"\\n offset += skel.vertices.shape[0]\\n\\n return swc\",\n \"def makeSubapMap():\\n a=numpy.zeros((sum(nsub),),numpy.int32)\\n subFlag=subapFlag.copy()\\n for i in range(NNGSCAM+NLGSOCAM+NBOBCAT):#ngs 1-3, truth, lgs, lofs, hofs\\n tmp=subFlag[nsub[:i].sum():nsub[:i+1].sum()]\\n tmp.shape=nsuby[i],nsubx[i]\\n if i==NNGSCAM+NLGSOCAM:#lofs\\n tmp[:]=sfNoObs*(i+1)\\n elif i==1+NNGSCAM+NLGSOCAM:#hofs\\n tmp[:]=sf14NoObs*(i+1)\\n elif i==NNGSCAM:#lgs\\n for j in range(4):\\n jj=6-j\\n tmp[j*2]=individualSubapFlag[jj]*(i+1)\\n if j!=3:\\n tmp[j*2+1]=individualSubapFlag[j]*(i+1)\\n #jj=7-j\\n #if jj<7:\\n # tmp[j*2-1]=individualSubapFlag[jj]*(i+1)\\n #tmp[j*2]=individualSubapFlag[j]*(i+1)\\n else:\\n tmp[:]=individualSubapFlag*(i+1)\\n return subFlag\",\n \"def nurbsToSubdiv(*args, addUnderTransform: bool=True, caching: bool=True, collapsePoles:\\n bool=False, constructionHistory: bool=True, matchPeriodic: bool=False,\\n maxPolyCount: Union[int, bool]=1000, name: AnyStr=\\\"\\\", nodeState: Union[int,\\n bool]=0, object: bool=True, reverseNormal: bool=True, q=True, query=True,\\n e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\\n pass\",\n \"def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\\n # get activation for each seperated vc\\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\\n max_ch_index = max_ch_index.view(-1, L) # n, L\\n\\n all_activation_vcs = []\\n\\n for i in range(len(integrate_activation_vc)):\\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\\n all_activation_vcs.append(integrate_activation_vc_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n print(f\\\"unique_vc_i {unique_vc_i.shape}\\\")\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\\n activate_vc_i[index_vc_i, :] = 0.\\n all_activation_vcs.append(activate_vc_i)\\n \\n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\\n \\n # decompose each mask \\n all_masks = []\\n for i in range(len(sim_map_max)):\\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\\n all_masks.append(sim_map_max_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\\n vc_sim_map_max_i[index_vc_i] = 0.\\n all_masks.append(vc_sim_map_max_i)\\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\\n\\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\\\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\\\"\\n\\n return all_activation_vcs, all_masks\",\n \"def scoreCirc_CmosVoltageReference(circuit, gen, indi, makeRedundancyInMatrix): #TODO 6.9.2016 napisi cost function ki se sklada z evaluateCmosVoltageRef\\n #----------#\\n VREF = 1.5\\n #----------#\\n \\n FullBigCircuitMatrix = deepcopy(circuit.fullRedundancyMatrix)\\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\\n\\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\\t#(ones/(all/2))\\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\\n \\n results = None\\n if OcSc > 1:\\n score = 1e4*np.exp(OcSc)\\n else:\\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\\n results = runme2.evaluateCmosVoltageRef(gen, indi)\\n disfCount = 0\\n \\n \\n #Vdd sweeps on 3 temperatures - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # -20 deg\\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\\n vdd_sweep_t1 = np.array(results['vout_vdd_temp1']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_t1)):\\n disfCount = disfCount + 1\\n vdd_s_t1 = 0\\n vdd_s_t1_d = 0\\n else:\\n x = np.median(vdd_sweep_t1)\\n vdd_s_t1 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_t1_d = np.max(vdd_sweep_t1) - np.min(vdd_sweep_t1)\\n \\n \\n # 25 deg\\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\\n vdd_sweep_t2 = np.array(results['vout_vdd_temp2']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_t2)):\\n disfCount = disfCount + 1\\n vdd_s_t2 = 0\\n vdd_s_t2_d = 0\\n else:\\n x = np.median(vdd_sweep_t2)\\n vdd_s_t2 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_t2_d = np.max(vdd_sweep_t2) - np.min(vdd_sweep_t2) \\n \\n # 120 deg\\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\\n vdd_sweep_t3 = np.array(results['vout_vdd_temp3']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_t3)):\\n disfCount = disfCount + 1\\n vdd_s_t3 = 0\\n vdd_s_t3_d = 0\\n else:\\n x = np.median(vdd_sweep_t3)\\n vdd_s_t3 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_t3_d = np.max(vdd_sweep_t3) - np.min(vdd_sweep_t3) \\n \\n #Vdd sweeps on 3 loads - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # 10e6 Ohm\\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\\n vdd_sweep_r1 = np.array(results['vout_vdd_res1']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_r1)):\\n disfCount = disfCount + 1\\n vdd_s_r1 = 0\\n vdd_s_r1_d = 0\\n else:\\n x = np.median(vdd_sweep_r1)\\n vdd_s_r1 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_r1_d = np.max(vdd_sweep_r1) - np.min(vdd_sweep_r1)\\n \\n # 10e4 Ohm\\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\\n vdd_sweep_r2 = np.array(results['vout_vdd_res2']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_r2)):\\n disfCount = disfCount + 1\\n vdd_s_r2 = 0\\n vdd_s_r2_d = 0\\n else:\\n x = np.median(vdd_sweep_r2)\\n vdd_s_r2 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_r2_d = np.max(vdd_sweep_r2) - np.min(vdd_sweep_r2) \\n \\n # 10e2 Ohm\\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\\n vdd_sweep_r3 = np.array(results['vout_vdd_res3']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_r3)):\\n disfCount = disfCount + 1\\n vdd_s_r3 = 0\\n vdd_s_r3_d = 0\\n else:\\n x = np.median(vdd_sweep_r3)\\n vdd_s_r3 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_r3_d = np.max(vdd_sweep_r3) - np.min(vdd_sweep_r3) \\n \\n power = results['power']['nominal']\\n if np.isnan(np.array(power, dtype=float)):\\n disfCount = disfCount + 1\\n powe = 0\\n else:\\n powe = power\\n \\n #---COST FUNCTION DEFINITION---#\\n score = vdd_s_t1 + vdd_s_t1_d + \\\\\\n\\t vdd_s_t2 + vdd_s_t2_d + \\\\\\n\\t vdd_s_t3 + vdd_s_t3_d + \\\\\\n\\t vdd_s_r1 + vdd_s_r1_d + \\\\\\n\\t vdd_s_r2 + vdd_s_r2_d + \\\\\\n\\t vdd_s_r3 + vdd_s_r3_d + \\\\\\n\\t (100*powe)\\n\\n #print disfCount\\n if disfCount > 0:\\n score = np.exp(disfCount) * 1e3\\n if np.isnan(score):\\n score = 2e4\\n score = score + (IcNc+1) #add small punishment if not all nodes connected\\n\\n #print \\\"\\\\t\\\\t\\\\t\\\\t\\\\tG_\\\" + str(gen) + \\\"_I_\\\" + str(indi) + \\\" SCORE:\\\", score\\n \\n filename = \\\"g_\\\" + str(gen) + \\\"_i_\\\" + str(indi) + \\\"_subckt.cir\\\"\\n os.remove(filename) #cleanup current subcircuit\\n\\n return score, matrixDensity, matrixQuaziID, results\",\n \"def build_splines(self, nsc, alpha=0.05, initial_beta=1.5):\\n pass\",\n \"def TNFR1_to_SecondaryComplex_Alternate():\\n \\n Parameter('TNFa_0' , 000) # 6000 corresponds to 100ng/ml TNFa\\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\\n Parameter('CompI_0' , 0) # complexes per cell\\n Parameter('NFkB_0' , 0) # molecules per cell\\n alias_model_components()\\n \\n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'unmod'), RIP1_0) # RIP1\\n Initial(NFkB(bf=None), NFkB_0)\\n \\n # =========================================\\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\\n # -----------------------------------------\\n # TNFa+ TNFR1 <-> TNFa:TNFR1\\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\\n \\n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\\n # [active]CompI:RIP1 >> [active]CompI + RIP1\\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\\n \\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\\n \\n # ------------------------------------------\\n \\n # -------------Complex I assembly----------------\\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\\n \\n # --------------Complex I - RIP1 Modification-----------------\\n # Complex I recruits RIP1\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\\n #bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\\n \\n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\\n #Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1))\\n \\n # De-ubiquitination and degradation or release of RIP1 from complex I\\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='deub'), Parameter('k6',1e-3))\\n \\n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\\n \\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'deub'), 'bDD', [1e-10,1])\\n \\n # Receptor recycle\\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1e-3))\\n \\n # --------------RIP1 Ubiquitination---------------------------\\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))\",\n \"def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\\n #Read in the image that is segmented/labelled for nuclei\\n img=imread(img_dir)\\n\\n #save plots to show clusters\\n fig = plt.figure(figsize=(6, 2))\\n ax0 = fig.add_subplot(131)\\n ax1 = fig.add_subplot(132)\\n ax3 = fig.add_subplot(133)\\n #show segmented image labels\\n ax0.imshow(img,aspect='auto') \\n ax0.axis('off')\\n #nuclear centroid color-coded by their orientation\\n img1=ax1.scatter(data[\\\"Y\\\"], data[\\\"X\\\"], c=data[\\\"angles\\\"],s=1)\\n ax1.set_xlim(0,img.shape[0])\\n ax1.set_ylim(img.shape[1],0)\\n plt.colorbar(img1)\\n ax1.axis('off')\\n\\n # plot the cluster assignments\\n img3=ax3.scatter(data[data[\\\"clusters\\\"]> -1][\\\"Y\\\"], data[data[\\\"clusters\\\"]> -1][\\\"X\\\"], \\n c=data[data[\\\"clusters\\\"]> -1][\\\"clusters\\\"],cmap=\\\"plasma\\\",s=1)\\n ax3.set_xlim(0,img.shape[0])\\n ax3.set_ylim(img.shape[1],0)\\n ax3.axis('off')\\n\\n #add titles\\n ax0.title.set_text('Segmented Image')\\n ax1.title.set_text('Filtered Orientation')\\n ax3.title.set_text('Clusters')\\n\\n if display_not_save:\\n plt.show()\\n else: \\n plt.savefig((output_dir+\\\"/\\\"+img_dir.rsplit('/', 1)[-1][:-4]+\\\"_\\\"+str(dbscn_length)+\\\"_\\\"+ str(dbscn_min_size)+\\\".png\\\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\\n fig.clf()\\n plt.close(fig)\\n plt.close('all')\\n \\n \\n del fig,ax0,ax1,ax3,img1,img3\",\n \"def initialize(self, simplified_circuit_list, numSubTreeComms=1, maxCacheSize=None):\\n #tStart = _time.time() #DEBUG TIMER\\n\\n # opLabels : A list of all the distinct operation labels found in\\n # simplified_circuit_list. Used in calc classes\\n # as a convenient precomputed quantity.\\n self.opLabels = self._get_opLabels(simplified_circuit_list)\\n if numSubTreeComms is not None:\\n self.distribution['numSubtreeComms'] = numSubTreeComms\\n\\n circuit_list = [tuple(mdl) for mdl in simplified_circuit_list.keys()]\\n self.simplified_circuit_spamTuples = list(simplified_circuit_list.values())\\n self.num_final_els = sum([len(v) for v in self.simplified_circuit_spamTuples])\\n #self._compute_finalStringToEls() #depends on simplified_circuit_spamTuples\\n self.recompute_spamtuple_indices(bLocal=True) # bLocal shouldn't matter here\\n\\n #Evaluation tree:\\n # A list of tuples, where each element contains\\n # information about evaluating a particular operation sequence:\\n # (iStart, tuple_of_following_gatelabels )\\n # and self.eval_order specifies the evaluation order.\\n del self[:] # clear self (a list)\\n\\n #Final Indices\\n # The first len(circuit_list) elements of the tree correspond\\n # to computing the operation sequences requested in circuit_list. Doing\\n # this make later extraction much easier (views can be used), but\\n # requires a non-linear order of evaluation, held in the eval_order list.\\n self.eval_order = []\\n\\n #initialize self as a list of Nones\\n self.num_final_strs = len(circuit_list)\\n self[:] = [None] * self.num_final_strs\\n\\n #Sort the operation sequences \\\"alphabetically\\\", so that it's trivial to find common prefixes\\n sorted_strs = sorted(list(enumerate(circuit_list)), key=lambda x: x[1])\\n\\n #DEBUG\\n #print(\\\"SORTED\\\"); print(\\\"\\\\n\\\".join(map(str,sorted_strs)))\\n\\n #PASS1: figure out what's worth keeping in the cache:\\n if maxCacheSize is None or maxCacheSize > 0:\\n curCacheSize = 0\\n cacheIndices = [] # indices into circuit_list/self of the strings to cache\\n dummy_self = [None] * self.num_final_strs; cache_hits = {}\\n for k, (iStr, circuit) in enumerate(sorted_strs):\\n L = len(circuit)\\n for i in range(curCacheSize - 1, -1, -1): # from curCacheSize-1 -> 0\\n candidate = circuit_list[cacheIndices[i]]\\n Lc = len(candidate)\\n if L >= Lc > 0 and circuit[0:Lc] == candidate:\\n iStart = i\\n remaining = circuit[Lc:]\\n if iStr in cache_hits: cache_hits[cacheIndices[i]] += 1 # tally cache hit\\n else: cache_hits[cacheIndices[i]] = 1 # TODO: use default dict?\\n break\\n else: # no break => no prefix\\n iStart = None\\n remaining = circuit[:]\\n\\n cacheIndices.append(iStr)\\n iCache = curCacheSize\\n curCacheSize += 1; assert(len(cacheIndices) == curCacheSize)\\n dummy_self[iStr] = (iStart, remaining, iCache)\\n\\n #PASS #2: for real this time: construct tree but only cache items w/hits\\n curCacheSize = 0\\n cacheIndices = [] # indices into circuit_list/self of the strings to cache\\n # (store persistently as prefixes of other string -- this need not be all\\n # of the strings in the tree)\\n\\n for k, (iStr, circuit) in enumerate(sorted_strs):\\n L = len(circuit)\\n\\n #find longest existing prefix for circuit by working backwards\\n # and finding the first string that *is* a prefix of this string\\n # (this will necessarily be the longest prefix, given the sorting)\\n for i in range(curCacheSize - 1, -1, -1): # from curCacheSize-1 -> 0\\n candidate = circuit_list[cacheIndices[i]]\\n Lc = len(candidate)\\n if L >= Lc > 0 and circuit[0:Lc] == candidate: # \\\">=\\\" allows for duplicates\\n iStart = i # NOTE: this is an index into the *cache*, not necessarily self\\n remaining = circuit[Lc:]\\n break\\n else: # no break => no prefix\\n iStart = None\\n remaining = circuit[:]\\n\\n # if/where this string should get stored in the cache\\n if (maxCacheSize is None or curCacheSize < maxCacheSize) and cache_hits.get(iStr, 0) > 0:\\n cacheIndices.append(iStr)\\n iCache = curCacheSize\\n curCacheSize += 1; assert(len(cacheIndices) == curCacheSize)\\n else: # don't store in the cache\\n iCache = None\\n\\n #Add info for this string\\n self[iStr] = (iStart, remaining, iCache)\\n self.eval_order.append(iStr)\\n\\n #FUTURE: could perform a second pass, and if there is\\n # some threshold number of elements which share the\\n # *same* iStart and the same beginning of the\\n # 'remaining' part then add a new \\\"extra\\\" element\\n # (beyond the #circuits index) which computes\\n # the shared prefix and insert this into the eval\\n # order.\\n\\n self.cachesize = curCacheSize\\n self.myFinalToParentFinalMap = None # this tree has no \\\"children\\\",\\n self.myFinalElsToParentFinalElsMap = None # i.e. has not been created by a 'split'\\n self.parentIndexMap = None\\n self.original_index_lookup = None\\n self.subTrees = [] # no subtrees yet\\n assert(self.generate_circuit_list() == circuit_list)\\n assert(None not in circuit_list)\",\n \"def __init__(self, dcs, suppliers, neighbor_threshold):\\n\\n nodes = []\\n locations = dcs + suppliers\\n total_space = sum([dc.max_cube for dc in dcs])\\n for loc in locations:\\n weight = 0\\n if type(loc) == DistributionCenter:\\n weight = loc.max_cube / total_space\\n node = Node(loc, weight)\\n nodes.append(node)\\n\\n for node1 in nodes:\\n for node2 in nodes:\\n if node1 != node2:\\n if type(node1.location) == Supplier and type(node2.location) == DistributionCenter:\\n node1.neighbors.append(node2)\\n elif type(node1.location) == DistributionCenter and type(node2.location) == Supplier:\\n node1.neighbors.append(node2)\\n elif type(node1.location) == DistributionCenter and type(node2.location) == DistributionCenter:\\n if node1.location.distance(node2.location) < neighbor_threshold:\\n node1.neighbors.append(node2)\\n\\n self.nodes = {n.location.id: n for n in nodes}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6174592","0.5594567","0.5401644","0.53908986","0.5365256","0.5335248","0.5255532","0.5243055","0.5222066","0.5215828","0.5205438","0.5200392","0.5197557","0.51619846","0.51185894","0.5075667","0.5075613","0.5074813","0.5073621","0.50514334","0.50234973","0.5009397","0.50067884","0.500347","0.49787","0.49657798","0.495915","0.4946976","0.49460298","0.49444845","0.49441388","0.49371672","0.49366137","0.49347615","0.49253306","0.49240035","0.49216542","0.49165353","0.4909136","0.4903336","0.48980904","0.48971498","0.4895512","0.48861226","0.4877514","0.48677385","0.48660052","0.48632717","0.48360705","0.48355868","0.48251164","0.48212707","0.4821054","0.4808239","0.48050284","0.4796011","0.47945902","0.4790962","0.47854826","0.47764924","0.47744623","0.47697353","0.47672194","0.47653076","0.4761918","0.47577333","0.47547755","0.47526425","0.47497803","0.47420448","0.47388682","0.4736488","0.47290993","0.4728531","0.47276643","0.47257486","0.47214147","0.47193703","0.47148022","0.4707874","0.47065395","0.47039977","0.47016296","0.46982697","0.4694118","0.46889427","0.4685351","0.4684664","0.46832454","0.46794847","0.46790916","0.46764868","0.46756992","0.46747327","0.46743724","0.46721402","0.46717218","0.46698067","0.46695867","0.46683604"],"string":"[\n \"0.6174592\",\n \"0.5594567\",\n \"0.5401644\",\n \"0.53908986\",\n \"0.5365256\",\n \"0.5335248\",\n \"0.5255532\",\n \"0.5243055\",\n \"0.5222066\",\n \"0.5215828\",\n \"0.5205438\",\n \"0.5200392\",\n \"0.5197557\",\n \"0.51619846\",\n \"0.51185894\",\n \"0.5075667\",\n \"0.5075613\",\n \"0.5074813\",\n \"0.5073621\",\n \"0.50514334\",\n \"0.50234973\",\n \"0.5009397\",\n \"0.50067884\",\n \"0.500347\",\n \"0.49787\",\n \"0.49657798\",\n \"0.495915\",\n \"0.4946976\",\n \"0.49460298\",\n \"0.49444845\",\n \"0.49441388\",\n \"0.49371672\",\n \"0.49366137\",\n \"0.49347615\",\n \"0.49253306\",\n \"0.49240035\",\n \"0.49216542\",\n \"0.49165353\",\n \"0.4909136\",\n \"0.4903336\",\n \"0.48980904\",\n \"0.48971498\",\n \"0.4895512\",\n \"0.48861226\",\n \"0.4877514\",\n \"0.48677385\",\n \"0.48660052\",\n \"0.48632717\",\n \"0.48360705\",\n \"0.48355868\",\n \"0.48251164\",\n \"0.48212707\",\n \"0.4821054\",\n \"0.4808239\",\n \"0.48050284\",\n \"0.4796011\",\n \"0.47945902\",\n \"0.4790962\",\n \"0.47854826\",\n \"0.47764924\",\n \"0.47744623\",\n \"0.47697353\",\n \"0.47672194\",\n \"0.47653076\",\n \"0.4761918\",\n \"0.47577333\",\n \"0.47547755\",\n \"0.47526425\",\n \"0.47497803\",\n \"0.47420448\",\n \"0.47388682\",\n \"0.4736488\",\n \"0.47290993\",\n \"0.4728531\",\n \"0.47276643\",\n \"0.47257486\",\n \"0.47214147\",\n \"0.47193703\",\n \"0.47148022\",\n \"0.4707874\",\n \"0.47065395\",\n \"0.47039977\",\n \"0.47016296\",\n \"0.46982697\",\n \"0.4694118\",\n \"0.46889427\",\n \"0.4685351\",\n \"0.4684664\",\n \"0.46832454\",\n \"0.46794847\",\n \"0.46790916\",\n \"0.46764868\",\n \"0.46756992\",\n \"0.46747327\",\n \"0.46743724\",\n \"0.46721402\",\n \"0.46717218\",\n \"0.46698067\",\n \"0.46695867\",\n \"0.46683604\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6822347"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93481,"cells":{"query":{"kind":"string","value":"Check all the subcontours in A to see if they have a match in B and return them Also check for flipped matches; in the event of a flip, both sc's are flagged for removal"},"document":{"kind":"string","value":"def FindMatchesAndRemovals(scListA, scListB, searchInds=None):\n scsMatchedInB = []\n removeFromA = []\n removeFromB = []\n\n if searchInds is None:\n searchInds = list(range(len(scListA)))\n\n for ind in searchInds:\n sca = scListA[ind]\n # Look for each sc from A in B:\n matchTuples = [\n (i, scb) for i, scb in enumerate(scListB) if sca.values == scb.values\n ]\n matchInds, matches = zip(*matchTuples)\n\n if len(matches) == 0:\n print(\"sc in A but not in B:\", sca.values, matches)\n sp, ep = sca.startPointValues, sca.endPointValues\n # get the values connected to the subcontour only at the corners:\n opposingValues = tuple(\n sorted(list(set(sp).union(ep).difference(sca.values)))\n )\n # get the sc's from B that have these values as their main values (aka, sca switched to this/these)\n matchOppTuples = [\n (i, scb)\n for i, scb in enumerate(scListB)\n if scb.values == opposingValues\n ]\n matchOppInds, matchesOpp = zip(*matchOppTuples)\n\n if matchesOpp == []:\n print(\"Not Recoverable!\")\n else:\n print(\n \"Recoverable: sc in A at index\",\n ind,\n sca.values,\n \"matches to sc in B at index\",\n matchOppInds[0],\n matchesOpp[0].values,\n )\n print(scListA[ind])\n removeFromA.append(\n ind\n ) # actually DO the removals later so we don't muck up the indexing!\n removeFromB.append(matchOppInds[0])\n scsMatchedInB.append(matchOppInds[0])\n\n if len(matchesOpp) > 1:\n print(\"More than 1 match!\")\n\n elif len(matches) > 1:\n print(\"sc in A matches multiple sc's in B:\", sca.values, matches)\n else:\n scsMatchedInB.append(matchInds[0])\n\n # Also check all the start and end points:\n # This stuff isn't really being used right now...\n sp1, sp2 = sca.startPointValues, matches[0].startPointValues\n if sp1 != sp2:\n print(\"start points don't match\", sp1, sp2)\n ep1, ep2 = sca.endPointValues, matches[0].endPointValues\n if ep1 != ep2:\n print(\"end points don't match\", ep1, ep2)\n\n return scsMatchedInB, removeFromA, removeFromB"},"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 GetMatchedSubContourListsCollapsing(scListA, scListB):\n\n if (\n scListA == scListB\n ): # if we got the same object for some reason, just return 2 shallow clones\n return scListA, scListB\n\n scsMatchedInB = [] # This keeps us from looping over both lists\n\n scsMatchedInB, removeFromA, removeFromB = FindMatchesAndRemovals(scListA, scListB)\n unMatchedInB = [\n i for i in range(len(scListB)) if i not in scsMatchedInB\n ] # This lets us skip the indexes that already matched\n\n _, removeFromB_2, removeFromA_2 = FindMatchesAndRemovals(\n scListB, scListA, searchInds=unMatchedInB\n ) # FLIP\n\n removeFromA = sorted(list(set(removeFromA + removeFromA_2)))\n removeFromB = sorted(list(set(removeFromB + removeFromB_2)))\n\n scListANew = deepcopy(scListA)\n scListBNew = deepcopy(scListB)\n\n for i in removeFromA[::-1]:\n RemoveSubContour(scListA, i)\n for i in removeFromB[::-1]:\n RemoveSubContour(scListB, i)\n\n return scListANew, scListBNew","def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def analyzeContours(contours):\n if len(contours[0]) != 4 and len(contours[0]) != 8:\n return 0\n\n first, second, prev = [1, 1], [1, 1], 0\n for i, val in enumerate(numpy.nditer(contours[0])):\n if i % 2:\n second = [prev, val]\n else:\n first = [prev, val]\n\n # compare pair to the previous pair\n for num in first:\n if num in second:\n break\n else:\n return 0\n\n prev = val\n\n return 1","def GetMatchedSubContourLists(\n scListRef,\n scList,\n allValsByFrame,\n orderOfSCsByValue,\n splitLength=1,\n fixedNumInteriorPoints=None,\n):\n ## NOT DONE! MERGE LATER??\n return simplifiedSCListRef, simplifiedSCList","def compare(image_a, image_b, is_camera_image):\n\n # Generate a unique filename\n filename = uuid.uuid4().hex[:3]\n\n if is_camera_image:\n image_a = imutils.rotate_bound(image_a, 90)\n image_b = imutils.rotate_bound(image_b, 90)\n\n # Store original to show in future\n original = image_a\n\n # Convert to greyscale\n image_a = cv2.cvtColor(image_a, cv2.COLOR_BGR2GRAY)\n image_b = cv2.cvtColor(image_b, cv2.COLOR_BGR2GRAY)\n\n # Reduce size and blur to account for shaky handheld camera based images\n if is_camera_image:\n scale_multiplier = 0.03125\n image_a = cv2.resize(image_a, (0, 0), fx=scale_multiplier, fy=scale_multiplier)\n image_b = cv2.resize(image_b, (0, 0), fx=scale_multiplier, fy=scale_multiplier)\n image_a = cv2.GaussianBlur(image_a, (1001, 1001), cv2.BORDER_DEFAULT)\n image_b = cv2.GaussianBlur(image_b, (1001, 1001), cv2.BORDER_DEFAULT)\n\n # Obtain SSIM and determine differences\n try:\n _, differences = structural_similarity(image_a, image_b, full=True, gaussian_weights=True)\n except ValueError:\n print('Images are not the same size')\n return None\n\n # Convert to cv2 array\n differences = (differences * 255).astype('uint8')\n\n # Threshold and find contours (differences)\n thresh = cv2.threshold(differences, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\n contours = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n contours = imutils.grab_contours(contours)\n\n # Draw contours (differences)\n for cont in contours:\n (x, y, w, h) = cv2.boundingRect(cont)\n if is_camera_image:\n multiplier = int(1 / scale_multiplier)\n y *= multiplier\n x *= multiplier\n h *= multiplier\n w *= multiplier\n cv2.rectangle(original, (x, y), (x + w, y + h), (255, 0, 0), 4)\n\n # TODO: Create GIF highlighting differences (instead of statuic image)\n cv2.imwrite('static/images/differences/' + filename + '.jpg', original)\n\n return filename","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def remove_duplicates_by_matching():\n # 1) and 2)\n all_blobs = vision.pqr_r\n all_angles = np.zeros(0)\n right = np.transpose(vision.pqr_r)\n left = np.transpose(vision.pqr_l)\n\n if not right.size and not left.size:\n return (0, 0)\n\n if not right.size:\n for l in left:\n angle = np.arctan2(l[1], l[0]) * 180 / pi\n all_angles = np.append(all_angles, angle)\n return (vision.pqr_l, all_angles)\n\n if not left.size:\n for r in right:\n angle = np.arctan2(r[1], r[0]) * 180 / pi\n all_angles = np.append(all_angles, angle)\n return (vision.pqr_r, all_angles)\n\n\n for r in right:\n angle = np.arctan2(r[1], r[0]) * 180 / pi\n all_angles = np.append(all_angles, angle)\n cand_r = np.zeros((3,1))\n if angle < 15:\n cand_r = np.append(cand_r, [[r[0]], [r[1]], [r[2]]], axis=1)\n cand_r = np.delete(cand_r, 0, axis=1)\n cand_r = np.transpose(cand_r)\n\n for l in left:\n angle = np.arctan2(l[1], l[0]) * 180 / pi\n dot = 0\n if angle > -15:\n dl = max(0.001, np.linalg.norm(l))\n for r in cand_r:\n dr = max(0.001, np.linalg.norm(r))\n dot = np.dot(r, l) / (dr * dl)\n print(dot)\n if dot > 0.9:\n continue\n \n if dot <= 0.9:\n all_blobs = np.append(all_blobs, [[l[0]], [l[1]], [l[2]]], axis=1)\n all_angles = np.append(all_angles, angle)\n\n # make even number of blobs if necessary\n #if all_blobs.shape[1] % 2:\n # all_blobs = np.delete(all_blobs, 0, axis=1)\n # all_angles = np.delete(all_angles, 0)\n\n\n\n return (all_blobs, all_angles)","def find_cards(thresh_image):\n\n # Find contours and sort their indices by contour size\n cnts,hier = cv2.findContours(thresh_image,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\n index_sort = sorted(range(len(cnts)), key=lambda i : cv2.contourArea(cnts[i]),reverse=True)\n\n print(\"Contour length\", len(cnts))\n\n # If there are no contours, do nothing\n if len(cnts) == 0:\n return [], []\n\n # Otherwise, initialize empty sorted contour and hierarchy lists\n cnts_sort = []\n hier_sort = []\n cnt_is_card = np.zeros(len(cnts),dtype=int)\n\n # Fill empty lists with sorted contour and sorted hierarchy. Now,\n # the indices of the contour list still correspond with those of\n # the hierarchy list. The hierarchy array can be used to check if\n # the contours have parents or not.\n for i in index_sort:\n cnts_sort.append(cnts[i])\n hier_sort.append(hier[0][i])\n\n # Determine which of the contours are cards by applying the\n # following criteria: 1) Smaller area than the maximum card size,\n # 2), bigger area than the minimum card size, 3) have no parents,\n # and 4) have four corners\n\n for i in range(len(cnts_sort)):\n size = cv2.contourArea(cnts_sort[i])\n peri = cv2.arcLength(cnts_sort[i],True)\n approx = cv2.approxPolyDP(cnts_sort[i],0.01*peri,True)\n\n # (size < CARD_MAX_AREA) and (size > CARD_MIN_AREA)\n # and\n # and (hier_sort[i][3] == -1)\n # and (len(approx) == 4)\n if ((size > CARD_MIN_AREA)):\n print('[inside loop]',size)\n cnt_is_card[i] = 1\n\n return cnts_sort, cnt_is_card","def findMatchesBetweenImages(image_1, image_2):\n # matches - type: list of cv2.DMath\n matches = None\n # image_1_kp - type: list of cv2.KeyPoint items.\n image_1_kp = None\n # image_1_desc - type: numpy.ndarray of numpy.uint8 values.\n image_1_desc = None\n # image_2_kp - type: list of cv2.KeyPoint items.\n image_2_kp = None\n # image_2_desc - type: numpy.ndarray of numpy.uint8 values.\n image_2_desc = None\n # WRITE YOUR CODE HERE.\n\n sift = cv2.ORB_create()\n image_1_kp, image_1_desc = sift.detectAndCompute(image_1, None)\n image_2_kp, image_2_desc = sift.detectAndCompute(image_2, None)\n\n # bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)\n # matches = bf.match(image_1_desc, image_2_desc)\n # matches = sorted(matches, key = lambda x:x.distance)\n # matches = matches[:10]\n\n bf = cv2.BFMatcher()\n matches = bf.knnMatch(image_1_desc, image_2_desc, k=2)\n\n # Apply ratio test\n good = []\n for m, n in matches:\n print(m.distance, n.distance, m.distance < .75*n.distance)\n if m.distance < (0.75 * n.distance):\n good.append([m])\n\n # We coded the return statement for you. You are free to modify it -- just\n # make sure the tests pass.\n print(len(good), good)\n return image_1_kp, image_2_kp, matches\n # END OF FUNCTION.","def get_matches(src,dst,src_list, dst_list):\n matches=[]\n for src_conn in src_list:\n print src_conn\n if (src_conn in dst_list) & (src_conn<>dst):\n matches.append(src_conn)\n return matches","def img_compare(A, B):\r\n A = cv2.GaussianBlur(A, (5, 5), 5)\r\n B = cv2.GaussianBlur(B, (5, 5), 5)\r\n diff = cv2.absdiff(A, B) # absolute difference\r\n _, diff = cv2.threshold(diff, 200, 255, cv2.THRESH_BINARY)\r\n return np.sum(diff)","def parent_children_match(parent_snap_index, child_parent_snap_index):\n # too slow\n #parent_child_start_time = time.time()\n #parent_index_dict = dict( \n # (k, i) \n # for i, k in enumerate(parent_snap_index) \n # )\n #child_index_dict = dict( \n # (k, i) \n # for i, k in enumerate(child_parent_snap_index) \n # )\n #parent_child_meet = np.intersect1d( parent_snap_index, child_parent_snap_index ) \n\n #parents = np.array([\n # parent_index_dict[k] for k in parent_child_meet\n # ])\n #children = np.array([\n # child_index_dict[k] for k in parent_child_meet\n # ])\n #print 'Parent Child match takes ', time.time() - parent_child_start_time, ' seconds'\n \n #parent_child_start_time = time.time()\n parent_sort_index = np.argsort(parent_snap_index)\n child_sort_index = np.argsort(child_parent_snap_index)\n sorted_parent_snap_index = parent_snap_index[parent_sort_index]\n sorted_child_parent_snap_index = child_parent_snap_index[child_sort_index]\n\n parent_child_in1d = np.in1d(sorted_parent_snap_index, sorted_child_parent_snap_index)\n child_parent_in1d = np.in1d(sorted_child_parent_snap_index, sorted_parent_snap_index)\n \n parents = parent_sort_index[parent_child_in1d]\n children = child_sort_index[child_parent_in1d]\n #print 'Parent Child match takes ', time.time() - parent_child_start_time, ' seconds'\n\n return parents, children","def match(ra1, dec1, ra2, dec2, tol, allmatches=False):\n \n ra1,ra2,dec1,dec2 = map(np.asarray, (ra1, ra2, dec1, dec2))\n\n abs = np.abs\n\n isorted = ra2.argsort()\n sdec2 = dec2[isorted]\n sra2 = ra2[isorted]\n\n LIM = tol * DEG_PER_ASEC\n\n match = []\n # use mean dec, assumes decs similar\n decav = np.mean(sdec2.mean() + dec1.mean())\n RA_LIM = LIM / cos(decav * RAD_PER_DEG)\n\n for ra,dec in zip(ra1,dec1):\n i1 = sra2.searchsorted(ra - RA_LIM)\n i2 = i1 + sra2[i1:].searchsorted(ra + RA_LIM)\n #print(i1,i2)\n close = []\n for j in xrange(i1,i2):\n if abs(dec - sdec2[j]) > LIM:\n continue\n else:\n # if ras and decs are within LIM arcsec, then\n # calculate actual separation:\n disq = ang_sep(ra, dec, sra2[j], sdec2[j])\n close.append((disq, j))\n\n close.sort()\n if not allmatches:\n # Choose the object with the closest separation inside the\n # requested tolerance, if one was found.\n if len(close) > 0:\n min_dist, jmin = close[0]\n if min_dist < LIM:\n match.append((isorted[jmin], min_dist))\n continue\n # otherwise no match\n match.append((-1,-1))\n else:\n # append all the matching objects\n jclose = []\n seps = []\n for dist,j in close:\n if dist < LIM:\n jclose.append(j)\n seps.append(dist)\n else:\n break\n match.append(fromarrays([isorted[jclose], seps],\n dtype=[(str('ind'),str('i8')),\n str(('sep'),str('f8'))\n ]))\n\n if not allmatches:\n # return both indices and separations in a recarray\n temp = np.rec.fromrecords(match, names=str('ind,sep'))\n # change to arcseconds\n temp.sep *= 3600.\n temp.sep[temp.sep < 0] = -1.\n return temp\n else:\n return match","def subcontract(a, b):\n for x in a:\n for y in b:\n if common_side(x, y):\n return 1\n return 0","def take_contours(self):\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]","def find_contours(thresh):\n thresh = thresh.astype(np.uint8)\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n\n # filter outer contours\n filtered_cont = []\n for i in range(len(contours)):\n if hierarchy[0, i, 3] == NO_PARENT:\n filtered_cont.append(contours[i])\n\n return filtered_cont","def match(image1,image2,threshold,useRansac=False,t_orientation=30,t_scale=0.5):\r\n im1, keypoints1, descriptors1 = ReadKeys(image1)\r\n im2, keypoints2, descriptors2 = ReadKeys(image2)\r\n #\r\n # REPLACE THIS CODE WITH YOUR SOLUTION (ASSIGNMENT 5, QUESTION 3)\r\n #\r\n # Generate five random matches (for testing purposes)\r\n # matched_pairs = []\r\n # num = 5\r\n # for i in range(num):\r\n # matched_pairs.append([keypoints1[i],keypoints2[i]])\r\n # return DisplayMatches(im1, im2, matched_pairs)\r\n\r\n # END OF SECTION OF CODE TO REPLACE\r\n #\r\n\r\n #q3\r\n matched_pairs = []\r\n between_angles = np.arccos(np.dot(descriptors1, np.transpose(descriptors2)))\r\n for i, row in enumerate(between_angles):\r\n \tratio = sorted(row)[0] / sorted(row)[1]\r\n \tif ratio <= threshold:\r\n\t \tmatched_pairs.append([keypoints1[i], keypoints2[np.where(row == sorted(row)[0])[0][0]]])\r\n # print(matched_pairs)\r\n if useRansac is False:\r\n return DisplayMatches(im1, im2, matched_pairs)\r\n\t# \r\n\r\n #q4\r\n repetition = 10\r\n subsets = [[]] * repetition\r\n for i in range(repetition):\r\n r = random.randint(0, len(matched_pairs))\r\n for match in matched_pairs:\r\n ds1, ds2 = matched_pairs[r][1][2]/matched_pairs[r][0][2], match[1][2]/match[0][2]\r\n do1, do2 = (matched_pairs[r][1][3]-matched_pairs[r][0][3]), (match[1][3]-match[0][3])\r\n if abs(ds2 - ds1) <= t_scale * ds1 and abs(do2 - do1) % (2 * math.pi) <= t_orientation:\r\n subsets[i].append(match)\r\n\r\n max_i, max_len = 0, subsets[0]\r\n for i in range(10):\r\n l = len(subsets[i])\r\n if l > max_len:\r\n max_len = l\r\n max_i = i\r\n\r\n im3 = DisplayMatches(im1, im2, subsets[max_i])\r\n return im3","def marge_matches(fm_A, fm_B, fsv_A, fsv_B):\n # Flag rows found in both fmA and fmB\n # that are intersecting (both) or unique (only)\n import vtool as vt\n flags_both_A, flags_both_B = vt.intersect2d_flags(fm_A, fm_B)\n flags_only_A = np.logical_not(flags_both_A)\n flags_only_B = np.logical_not(flags_both_B)\n # independent matches\n fm_both_AB = fm_A.compress(flags_both_A, axis=0)\n fm_only_A = fm_A.compress(flags_only_A, axis=0)\n fm_only_B = fm_B.compress(flags_only_B, axis=0)\n # independent scores\n fsv_both_A = fsv_A.compress(flags_both_A, axis=0)\n fsv_both_B = fsv_B.compress(flags_both_B, axis=0)\n fsv_only_A = fsv_A.compress(flags_only_A, axis=0)\n fsv_only_B = fsv_B.compress(flags_only_B, axis=0)\n # build merge offsets\n offset1 = len(fm_both_AB)\n offset2 = offset1 + len(fm_only_A)\n offset3 = offset2 + len(fm_only_B)\n # Merge feature matches\n fm_merged = np.vstack([fm_both_AB, fm_only_A, fm_only_B])\n # Merge feature scores\n num_rows = fm_merged.shape[0]\n num_cols_A = fsv_A.shape[1]\n num_cols_B = fsv_B.shape[1]\n num_cols = num_cols_A + num_cols_B\n fsv_merged = np.full((num_rows, num_cols), np.nan)\n fsv_merged[0:offset1, 0:num_cols_A] = fsv_both_A\n fsv_merged[0:offset1, num_cols_A:] = fsv_both_B\n fsv_merged[offset1:offset2, 0:num_cols_A] = fsv_only_A\n fsv_merged[offset2:offset3, num_cols_A:] = fsv_only_B\n return fm_merged, fsv_merged","def find_original_contours(self):\r\n\r\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\r\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\r\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\r\n int(self.cell_size), 5)\r\n self.thresh_orig = 255 - self.thresh_invert\r\n\r\n # Find the contours of the image. Each contour should correspond to a cell\r\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\r\n for block in orig_contours:\r\n area = cv2.contourArea(block)\r\n\r\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\r\n if area < self.min_cell_size:\r\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)","def _compositions_swapped(self, thermo):\n assert self._ref_indicators is not None\n\n indicators = self._singlet_comparison(thermo)\n\n for list1, list2 in zip(indicators, self._ref_indicators):\n comp_swapped = True\n for ind1, ind2 in zip(list1, list2):\n if ind1 == ind2:\n comp_swapped = False\n if comp_swapped:\n return True\n return False","def intersect(pieceA, pieceB):\n return pieceA[0] in pieceB or pieceA[1] in pieceB","def compute_contour_coverage(\n contoursA: ContourList,\n contoursB: ContourList,\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\n):\n arr = np.zeros((len(contoursA), len(contoursB)), dtype=\"float32\")\n box_coverage = compute_coverage(\n *[\n np.array(\n [\n np.concatenate([contour.min(axis=0), contour.max(axis=0)])\n for contour in contours\n ]\n )\n for contours in [contoursA, contoursB]\n ]\n )\n for idx1, contour1 in enumerate(contoursA):\n for idx2, contour2 in enumerate(contoursB):\n if box_coverage[idx1, idx2] == 0:\n arr[idx1, idx2] = 0\n continue\n arr[idx1, idx2] = compute_coverage_for_contour_pair(\n contour1, contour2, max_size=max_size\n )\n return arr","def __find_contours(input1, external_only):\n if(external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n contours, hierarchy = cv2.findContours(input1, cv2.RETR_TREE, method=method)\n return contours","def matchShapes(cnt1, cnt2):\n\tret = cv2.matchShapes(cnt1, cnt2, 1, 0.0)\n\treturn ret","def chk_chng(src_flist,dst_flist):\n uc_flist = []\n c_flist = []\n for files in src_flist:\n if files in dst_flist:\n uc_flist.append(files)\n else:\n c_flist.append(files)\n return uc_flist,c_flist","def backtrack2(B):\n tracH, tracV=[],[]\n lenR, lenC = len(B)-1, len(B[0])-1\n R,C =lenR,lenC;\n while R>0 and C>0:\n LL,TT,LT = B[R][C-1], B[R-1][C], B[R-1][C-1] ## Left,Top,LeftTop\n max3=max(LL, TT, LT)\n if max3==LT:\n if LT==B[R][C]-1: ## otherwise, it is a subsitution\n tracH.append(R-1); tracV.append(C-1)\n R-=1; C-=1\n elif max3==TT: R-=1\n else : C-=1\n tracV.reverse(); tracH.reverse()\n return tracH, tracV","def sort_filtered_contours(self):\r\n\r\n # Get the contours again\r\n invert = 255 - self.thresh_invert\r\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\r\n\r\n # Make sure that they're within the correct range for size\r\n # If too small, it is probably noise; if too large, then should be things around the grid\r\n for i, c in enumerate(real_contours, 1):\r\n contour_area = cv2.contourArea(c)\r\n if self.min_cell_size < contour_area < self.max_cell_size:\r\n self.good_contours.append(c)\r\n\r\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\r\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\r\n\r\n # Sort the contours from top to bottom\r\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\"top-to-bottom\")\r\n\r\n # We then sort each row from left to right\r\n row = []\r\n for i, c in enumerate(half_sorted_contours, 1):\r\n row.append(c)\r\n if i % self.board_dimension == 0:\r\n (full_sorted_contours, _) = contours.sort_contours(row, method=\"left-to-right\")\r\n self.game_board_contours.append(full_sorted_contours)\r\n row = []","def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\n orderOfSCsByValueByFrame = [\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\n ]\n return scListByFrame, orderOfSCsByValueByFrame","def _red_detect_(self, nslice = 0, thresh = 2.0):\n zk_1 = 's_' + format(nslice, '03d')\n zk_2 = 's_' + format(nslice+1, '03d')\n\n zf_1 = self.z_dense[zk_1]\n zf_2 = self.z_dense[zk_2]\n\n # extract the y and x coordinates\n y1 = zf_1[:,0]\n x1 = zf_1[:,1]\n\n y2 = zf_2[:,0]\n x2 = zf_2[:,1]\n\n\n # create a meshgrid\n [YC, YR] = np.meshgrid(y2, y1)\n [XC, XR] = np.meshgrid(x2, x1)\n\n\n dist_block = np.sqrt((YC-YR)**2 + (XC-XR)**2)\n red_pair = np.where(dist_block <= thresh) # find out where the distance between cell i in plane k and cell j in plane k+1 is below the threshold.\n\n ind1 = red_pair[0] # the indices in the first frame\n ind2 = red_pair[1] # the indices in the second frame\n\n\n # select those with markers > 0 and markers < 0\n marker_1 = zf_1[ind1, 3]\n\n\n new_idx = (marker_1 == 0) # select those with zero-markers, which are never counted before. These are new cells. marker_1 needs to be updated.\n pool_new = ind1[new_idx] # select the indices in the first frame where new redundancies are detected \n pool_new_cov = ind2[new_idx] # select the indices in the second frame where new redundancies are detected.\n\n\n pool_exist = ind1[~new_idx] # among the detected redundancies, find those already marked.\n pool_exist_cov = ind2[~new_idx] # correspondingly, find those already marked in the adjacent slice\n\n n_new = len(pool_new)\n n_exist = len(pool_exist)\n if self.verbose:\n print(n_new, \"new redundancies, \", n_exist, \"existing redundancies\")\n\n for n_count in np.arange(n_new):\n # build the new keys\n # also, we need to assign each new key an identity number which is unique.\n n_ind1 = pool_new[n_count] # find the indices in the first slice that contains new redundancies\n n_ind2 = pool_new_cov[n_count] # find the indices in the following slice \n pr_number = nslice * 1000 + n_ind1\n pr_key = 'sl_' + str(pr_number) # build a key \n new_sl = Simple_list(nslice) # create a simple list with z_marker = nslice, nslice is the index of the first z-slice \n new_sl.add([nslice, zf_1[n_ind1, 4]])\n new_sl.add([nslice+1, zf_2[n_ind2, 4]])\n zf_1[n_ind1, 3] = pr_number # assign the new pr_number to zf_1\n zf_2[n_ind2, 3] = pr_number # assigne the same new pr_number to zf_2\n\n self.redundancy_pool[pr_key] = new_sl # stored into the redundancy pool\n\n\n for n_count in np.arange(n_exist):\n # search for the existing keys\n n_ind1 = pool_exist[n_count]\n n_ind2 = pool_exist_cov[n_count]\n pr_number = int(zf_1[n_ind1, 3])# catch up the pr_number\n pr_key = 'sl_' + str(pr_number) # this pr_key should already exist in the pool. \n\n self.redundancy_pool[pr_key].add([nslice+1, zf_2[n_ind2, 4]])\n zf_2[n_ind2, 3] = pr_number # update the pr_number in the adjacent slice","def max_disp(left_img, right_img):\n\n # Max initial matches\n MAX_INI_MATCH = np.inf\n\n # ORB detector and brute-force matcher\n detector = cv2.ORB_create(nfeatures=100000, edgeThreshold=5)\n matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)\n\n # Find the keypoints and descriptors of both images\n keypoint_left, descriptor_left = detector.detectAndCompute(\n image=left_img, mask=None\n )\n keypoint_right, descriptor_right = detector.detectAndCompute(\n image=right_img, mask=None\n )\n\n # Find the best matches\n matches = matcher.match(\n queryDescriptors=descriptor_left, trainDescriptors=descriptor_right\n )\n matches = sorted(matches, key=lambda x: x.distance)\n\n if DEBUG:\n print(f\"Initial matches#\")\n print(f\"match_lr: {len(matches)}\")\n\n # Match refinement with RANSAC\n left_pts = np.float32([keypoint_left[m.queryIdx].pt for m in matches]).reshape(\n -1, 1, 2\n )\n right_pts = np.float32([keypoint_right[m.trainIdx].pt for m in matches]).reshape(\n -1, 1, 2\n )\n homography, mask = cv2.findHomography(left_pts, right_pts, cv2.RANSAC, 5.0)\n matchesMask = mask.ravel().tolist()\n\n ransac_matches = []\n for (m, keep) in zip(matches, matchesMask):\n if keep:\n ransac_matches.append(m)\n\n if DEBUG:\n print(f\"After RANSAC:\")\n print(f\"match: {len(ransac_matches)}\")\n ransac_img = cv2.drawMatches(\n left_img,\n keypoint_left,\n right_img,\n keypoint_right,\n ransac_matches,\n None,\n flags=2,\n )\n cv2.imwrite(\"./debug/RANSAC.png\", ransac_img)\n\n # Get the range of disparity\n disp_min = np.inf\n disp_max = 0\n\n for m in ransac_matches:\n # Keypoints coordinates\n pt_left = np.float32(keypoint_left[m.queryIdx].pt)\n pt_right = np.float32(keypoint_right[m.trainIdx].pt)\n\n # Compute the distance\n dist = int(abs(pt_left - pt_right)[0])\n\n if disp_max < dist:\n disp_max = dist\n\n # Ceiling the number\n disp_max += 1\n\n return disp_max","def correspondence_points(img1, img2, tag='c'):\n if len(img1.shape) == 3:\n img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)\n if len(img2.shape) == 3:\n img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)\n\n detector = cv2.SURF(800)\n norm = cv2.NORM_L2\n flann_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)\n matcher = cv2.FlannBasedMatcher(flann_params, {}) # bug : need to pass empty dict (#1329)\n kp1, desc1 = detector.detectAndCompute(img1, None)\n kp2, desc2 = detector.detectAndCompute(img2, None)\n raw_matches = matcher.knnMatch(desc1, trainDescriptors = desc2, k = 2) #2\n p1, p2, kp_pairs = filter_matches(kp1, kp2, raw_matches)\n\n if len(p1) >= 4:\n H, status = cv2.findHomography(p1, p2, cv2.RANSAC, 5.0)\n print '%d / %d inliers/matched' % (np.sum(status), len(status))\n status = status.reshape(-1) # flatten\n p1 = p1[status == 1]\n p2 = p2[status == 1]\n kp_pairs = [kp_pairs[i] for i in range(len(kp_pairs)) if status[i] == 1]\n else:\n # Just depend on the thresholding for filtering matches\n p1, p2, kp_pairs = filter_matches(kp1, kp2, raw_matches, ratio=0.3)\n\n draw_correspondence_points(img1, img2, kp_pairs, tag=tag)\n return p1, p2, kp_pairs","def get_pair_rects(contours):\n\n rect_pairs = []\n for index, cnt in enumerate(contours):\n # Rotated rect - ( center (x,y), (width, height), angle of rotation )\n rect = cv2.minAreaRect(cnt)\n center_x, center_y = rect[0]\n rect_angle = -round(rect[2], 2)\n\n if rect_angle > 45.0:\n # Iterate through all of the potential matches\n min_x_dist = min_rect = min_index = None\n for pot_index, pot_match in enumerate(contours):\n if np.array_equal(pot_match, cnt):\n continue\n\n match_rect = cv2.minAreaRect(pot_match)\n\n # Check if match is to the right of the contour\n if match_rect[0][0] > rect[0][0] and abs(\n match_rect[2] - rect_angle) > ANGLE_TOLERANCE_DEG:\n x_distance = match_rect[0][0] - rect[0][0]\n\n if min_x_dist is None or x_distance < min_x_dist:\n min_x_dist = x_distance\n min_rect = match_rect\n min_index = pot_index\n\n if min_rect is not None:\n rect_pairs.append((rect, min_rect))\n np.delete(contours, index)\n np.delete(contours, min_index)\n\n return rect_pairs","def compareTwoReco(reference, new, histos, debug=1):\n\n # Tracks with index False are the ones that have been matched to the reference track collection\n new_valid = [True for i in new]\n\n # Tracks with index False are the ones that have been matched to the comparison track collection\n original_valid = [True for i in reference]\n print \" \".join(\"%10s\" % k for k in variables)\n debug_verbose = checkDebug(debug, 'Verbose')\n debug_ordinary = checkDebug(debug, 'Ordinary')\n debug_recovery = checkDebug(debug, 'Recovery')\n debug_lost = checkDebug(debug, 'Lost')\n debug_fake = checkDebug(debug, 'Fake')\n\n for original_index, original in enumerate(reference):\n # Fill in cumulative plots for the reference sample first\n histos['reference_hits_vs_algo'].Fill(original.algo, original.hits)\n histos['reference_hits_vs_orialgo'].Fill(original.orialgo, original.hits)\n histos['reference_hits_vs_pt'].Fill(original.pt, original.hits)\n histos['den'].Fill(original.pt)\n histos['den_eta'].Fill(original.eta)\n histos['den_phi'].Fill(original.phi)\n histos['den_hits'].Fill(original.hits)\n histos['den_algo'].Fill(original.algo)\n histos['den_orialgo'].Fill(original.orialgo)\n\n # Now start to look for a matching track in the comparison track collection\n window_depth = 400 # elements to span to look for best candidate\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = -1, 100, 100\n if debug_verbose:\n print original\n for i,j in enumerate(new):\n if new_valid[i] == True:\n if debug_verbose:\n print \" \", i, j\n if window_depth == 0:\n break\n dr_squared, dPt_over_pt = match(original, j)\n if dr_squared < bestDeltaRMatch*bestDeltaRMatch and dPt_over_pt < DELTA_PT_OVER_PT_CUT:\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = i, dr_squared, dPt_over_pt\n if debug_verbose:\n print \" \", window_depth, iBest, bestDeltaRMatch, dr_squared, bestDeltaPt_over_PtMatch, dPt_over_pt\n if bestDeltaRMatch <= 0.0001 or bestDeltaPt_over_PtMatch == 0.0001:\n break\n window_depth -= 1\n if iBest != -1 and bestDeltaRMatch < DELTA_R_CUT:\n # These are the tracks in the reference track collection\n # that have been matched to a track in the comparison\n # track collection\n new_valid[iBest] = False\n original_valid[original_index] = False\n assert original.run == new[iBest].run, \"run mismatch\"\n assert original.ls == new[iBest].ls, \"ls mismatch\"\n assert original.event == new[iBest].event, \"event mismatch\"\n if debug_ordinary:\n print original\n print new[iBest]\n print iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch, '\\n'\n histos['num'].Fill(original.pt)\n histos['num_eta'].Fill(original.eta)\n histos['num_phi'].Fill(original.phi)\n histos['num_hits'].Fill(original.hits)\n histos['num_algo'].Fill(original.algo)\n histos['num_orialgo'].Fill(original.orialgo)\n histos['fake_num'].Fill(new[iBest].pt)\n histos['fake_num_eta'].Fill(new[iBest].eta)\n histos['fake_num_phi'].Fill(new[iBest].phi)\n histos['fake_num_hits'].Fill(new[iBest].hits)\n histos['fake_num_algo'].Fill(new[iBest].algo)\n histos['fake_num_orialgo'].Fill(new[iBest].orialgo)\n histos['comparison_algo_vs_reference_algo'].Fill(original.algo, new[iBest].algo)\n histos['comparison_orialgo_vs_reference_orialgo'].Fill(original.orialgo, new[iBest].orialgo)\n histos['comparison_hits_vs_reference_hits'].Fill(original.hits, new[iBest].hits)\n\n # Let's try a recovery loop with somewhat lesser stringent cuts\n for original_index, original in enumerate(reference):\n if original_valid[original_index]:\n # Now start to look for a matching track in the comparison track collection\n window_depth = 300 # elements to span to look for best candidate\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = -1, 100, 100\n if debug_verbose:\n print \"Recovery \", original\n for i,j in enumerate(new):\n if new_valid[i] == True:\n if debug_verbose:\n print \"Recovery \", i, j\n if window_depth == 0:\n break\n dr_squared, dPt_over_pt = match(original, j)\n if dr_squared < bestDeltaRMatch*bestDeltaRMatch and dPt_over_pt < DELTA_PT_OVER_PT_CUT*6:\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = i, dr_squared, dPt_over_pt\n if debug_verbose:\n print \"Recovery \", window_depth, iBest, bestDeltaRMatch, dr_squared, bestDeltaPt_over_PtMatch, dPt_over_pt\n if bestDeltaRMatch <= 0.0001 or bestDeltaPt_over_PtMatch == 0.0001:\n break\n window_depth -= 1\n if iBest != -1 and bestDeltaRMatch < DELTA_R_CUT*10: # inflate cut on DeltaR to recover some good-medium matching\n # These are the tracks in the reference track collection\n # that have been matched to a track in the comparison\n # track collection\n new_valid[iBest] = False\n original_valid[original_index] = False\n if debug_recovery:\n print \"Recovery \", original\n print \"Recovery \", new[iBest]\n print \"Recovery \", iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch\n histos['num'].Fill(original.pt)\n histos['num_eta'].Fill(original.eta)\n histos['num_phi'].Fill(original.phi)\n histos['num_hits'].Fill(original.hits)\n histos['num_algo'].Fill(original.algo)\n histos['num_orialgo'].Fill(original.orialgo)\n histos['fake_num'].Fill(new[iBest].pt)\n histos['fake_num_eta'].Fill(new[iBest].eta)\n histos['fake_num_hits'].Fill(new[iBest].hits)\n histos['fake_num_algo'].Fill(new[iBest].algo)\n histos['fake_num_orialgo'].Fill(new[iBest].orialgo)\n histos['comparison_algo_vs_reference_algo'].Fill(original.algo, new[iBest].algo)\n histos['comparison_orialgo_vs_reference_orialgo'].Fill(original.orialgo, new[iBest].orialgo)\n histos['comparison_hits_vs_reference_hits'].Fill(original.hits, new[iBest].hits)\n\n\n # These are the tracks in the reference track collection\n # that have *not* been associated to any track in the\n # comparison collection == > LOST TRACKS\n reference_not_assigned = [j for i,j in enumerate(reference) if original_valid[i]]\n reference_not_assigned.sort(key=lambda tr: tr.algo)\n if debug_lost:\n print \"**** Lost tracks **** %d\" % len(reference_not_assigned)\n for j in reference_not_assigned:\n histos['lost_hits_vs_algo'].Fill(j.algo, j.hits)\n histos['lost_hits_vs_orialgo'].Fill(j.orialgo, j.hits)\n histos['lost_hits_vs_pt'].Fill(j.pt, j.hits)\n histos['lost_eta'].Fill(j.eta)\n if debug:\n print j\n if debug_lost:\n print \"**** End of Lost tracks ****\"\n\n # Fake Tracks\n for i, j in enumerate(new):\n # Fill in the cumulative plots related to tracks in the comparison track collection\n histos['comparison_hits_vs_algo'].Fill(j.algo, j.hits)\n histos['comparison_hits_vs_orialgo'].Fill(j.orialgo, j.hits)\n histos['comparison_hits_vs_pt'].Fill(j.pt, j.hits)\n histos['fake_den'].Fill(j.pt)\n histos['fake_den_eta'].Fill(j.eta)\n histos['fake_den_phi'].Fill(j.phi)\n histos['fake_den_hits'].Fill(j.hits)\n histos['fake_den_algo'].Fill(j.algo)\n histos['fake_den_orialgo'].Fill(j.orialgo)\n\n # These are the tracks in the comparison track collection\n # that have *not* been associated to any track in the\n # reference collection ==> FAKE TRACKS\n new_not_assigned = [j for i,j in enumerate(new) if new_valid[i]]\n new_not_assigned.sort(key=lambda tr: tr.algo)\n if debug_fake:\n print \"**** Fake tracks **** %d\" % len(new_not_assigned)\n for j in new_not_assigned:\n histos['fake_hits_vs_algo'].Fill(j.algo, j.hits)\n histos['fake_hits_vs_orialgo'].Fill(j.orialgo, j.hits)\n histos['fake_hits_vs_pt'].Fill(j.pt, j.hits)\n if debug:\n print j\n if debug_fake:\n print \"**** End of Fake tracks ****\"","def matchExplorer(win, img1, img2, kp_pairs=(), status = None, H = None, show=True, block= True, daemon=True):\n # FIXME keypoints visualization wrong\n # functions\n ## GET INITIAL VISUALIZATION\n if len(img1.shape)<3:\n img1 = cv2.cvtColor(img1,cv2.COLOR_GRAY2BGR)\n if len(img2.shape)<3:\n img2 = cv2.cvtColor(img2,cv2.COLOR_GRAY2BGR)\n\n h1, w1 = img1.shape[:2] # obtaining image1 dimensions\n h2, w2 = img2.shape[:2] # obtaining image2 dimensions\n # imgf and imgb will be visualized horizontally (left-right)\n vis = np.zeros((max(h1, h2), w1+w2,3), np.uint8) # making visualization image\n vis[:h1, :w1] = img1 # imgf at the left of vis\n vis[:h2, w1:w1+w2] = img2 # imgf at the right of vis\n\n if status is None:\n status = np.ones(len(kp_pairs), np.bool_) # making sure every pair of keypoints is graphed\n\n kp_pairs = [(dict2keyPoint(i),dict2keyPoint(j)) for i,j in kp_pairs]\n p1 = FLOAT([kpp[0].pt for kpp in kp_pairs]) # pair of coordinates for imgf\n p2 = FLOAT([kpp[1].pt for kpp in kp_pairs]) + (w1, 0) # pair of coordinates for imgb\n\n if H is not None:# does the same as getTransformedCorners\n corners = FLOAT([[0, 0], [w1, 0], [w1, h1], [0, h1]])\n corners = np.int32(cv2.perspectiveTransform(corners.reshape(1, -1, 2), H).reshape(-1, 2) + (w1, 0))\n\n def drawline(self):\n vis = self.rimg\n self.thick = int(sigmoid(vis.shape[0] * vis.shape[1], 1723567, 8080000, 5, 1))\n if H is not None: # enclosing object\n rcorners = np.array([self.real2render(corner[0],corner[1]) for corner in corners],np.int32)\n cv2.polylines(vis, [rcorners], True, self.framecolor) # draw rendered TM encasing\n\n rp1,rp2 = [],[]\n for (x1, y1), (x2, y2), inlier in zip(p1, p2, status):\n rx1,ry1 = self.real2render(x1,y1,np.int32) # real to render\n rx2,ry2 = self.real2render(x2,y2,np.int32) # real to render\n rp1.append((rx1,ry1))\n rp2.append((rx2,ry2))\n r = self.thick\n if inlier and self.showgoods: # drawing circles (good keypoints)\n col = self.goodcolor\n cv2.circle(vis, (rx1, ry1), r, col, -1) # for left keypoint (imgf)\n cv2.circle(vis, (rx2, ry2), r, col, -1) # for right keypoint (imgf)\n elif self.showbads: # drawing x marks (wrong keypoints)\n col = self.badcolor\n thickness = r+5\n # for left keypoint (imgf)\n cv2.line(vis, (rx1-r, ry1-r), (rx1+r, ry1+r), col, thickness)\n cv2.line(vis, (rx1-r, ry1+r), (rx1+r, ry1-r), col, thickness)\n # for right keypoint (imgf)\n cv2.line(vis, (rx2-r, ry2-r), (rx2+r, ry2+r), col, thickness)\n cv2.line(vis, (rx2-r, ry2+r), (rx2+r, ry2-r), col, thickness)\n # drawing lines for non-onmouse event\n self.rp1 = np.int32(rp1)\n self.rp2 = np.int32(rp2)\n self.vis0 = vis.copy() # saving state of the visualization for onmouse event\n # get rendered kp_pairs\n self.kp_pairs2 = apply2kp_pairs(kp_pairs,self.real2render,self.real2render)\n # drawing lines for non-onmouse event\n for (rx1, ry1), (rx2, ry2), inlier in zip(rp1, rp2, status):\n if inlier and self.showgoods:\n cv2.line(vis, (rx1, ry1), (rx2, ry2), self.goodcolor,r)\n self.vis = vis#.copy() # visualization with all inliers\n\n def drawrelation(self):\n if self.flags & cv2.EVENT_FLAG_LBUTTON:\n x,y = self.rx, self.ry\n cur_vis = self.vis0.copy() # actual visualization\n r = self.thick + 8 # proximity to keypoint\n m = (anorm(self.rp1 - (x, y)) < r) | (anorm(self.rp2 - (x, y)) < r)\n idxs = np.where(m)[0] # get indexes near pointer\n kp1s, kp2s = [], []\n for i in idxs: # for all keypints near pointer\n (rx1, ry1), (rx2, ry2) = self.rp1[i], self.rp2[i] # my keypoint\n col = (self.badcolor, self.goodcolor)[status[i]] # choosing False=red,True=green\n cv2.line(cur_vis, (rx1,ry1), (rx2,ry2), col, self.thick) # drawing line\n # keypoints to show on event\n kp1, kp2 = self.kp_pairs2[i]\n kp1s.append(kp1)\n kp2s.append(kp2)\n # drawing keypoints near pointer for imgf and imgb\n cur_vis = cv2.drawKeypoints(cur_vis, kp1s, flags=4, color=self.kpcolor)\n cur_vis = cv2.drawKeypoints(cur_vis, kp2s, flags=4, color=self.kpcolor)\n self.rimg = cur_vis\n else:\n self.rimg = self.vis\n\n if self.y is not None and self.x is not None:\n self.builtinplot(self.sample[self.y,self.x])\n\n def randomColor():\n return (np.random.randint(0,255), np.random.randint(0,255), np.random.randint(0,255))\n\n def mousefunc(self):\n if self.builtincontrol():\n self.updaterenderer()\n drawline(self)\n\n drawrelation(self)\n\n def keyfunc(self):\n if self.builtincmd():\n drawline(self)\n drawrelation(self)\n if self.y is not None and self.x is not None:\n self.builtinplot(self.img[self.y,self.x])\n else:\n self.builtinplot()\n\n self = plotim(win, vis)\n self.mousefunc = mousefunc\n self.keyfunc = keyfunc\n self.showgoods = True\n self.showbads = False\n from image import colors\n self.__dict__.update(colors)\n self.randomColor = randomColor\n self.goodcolor = self.green\n self.badcolor = self.red\n self.kpcolor = self.orange\n self.framecolor = self.blue\n self.cmdlist.extend([\"showgoods\",\"showbads\",\"framecolor\",\"kpcolor\",\"badcolor\",\"goodcolor\"])\n drawline(self)\n # show window\n if show: self.show(block= block, daemon=daemon)\n return self #self.rimg # return coordinates","def matchShapesImages(img1, img2):\n\tcnt1 = findContours(img1)[0]\n\tcnt2 = findContours(img2)[0]\n\tret = cv2.matchShapes(cnt1, cnt2, 1, 0.0)\n\treturn ret","def intersect(A,B,C,D):\n def ccw(A,B,C):\n return (C[iY]-A[iY]) * (B[iX]-A[iX]) > (B[iY]-A[iY]) * (C[iX]-A[iX])\n return ccw(A,C,D) != ccw(B,C,D) and ccw(A,B,C) != ccw(A,B,D)","def bins_match (a, b):\n return 0 == (\n np.sum ((a.xbins - b.xbins)**2)\n + np.sum ((a.ybins - b.ybins)**2) )","def find_contours(dframe):\n #Blur the image.\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\n #if debug:\n #plt.imshow(fixColor(blurred))\n #plt.show()\n #Get a threshold image, numbers where tested for the given video.\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \n cv2.CHAIN_APPROX_SIMPLE)\n return cnts","def create_non_correspondences(uv_b_matches, img_b_shape, num_non_matches_per_match=100, img_b_mask=None):\n image_width = img_b_shape[1]\n image_height = img_b_shape[0]\n # print(\"uv_b_matches: \", uv_b_matches)\n if uv_b_matches == None:\n return None\n\n num_matches = len(uv_b_matches[0])\n\n def get_random_uv_b_non_matches():\n return pytorch_rand_select_pixel(width=image_width,height=image_height, \n num_samples=num_matches*num_non_matches_per_match)\n\n if img_b_mask is not None:\n img_b_mask_flat = img_b_mask.view(-1,1).squeeze(1)\n mask_b_indices_flat = torch.nonzero(img_b_mask_flat)\n if len(mask_b_indices_flat) == 0:\n print(\"warning, empty mask b\")\n uv_b_non_matches = get_random_uv_b_non_matches()\n else:\n num_samples = num_matches*num_non_matches_per_match\n rand_numbers_b = torch.rand(num_samples)*len(mask_b_indices_flat)\n rand_indices_b = torch.floor(rand_numbers_b).long()\n randomized_mask_b_indices_flat = torch.index_select(mask_b_indices_flat, 0, rand_indices_b).squeeze(1)\n uv_b_non_matches = (randomized_mask_b_indices_flat%image_width, randomized_mask_b_indices_flat/image_width)\n else:\n uv_b_non_matches = get_random_uv_b_non_matches()\n \n # for each in uv_a, we want non-matches\n # first just randomly sample \"non_matches\"\n # we will later move random samples that were too close to being matches\n uv_b_non_matches = (uv_b_non_matches[0].view(num_matches,num_non_matches_per_match), uv_b_non_matches[1].view(num_matches,num_non_matches_per_match))\n\n # uv_b_matches can now be used to make sure no \"non_matches\" are too close\n # to preserve tensor size, rather than pruning, we can perturb these in pixel space\n copied_uv_b_matches_0 = torch.t(uv_b_matches[0].repeat(num_non_matches_per_match, 1))\n copied_uv_b_matches_1 = torch.t(uv_b_matches[1].repeat(num_non_matches_per_match, 1))\n\n diffs_0 = copied_uv_b_matches_0 - uv_b_non_matches[0].type(dtype_float)\n diffs_1 = copied_uv_b_matches_1 - uv_b_non_matches[1].type(dtype_float)\n\n diffs_0_flattened = diffs_0.contiguous().view(-1,1)\n diffs_1_flattened = diffs_1.contiguous().view(-1,1)\n\n diffs_0_flattened = torch.abs(diffs_0_flattened).squeeze(1)\n diffs_1_flattened = torch.abs(diffs_1_flattened).squeeze(1)\n\n\n need_to_be_perturbed = torch.zeros_like(diffs_0_flattened)\n ones = torch.zeros_like(diffs_0_flattened)\n num_pixels_too_close = 1.0\n threshold = torch.ones_like(diffs_0_flattened)*num_pixels_too_close\n\n # determine which pixels are too close to being matches\n need_to_be_perturbed = where(diffs_0_flattened < threshold, ones, need_to_be_perturbed)\n need_to_be_perturbed = where(diffs_1_flattened < threshold, ones, need_to_be_perturbed)\n\n minimal_perturb = num_pixels_too_close/2\n minimal_perturb_vector = (torch.rand(len(need_to_be_perturbed))*2).floor()*(minimal_perturb*2)-minimal_perturb\n std_dev = 10\n random_vector = torch.randn(len(need_to_be_perturbed))*std_dev + minimal_perturb_vector\n perturb_vector = need_to_be_perturbed*random_vector\n\n uv_b_non_matches_0_flat = uv_b_non_matches[0].view(-1,1).type(dtype_float).squeeze(1)\n uv_b_non_matches_1_flat = uv_b_non_matches[1].view(-1,1).type(dtype_float).squeeze(1)\n\n uv_b_non_matches_0_flat = uv_b_non_matches_0_flat + perturb_vector\n uv_b_non_matches_1_flat = uv_b_non_matches_1_flat + perturb_vector\n\n # now just need to wrap around any that went out of bounds\n\n # handle wrapping in width\n lower_bound = 0.0\n upper_bound = image_width*1.0 - 1\n lower_bound_vec = torch.ones_like(uv_b_non_matches_0_flat) * lower_bound\n upper_bound_vec = torch.ones_like(uv_b_non_matches_0_flat) * upper_bound\n\n uv_b_non_matches_0_flat = where(uv_b_non_matches_0_flat > upper_bound_vec, \n uv_b_non_matches_0_flat - upper_bound_vec, \n uv_b_non_matches_0_flat)\n\n uv_b_non_matches_0_flat = where(uv_b_non_matches_0_flat < lower_bound_vec, \n uv_b_non_matches_0_flat + upper_bound_vec, \n uv_b_non_matches_0_flat)\n\n # handle wrapping in height\n lower_bound = 0.0\n upper_bound = image_height*1.0 - 1\n lower_bound_vec = torch.ones_like(uv_b_non_matches_1_flat) * lower_bound\n upper_bound_vec = torch.ones_like(uv_b_non_matches_1_flat) * upper_bound\n\n uv_b_non_matches_1_flat = where(uv_b_non_matches_1_flat > upper_bound_vec, \n uv_b_non_matches_1_flat - upper_bound_vec, \n uv_b_non_matches_1_flat)\n\n uv_b_non_matches_1_flat = where(uv_b_non_matches_1_flat < lower_bound_vec, \n uv_b_non_matches_1_flat + upper_bound_vec, \n uv_b_non_matches_1_flat)\n\n return (uv_b_non_matches_0_flat.view(num_matches, num_non_matches_per_match),\n uv_b_non_matches_1_flat.view(num_matches, num_non_matches_per_match))","def find_inplane_to_match(phiA,thetaA,phiB,thetaB,psiA=0,psiB=0):\n\t#from math import pi, sqrt, cos, acos, sin\n\n\tRA = Transform({'type': 'spider', 'phi': phiA, 'theta': thetaA, 'psi': psiA})\n\tRB = Transform({'type': 'spider', 'phi': phiB, 'theta': thetaB, 'psi': psiB})\n\tRBT = RB.transpose()\n\tRABT = RA * RBT\n\n\tRABTeuler = RABT.get_rotation('spider')\n\tRABTphi = RABTeuler['phi']\n\tRABTtheta = RABTeuler['theta']\n\tRABTpsi = RABTeuler['psi']\n\n\t#deg_to_rad = pi/180.0\n\t#thetaAR = thetaA*deg_to_rad\n\t#thetaBR = thetaB*deg_to_rad\n\t#phiAR = phiA*deg_to_rad\n\t#phiBR = phiB *deg_to_rad\n\n\t#d12=cos(thetaAR)*cos(thetaBR) + sin(thetaAR)*sin(thetaBR)*cos(phiAR-phiBR)\n\treturn (-RABTpsi-RABTphi),RABTtheta # 180.0*acos(d12)/pi;","def recognize_pieces(edges, v, squares):\n\n pieces = []\n\n v = cv2.equalizeHist(v)\n for p1, p2 in squares:\n # count the number of slightly centered edges\n occupancy = sum(edges[y][x]\n for x in range(p1.x + 5, p2.x - 5)\n for y in range(p1.y + 5, p2.y - 5))\n\n if occupancy > 70*255:\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\n v[p2.y][p1.x], v[p2.y][p2.x])\n\n # average v-component of the corners\n avg = sum(map(float, corners)) / len(corners)\n\n # black pixels should be relatively black\n # when compared to the corner average\n black = sum(v[y][x] / avg < 0.2\n for x in range(p1.x, p2.x + 1)\n for y in range(p1.y, p2.y + 1))\n\n if black >= 1000 and black != 1049:\n color = \"B\"\n else:\n color = \"W\"\n\n pieces.append(color)\n else:\n pieces.append(None)\n\n return pieces","def intersect(A,B,C,D):\n i = ccw(A,C,D) != ccw(B,C,D) and ccw(A,B,C) != ccw(A,B,D)\n #if i:\n # canvas.polyline( [ A,B ], style=4 , tags = (\"debug\"))\n # canvas.polyline( [ C,D ], style=4 , tags = (\"debug\"))\n #else:\n # canvas.polyline( [ A,B ], style=1 , tags = (\"debug\")) # green\n # canvas.polyline( [ C,D ], style=1 , tags = (\"debug\"))\n return i","def find_targets(contours, frame):\n # If there aren't any contours present, return frame without drawing\n if len(contours) == 0:\n return frame\n # Copy frame, TODO why do we need to do this?\n image = frame.copy()\n screen_height, screen_width, _ = image.shape;\n # TODO: Why subtract?\n center_x = screen_width / 2 - .5\n center_y = screen_height / 2 - .5\n # List for storing found targets\n targets = []\n\n if len(contours) >= 2:\n # Sort contours in descending order by size\n contours.sort(key=lambda contour: cv2.contourArea(contour), reverse=True)\n\n valid_contours = []\n for contour in contours:\n # Calculate areas of contour\n contour_area = cv2.contourArea(contour)\n if contour_area >= MIN_CONTOUR_SIZE:\n # Get moments of contour for centroid calculations\n moments = cv2.moments(contour)\n # Find centroid of contour\n if moments[\"m00\"] != 0:\n cx = int(moments[\"m10\"] / moments[\"m00\"])\n cy = int(moments[\"m01\"] / moments[\"m00\"])\n else:\n cx, cy = 0, 0\n\n ### CALCULATE CONTOUR ROTATION BY FITTING ELLIPSE ###\n rotation = get_ellipse_rotation(image, contour)\n\n ### DRAW CONTOUR ###\n # Draw white circle at center of contour\n cv2.circle(image, (cx, cy), 6, (255, 255, 255))\n\n # Draw contour in green\n cv2.drawContours(image, [contour], 0, (0, 200, 0), 1)\n\n # Append important info to array\n valid_contours.append({\"cx\": cx, \"cy\": cy, \"rotation\": rotation})\n\n # Sort array based on coordinates (left to right) to make sure contours are adjacent\n valid_contours.sort(key=lambda contour: contour[\"cx\"])\n\n # Find targets from contours\n for i in range(len(valid_contours) - 1):\n # Check rotation of adjacent contours\n tilt_left = valid_contours[i][\"rotation\"]\n tilt_right = valid_contours[i + 1][\"rotation\"]\n\n # Contour coordinates\n cx_left = valid_contours[i][\"cx\"]\n cx_right = valid_contours[i + 1][\"cx\"]\n cy_left = valid_contours[i][\"cy\"]\n cy_right = valid_contours[i + 1][\"cy\"]\n\n # If contour angles are opposite\n # Negative tilt -> Rotated to the right\n # NOTE: if using rotated rect (min area rectangle), negative tilt means rotated to left\n # If left contour rotation is tilted to the left then skip iteration\n # If right contour rotation is tilted to the right then skip iteration\n if (len(valid_contours) == 2) or (np.sign(tilt_left) != np.sign(tilt_right) and\n not (tilt_left > 0 and cx_left < cx_right or tilt_right > 0 and cx_right < cx_left)):\n\n target_cx = (cx_left + cx_right) / 2\n target_cy = (cy_left + cy_right) / 2\n\n target_yaw = calculate_yaw(target_cx, center_x)\n target_pitch = calculate_pitch(target_cy, center_y)\n\n targets.append({\"cx\": target_cx,\n \"cy\": target_cy,\n \"yaw\": target_yaw,\n \"pitch\": target_pitch})\n\n # Check if there are targets seen\n if len(targets) > 0:\n # Get target with smallest yaw\n nearest_target = min(targets, key=lambda target: math.fabs(target[\"yaw\"]))\n # Write yaw of target in corner of image\n cv2.putText(image, \"Yaw: %.3f\" % nearest_target[\"yaw\"], (1, 12), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255))\n # Draw line at center of target\n cv2.line(image, (int(nearest_target[\"cx\"]), screen_height), (int(nearest_target[\"cx\"]), 0), (255, 0, 0), 1)\n # Draw line at center of screen\n cv2.line(image, (round(center_x), screen_height), (round(center_x), 0), (255, 255, 255), 1)\n\n # Send our final data to NetworkTables\n table.putBoolean(\"target_present\", True)\n table.putNumber(\"targets_seen\", len(targets))\n table.putNumber(\"target_yaw\", nearest_target[\"yaw\"])\n table.putNumber(\"target_pitch\", nearest_target[\"pitch\"])\n else:\n table.putBoolean(\"target_present\", False)\n table.putNumber(\"targets_seen\", 0)\n table.putNumber(\"target_yaw\", 0)\n table.putNumber(\"target_pitch\", 0)\n table.putNumber(\"target_distance\", 0)\n\n return image","def draw_matches(img1, kp1, img2, kp2, matches, inliers, ignore_indexes, filter_by_dist=True, color=None):\n # We're drawing them side by side. Get dimensions accordingly.\n # Handle both color and grayscale images.\n\n\n\n img1 = cv2.cvtColor(img1, cv2.COLOR_GRAY2RGB)\n img2 = cv2.cvtColor(img2, cv2.COLOR_GRAY2RGB)\n if len(img1.shape) == 3:\n new_shape = (img1.shape[0] + img2.shape[0], max(img1.shape[1], img2.shape[1]), img1.shape[2])\n elif len(img1.shape) == 2:\n new_shape = (img1.shape[0] + img2.shape[0], max(img1.shape[1], img2.shape[1]))\n new_img = np.zeros(new_shape, type(img1.flat[0])) \n # Place images onto the new image.\n new_img[0:img1.shape[0],0:img1.shape[1]] = img1\n new_img[img1.shape[0]:img1.shape[0]+img2.shape[0],0:img1.shape[1]] = img2\n \n # Draw lines between matches. Make sure to offset kp coords in second image appropriately.\n r = 1\n thickness = 1\n if color:\n c = color\n\n # print(new_img.shape)\n distances = []\n for m in matches:\n distances.append(m.distance)\n \n dist_threshold = min(distances) * 2\n # print(dist_threshold)\n \n for i, m in enumerate(matches):\n if inliers:\n if not i in inliers:\n continue\n if ignore_indexes:\n if i in ignore_indexes:\n continue\n if filter_by_dist:\n if m.distance > 50:\n continue\n \n # Generate random color for RGB/BGR and grayscale images as needed.\n if not color: \n c = tuple(np.random.randint(0,256,3)) if len(img1.shape) == 3 else np.random.randint(0,256)\n c = ( int (c [ 0 ]), int (c [ 1 ]), int (c [ 2 ])) \n \n # So the keypoint locs are stored as a tuple of floats. cv2.line(), like most other things,\n # wants locs as a tuple of ints.\n\n try:\n end1 = tuple(np.round(kp1[m.queryIdx].pt).astype(int))\n end2 = tuple(np.round(kp2[m.trainIdx].pt).astype(int) + np.array([ 0, img1.shape[0]]))\n cv2.line(new_img, end1, end2, c, thickness)\n cv2.circle(new_img, end1, r, c, thickness)\n cv2.circle(new_img, end2, r, c, thickness)\n except:\n continue\n \n\n return new_img","def intersects_segment(A, B, X):\n \n AX = np.array([X.x - A.x, X.y - A.y])\n XB = np.array([B.x - X.x, B.y - X.y])\n equal_signs = np.array_equal(np.sign(AX), np.sign(XB))\n\n return equal_signs","def test_compute_cbca_subpixel(self):\n stereo_matcher = stereo.AbstractStereo(**{'stereo_method': 'sad', 'window_size': 1, 'subpix': 2})\n sad = stereo_matcher.compute_cost_volume(img_ref=self.ref, img_sec=self.sec, disp_min=-1, disp_max=1,\n **{'valid_pixels': 0, 'no_data': 1})\n\n # Computes the cost aggregation with the cross-based cost aggregation method,\n # with cbca_intensity=5 and cbca_distance=3\n cbca_obj = aggregation.AbstractAggregation(**{'aggregation_method': 'cbca',\n 'cbca_intensity': 5., 'cbca_distance': 3})\n\n cv_aggreg = cbca_obj.cost_volume_aggregation(self.ref, self.sec, sad)\n\n # Aggregate cost volume ground truth with the cross-based cost aggregation method for the stereo image\n aggregated_ground_truth = np.array([[[np.nan, np.nan, 36./6, 25./7, 0.],\n [36./6, 46./7, 66./9, 38.5/12, 0.],\n [55./9, 64.5/12, 74./12, 32.5/10, 0.],\n [55./9, 59.5/10, 52./9, 31.5/9, 0.],\n [41./6, 43.5/9, 52./9, np.nan, np.nan]],\n\n [[np.nan, np.nan, 36./6, 25./7, 0.],\n [36./6, 46./7, 66./9, 38.5/12, 0.],\n [55./9, 64.5/12, 74./12, 32.5/10, 0.],\n [55./9, 59.5/10, 52./9, 31.5/9, 0.],\n [41./6, 43.5/9, 52./9, np.nan, np.nan]],\n\n [[np.nan, np.nan, 36./6, 25./7, 0.],\n [36./6, 46./7, 66./9, 38.5/12, 0.],\n [55./9, 64.5/12, 74./12, 32.5/10, 0.],\n [55./9, 59.5/10, 52./9, 31.5/9, 0.],\n [41./6, 43.5/9, 52./9, np.nan, np.nan]]])\n\n # Check if the calculated standard deviation is equal ( to desired tolerance 1e-07 ) to the ground truth\n np.testing.assert_allclose(cv_aggreg['cost_volume'].data, aggregated_ground_truth, rtol=1e-07)","def find_homography(kp1, kp2, goodmatches):\n src_pts = np.float32([kp1[m.trainIdx].pt for m in goodmatches]).reshape(-1, 1, 2)\n dst_pts = np.float32([kp2[m.trainIdx].pt for m in goodmatches]).reshape(-1, 1, 2)\n M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)\n matchesMask = mask.ravel().tolist()\n return M, matchesMask","def get_matches(jig_sol, blocks_roi):\n\n match_data = {}\n height, width,= jig_sol.shape\n font = cv2.FONT_HERSHEY_SIMPLEX\n\n #identify the puzzle peice number based on the peice block position in solution image\n identity = {\n (1, 1): 1,\n (2, 1): 2,\n (3, 1): 3,\n (1, 2): 4,\n (2, 2): 5,\n (3, 2): 6,\n (1, 3): 7,\n (2, 3): 8,\n (3, 3): 9,\n }\n\n #iterate through the blocks roi\n for i in blocks_roi.keys():\n blk = blocks_roi[i].copy()\n blk = cv2.cvtColor(blk,cv2.COLOR_BGR2GRAY)\n max_list = []\n\n #for eack blk rotate is by 90 degrees and try template matching\n for k in range(0,360,90):\n #cv2.resize(blk,(int(width/3),int(height/3)), interpolation= cv2.INTER_CUBIC)\n blk_copy = imutils.rotate_bound(blk, -k)\n\n #get the resulting heat map of template matching\n result = cv2.matchTemplate(jig_sol,blk_copy,cv2.TM_CCOEFF_NORMED)\n\n #get the max value and its location in the heat map\n _, max_val, _, max_loc = cv2.minMaxLoc(result)\n\n #append a tuple consisting of max location, value and peice rotation to max_list\n max_list.append((max_loc, max_val, k))#((k+1)*90)%360))\n\n #find the location with maximum value of template matching regardless of peice rotation\n top_left = max(max_list, key=lambda x: x[1])[0]\n\n #get the peice rotation of that template matching\n rot = max(max_list, key=lambda x: x[1])[2]\n\n #calculate the bottom right cordinates of the block\n bottom_right = (top_left[0] + int(width/3), top_left[1] + int(height/3))\n\n #find the center of the block\n centx = 0\n centy = 0\n for (l,m) in [top_left, bottom_right]:\n centx += l\n centy += m\n centx = int(centx/2)\n centy = int(centy/2)\n\n #get the puzzle peice block position in solution image\n piece = (math.ceil(3*centx/width), math.ceil(3*centy/height))\n\n if piece not in identity.keys():\n continue\n\n match_data.update({i: (identity[piece], rot)})\n\n return match_data","def sub(input_a, input_b):\n sub_comp = input_b.duplicate()\n\n ImageBufAlgo.sub(sub_comp, input_a, input_b)\n\n if sub_comp.has_error:\n print \"Error merging subtracting:\", sub_comp.geterror()\n\n return sub_comp","def matchsize(A, B):\n wA, hA = cv.GetSize(A)\n wB, hB = cv.GetSize(B)\n if wA == wB and hA == hB:\n return A\n SetImageROI = cv.SetImageROI\n out = cv.CreateImage((wB, hB), A.depth, A.channels)\n wOut, hOut = cv.GetSize(out)\n if wA < wOut and hA < hOut:\n SetImageROI(out, (0, 0, wA, hA))\n elif wA >= wOut and hA < hOut:\n SetImageROI(out, (0, 0, wOut, hA))\n SetImageROI(A, (0, 0, wOut, hA))\n elif wA < wOut and hA >= hOut:\n SetImageROI(out, (0, 0, wA, hOut))\n SetImageROI(A, (0, 0, wA, hOut))\n else: # wA >= wOut and hA >= hOut:\n SetImageROI(A, (0, 0, wOut, hOut))\n cv.Copy(A, out)\n cv.ResetImageROI(out)\n cv.ResetImageROI(A)\n return out","def create_masks(img_path, frame_num):\n #import the images\n key_frame = cv2.imread(img_path + \"_\" + str(frame_num) + \".png\")\n beam_mask = filter_beam(key_frame)\n key_frame = cv2.cvtColor(cv2.bitwise_and(beam_mask,key_frame), cv2.COLOR_BGR2GRAY)\n cv2.imwrite(img_path + \"_\" + str(frame_num) + \"_beamed.png\",key_frame)\n key_frame = change_contrast(key_frame, 4.0)\n\n #key_mask = cv2.imread(img_path + \"_mask_\" + str(frame_num) + \".png\",0)\n #masked_key = cv2.bitwise_and(key_frame,key_mask)\n new_frame = cv2.imread(img_path + \"_\" + str(frame_num + 1) + \".png\")\n new_frame = cv2.cvtColor(cv2.bitwise_and(beam_mask,new_frame), cv2.COLOR_BGR2GRAY)\n new_frame = change_contrast(new_frame, 4.0)\n\n #trying with a couple methods here:\n #SIFT method\n sift = cv2.SIFT_create()\n keypoints_1, descriptors_1 = sift.detectAndCompute(key_frame,None)\n keypoints_2, descriptors_2 = sift.detectAndCompute(new_frame,None)\n bf = cv2.BFMatcher(cv2.NORM_L1, crossCheck=True)\n\n matches = bf.match(descriptors_1,descriptors_2)\n matches = sorted(matches, key = lambda x:x.distance)\n for x in keypoints_1:\n print(x.pt)\n\n img3 = cv2.drawMatches(key_frame, keypoints_1, new_frame, keypoints_2, matches, new_frame, flags=2)\n cv2.imshow(\"matched\",img3)\n cv2.waitKey(0)\n\n #use the SIFT paradigm but do it semi-manually\n\n #active contouring method","def test_compare_confs(self):\n ch4_1 = {'symbols': ('C', 'H', 'H', 'H', 'H'),\n 'isotopes': (12, 1, 1, 1, 1),\n 'coords': ((0.0, 0.0, 0.0),\n (0.6300326, 0.6300326, 0.6300326),\n (-0.6300326, -0.6300326, 0.6300326),\n (-0.6300326, 0.6300326, -0.6300326),\n (0.6300326, -0.6300326, -0.6300326))}\n self.assertTrue(converter.compare_confs(ch4_1, ch4_1))\n self.assertEqual(converter.compare_confs(ch4_1, ch4_1, rmsd_score=True), 0.0)\n\n ch4_2 = {'symbols': ('C', 'H', 'H', 'H', 'H'),\n 'isotopes': (12, 1, 1, 1, 1),\n 'coords': ((0.0, 0.0, 0.0),\n (0.630032999999999999, 0.6300326, 0.6300326),\n (-0.6300326, -0.6300326, 0.6300326),\n (-0.6300326, 0.6300326, -0.6300326),\n (0.6300326, -0.6300326, -0.6300326))}\n self.assertTrue(converter.compare_confs(ch4_1, ch4_2))\n self.assertAlmostEqual(converter.compare_confs(ch4_1, ch4_2, rmsd_score=True), 0.0, places=4)\n\n ch4_3 = {'symbols': ('C', 'H', 'H', 'H', 'H'),\n 'isotopes': (12, 1, 1, 1, 1),\n 'coords': ((0.0, 0.0, 0.0),\n (0.81, 0.6300326, 0.6300326),\n (-0.6300326, -0.6300326, 0.6300326),\n (-0.6300326, 0.6300326, -0.6300326),\n (0.6300326, -0.6300326, -0.6300326))}\n self.assertFalse(converter.compare_confs(ch4_1, ch4_3))\n self.assertAlmostEqual(converter.compare_confs(ch4_1, ch4_3, rmsd_score=True), 0.0973755, 5)\n\n occco_1 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\n 'coords': ((-1.645138856907744, 0.4855258453193825, -1.269098295435587),\n (-1.826155038047953, 0.3950495294463964, 0.14042133077839267),\n (-1.809422000751755, 1.7890058616007063, 0.7598491740499427),\n (-0.5144047765537177, 2.5412406931938802, 0.46679697338621373),\n (-0.4166415293412751, 2.87702090326361, -0.9112962716273996),\n (-1.7523716337780308, -0.4153106947877299, -1.6252584016046343),\n (-2.785951955397608, -0.09251469392615361, 0.33828359656775064),\n (-1.0240452528998532, -0.22437445960667116, 0.5540970106165476),\n (-2.6481280678220354, 2.3642983699082096, 0.34958017984053996),\n (-1.948589699885299, 1.7026595551213293, 1.842711580226941),\n (0.3611954633790452, 1.9455154222553817, 0.7436960027091665),\n (-0.4846097814890448, 3.4746190180148613, 1.0370826136306412),\n (-0.7517118479102434, 2.0995465744609016, -1.4084474547843668))}\n self.assertTrue(converter.compare_confs(occco_1, occco_1))\n self.assertEqual(converter.compare_confs(occco_1, occco_1, rmsd_score=True), 0.0)\n\n occco_2 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\n 'coords': ((-1.7947360038254172, -0.2800502342395655, -0.94718691702442),\n (-1.3484923712374388, 0.3115024061252556, 0.26578718691263836),\n (0.048477626636679344, -0.18145884392561823, 0.6324014558703148),\n (0.06768533157823732, -1.6675011458530478, 0.9732242593946415),\n (-0.3530408338556874, -2.4414941005488964, -0.14539995931042984),\n (-1.6993365552401258, -1.24904809118412, -0.8336640895923935),\n (-1.3364382254722125, 1.3960688766201377, 0.12095890535651209),\n (-2.0720954664081472, 0.08255875951942339, 1.0547463625584224),\n (0.7166058894071794, -0.006871191098481536, -0.21939247767770087),\n (0.42416153066953804, 0.38997256785153595, 1.4878132135000073),\n (-0.6073710844027356, -1.8828156181698352, 1.8073934203380306),\n (1.0743805139106757, -1.9882575918786236, 1.2595102280098387),\n (0.35195568839394714, -2.3791987519096245, -0.81652943836054))}\n self.assertFalse(converter.compare_confs(occco_1, occco_2))\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_2, rmsd_score=True), 1.00940798, 5)\n\n occco_3 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\n 'coords': ((-2.1449415573976087, 0.22095421320805855, -1.1761667487081628),\n (-1.8458576972054956, 0.34850267283416353, 0.21018774322610537),\n (-1.7946333596155588, 1.8224048429109774, 0.6001541290065803),\n (-0.7643941488427433, 2.603963636650936, -0.21014179435545444),\n (-1.160550573561837, 2.7172772321690157, -1.5709018700345496),\n (-2.2541573481252226, -0.7309807530987936, -1.3543442072197793),\n (-2.624019853257233, -0.1650323593077789, 0.7836186270202112),\n (-0.885183881101036, -0.13905038811734782, 0.4040751763466029),\n (-2.7832838991835382, 2.2645645737400506, 0.427600829327477),\n (-1.562954529947271, 1.9038127448704014, 1.6674459390753227),\n (0.21794991835079414, 2.1225495495404854, -0.17169963700580776),\n (-0.6621011473071822, 3.6174144955483376, 0.18956005497753062),\n (-1.544021016988015, 1.848253867499642, -1.8191893347265315))}\n self.assertTrue(converter.compare_confs(occco_1, occco_3))\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_3, rmsd_score=True), 0.0, places=4)\n\n occco_4 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\n 'coords': ((-2.149273800177333, 0.3878561319363274, -1.067994536622897),\n (-1.8905197406541119, 0.16731522843849514, 0.3147948930907352),\n (-2.2871289950009728, 1.398560959638718, 1.1233863494505283),\n (-1.5514369216953363, 2.6559008371480006, 0.6687883285931627),\n (-1.97578532983754, 3.0584350426221696, -0.6271056229665328),\n (-1.9649535743321451, -0.45216201833697967, -1.5265252922322194),\n (-2.469954748031858, -0.7010050003658949, 0.6439649209501082),\n (-0.8252433635746496, -0.052453567250684806, 0.43760424203717113),\n (-3.36502756891988, 1.5624906595612045, 1.0051865026931144),\n (-2.0814509723064316, 1.2139856682154606, 2.18312358675434),\n (-0.4688204416342118, 2.495542838358611, 0.6472342384223745),\n (-1.759053255113454, 3.4819317812208626, 1.3557210162758644),\n (-2.0785703072969466, 2.2346795710060765, -1.151280970188824))}\n self.assertTrue(converter.compare_confs(occco_1, occco_4))\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_4, rmsd_score=True), 0.0, places=4)\n\n occco_5 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\n 'coords': (\n (-2.4583263702786398, 0.0718285271168676, -1.073208642860504),\n (-1.937015981064579, 0.0890930305098165, 0.25179580507902494),\n (-2.348398726927575, 1.376978495961958, 0.9583384372437844),\n (-1.8770165015484177, 2.6245423907540975, 0.21659228399276115),\n (-2.569162634647042, 2.781228761671768, -1.015409941988472),\n (-2.2457141392131477, -0.8022675472463131, -1.4481857725877),\n (-2.3295554159352525, -0.7779156570908263, 0.792431073403323),\n (-0.8469088168553344, 0.006439213644634347, 0.19675913068823528),\n (-3.4425715658912557, 1.4040720104173179, 1.0273387203822888),\n (-1.939605978646692, 1.375711847707625, 1.9743606178959265),\n (-0.8029097001610058, 2.5806396078360736, 0.010183430117069694),\n (-2.07095189274604, 3.516416462694289, 0.8201309204066712),\n (-2.650256378769789, 1.8823222470150054, -1.4017891959903757))}\n self.assertTrue(converter.compare_confs(occco_1, occco_5))\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_5, rmsd_score=True), 0.0, places=4)","def find_optimal_components_subset(contours, edges):\n c_info = props_for_contours(contours, edges)\n c_info.sort(key=lambda x: -x['sum'])\n total = np.sum(edges) / 255\n area = edges.shape[0] * edges.shape[1]\n\n c = c_info[0]\n del c_info[0]\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\n crop = this_crop\n covered_sum = c['sum']\n\n while covered_sum < total:\n changed = False\n recall = 1.0 * covered_sum / total\n prec = 1 - 1.0 * crop_area(crop) / area\n f1 = 2 * (prec * recall / (prec + recall))\n # print '----'\n for i, c in enumerate(c_info):\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\n new_crop = union_crops(crop, this_crop)\n new_sum = covered_sum + c['sum']\n new_recall = 1.0 * new_sum / total\n new_prec = 1 - 1.0 * crop_area(new_crop) / area\n new_f1 = 2 * new_prec * new_recall / (new_prec + new_recall)\n\n # Add this crop if it improves f1 score,\n # _or_ it adds 25% of the remaining pixels for <15% crop expansion.\n # ^^^ very ad-hoc! make this smoother\n remaining_frac = c['sum'] / (total - covered_sum)\n new_area_frac = 1.0 * crop_area(new_crop) / crop_area(crop) - 1\n if new_f1 > f1 or (\n remaining_frac > 0.25 and new_area_frac < 0.15):\n print('%d %s -> %s / %s (%s), %s -> %s / %s (%s), %s -> %s' % (\n i, covered_sum, new_sum, total, remaining_frac,\n crop_area(crop), crop_area(new_crop), area, new_area_frac,\n f1, new_f1))\n crop = new_crop\n covered_sum = new_sum\n del c_info[i]\n changed = True\n break\n\n if not changed:\n break\n\n return crop","def ransac(keypoints1, keypoints2, matches, sampling_ratio=0.5, n_iters=500, threshold=20):\n N = matches.shape[0]\n n_samples = int(N * sampling_ratio)\n\n # Please note that coordinates are in the format (y, x)\n matched1 = pad(keypoints1[matches[:,0]])\n matched2 = pad(keypoints2[matches[:,1]])\n matched1_unpad = keypoints1[matches[:,0]]\n matched2_unpad = keypoints2[matches[:,1]]\n\n max_inliers = np.zeros(N)\n n_inliers = 0\n\n # RANSAC iteration start\n ### YOUR CODE HERE\n raise NotImplementedError() # Delete this line\n ### END YOUR CODE\n return H, matches[max_inliers]","def ransac(matches, kp1, kp2, s=4, threshold=3, maxIterations=2000, returnMatches=False, inlierRatio=0.05, ransacRatio=0.6):\n\n sizes_kp1 = [kp1[dt[0].queryIdx].size for dt in matches]\n sizes_kp2 = [kp1[dt[0].trainIdx].size for dt in matches]\n tup_matches_kp1 = [kp1[dt[0].queryIdx].pt for dt in matches]\n tup_matches_kp2 = [kp2[dt[0].trainIdx].pt for dt in matches]\n matches_kp1 = np.array([[h for h in kp] + [1] for kp in tup_matches_kp1])\n matches_kp2 = np.array([[h for h in kp] + [1] for kp in tup_matches_kp2])\n\n cnt_matches = len(matches)\n\n max_matches = []\n max_p1, max_p2 = [], []\n max_p1_sizes, max_p2_sizes = [], []\n max_total = 0\n\n for iter in range(maxIterations):\n # Find Homography based on random sample\n data = random.sample(matches, s)\n data_p1 = np.array([matches_kp1[dt[0].queryIdx] for dt in data])\n data_p2 = np.array([matches_kp2[dt[0].trainIdx] for dt in data])\n homography = homomat(data_p1[:, :2], data_p2[:, :2])\n\n # Find P1 projection from the homography matrix\n projected_p2 = np.dot(homography, matches_kp1.transpose())\n projected_p2 = projected_p2[0:3] / projected_p2[2] # make sure w' is 1\n projected_p2 = projected_p2.transpose()\n\n # Initialize Current Matches\n current_matches = []\n current_p1, current_p2 = [], []\n current_p1_sizes, current_p2_sizes = [], []\n current_total = 0\n\n # Check for inliers and outliers for each matches\n for i, (match) in enumerate(matches):\n # normalize the error\n error = np.linalg.norm(matches_kp2[i] - projected_p2[i])\n\n # Check for inliers\n if error < threshold:\n current_matches.append([cv.DMatch(current_total, current_total, match[0].distance)])\n current_p1.append(matches_kp1[i][0:2])\n current_p2.append(matches_kp2[i][0:2])\n current_p1_sizes.append(sizes_kp1[i])\n current_p2_sizes.append(sizes_kp2[i])\n current_total += 1\n\n # If\n if current_total > max_total and current_total >= np.round(inlierRatio*cnt_matches):\n max_matches = current_matches\n max_p1 = current_p1\n max_p2 = current_p2\n max_p1_sizes = current_p1_sizes\n max_p2_sizes = current_p2_sizes\n max_total = current_total\n\n # # we are done in case we have enough inliers\n if current_total > cnt_matches * ransacRatio:\n break\n\n\n # Re-evaluate the Homography based on the best inliers\n max_homography = homomat(np.array(max_p1), np.array(max_p2))\n\n if returnMatches:\n max_kp1 = [cv.KeyPoint(d[0], d[1], max_p1_sizes[i]) for i, d in enumerate(max_p1)]\n max_kp2 = [cv.KeyPoint(d[0], d[1], max_p2_sizes[i]) for i, d in enumerate(max_p2)]\n return max_homography, max_matches, max_kp1, max_kp2\n\n return max_homography","def find_occluded(tlbrs, occlusion_thresh):\n occluded_mask = np.zeros(tlbrs.shape[0], dtype=np.bool_)\n for i in nb.prange(tlbrs.shape[0]):\n area_self = area(tlbrs[i, :])\n for j in range(tlbrs.shape[0]):\n if i != j:\n iw = min(tlbrs[i, 2], tlbrs[j, 2]) - max(tlbrs[i, 0], tlbrs[j, 0]) + 1\n ih = min(tlbrs[i, 3], tlbrs[j, 3]) - max(tlbrs[i, 1], tlbrs[j, 1]) + 1\n if iw > 0 and ih > 0:\n ios = iw * ih / area_self\n if ios >= occlusion_thresh:\n occluded_mask[i] = True\n break\n return occluded_mask","def _poly_exactly_coincident(a,b):\n n_holes = len(a.holes)\n n_parts = len(a.parts)\n if n_holes != len(b.holes):\n return False\n if n_parts != len(b.parts):\n return False\n b_in_a = [None]*n_holes\n a_in_b = [None]*n_holes\n for i, a_hole in a.holes:\n for j, b_hole in b.holes:\n i_j = coincident(a_hole, b_hole)\n if i_j:\n b_in_a[j] = True\n a_in_b[i] = True\n break\n if not a_in_b[i]:\n return False\n if any(in_b):\n return False\n for b_hole in b.holes:\n in_a = [not coincident(b_hole, a_hole) for a_hole in a.holes]\n if any(in_a):\n return False\n return True","def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\n min_ratio, max_ratio):\n output = []\n for contour in input_contours:\n x,y,w,h = cv2.boundingRect(contour)\n if (w < min_width or w > max_width):\n continue\n if (h < min_height or h > max_height):\n continue\n area = cv2.contourArea(contour)\n if (area < min_area):\n continue\n if (cv2.arcLength(contour, True) < min_perimeter):\n continue\n hull = cv2.convexHull(contour)\n solid = 100 * area / max(cv2.contourArea(hull),1)\n if (solid < solidity[0] or solid > solidity[1]):\n continue\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\n continue\n ratio = (float)(w) / h\n if (ratio < min_ratio or ratio > max_ratio):\n continue\n output.append(contour)\n return output","def venn(a,b):\n a = set(a)\n b = set(b)\n return map(list, (a.difference(b), a.intersection(b), b.difference(a)))","def match_marking_points(point_a, point_b):\n \n squared_distance_thresh = 0.000277778 # 10 pixel in 600*600 image\n direction_angle_thresh = 0.5235987755982988 # 30 degree in rad \n \n dist_square = calc_point_squre_dist(point_a, point_b)\n #if min(point_a.shape[1], point_b.shape[1]) <= 2:\n if True:\n return dist_square < squared_distance_thresh\n\n angle = calc_point_direction_angle(point_a, point_b)\n if point_a[3] > 0.5 and point_b[3] < 0.5:\n return False\n if point_a[3] < 0.5 and point_b[3] > 0.5:\n return False\n return (dist_square < squared_distance_thresh\n and angle < direction_angle_thresh)","def match_twosided(desc1,desc2,threshold=0.5):\n matches_12 = match(desc1,desc2,threshold)\n matches_21 = match(desc2,desc1,threshold)\n ndx_12 = np.where(matches_12 >= 0)[0]\n # remove matches that are not symmetric\n for n in ndx_12:\n if matches_21[matches_12[n]] != n:\n matches_12[n] = -1\n return matches_12","def __find_contours(input, external_only):\n if(external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n im2, contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\n return contours","def find_matching_segments(self):\n hyp_matched_segs = [TIntervalGroup() for i in range(len(self.hyp))]\n for gid_ref, match_ref in enumerate(self.ref):\n bg_ref = match_ref.bbox_group\n max_gid, max_area = -1, 0\n for gid_hyp, bg_hyp in enumerate(self.hyp.get_bbox_groups()):\n rx, ry = bg_ref.page_range(), bg_hyp.page_range()\n if ry[0] > rx[1]:\n break\n area = (bg_ref & bg_hyp)\n if area > max_area:\n max_gid, max_area = gid_hyp, area\n if max_gid != -1:\n hyp_matched_segs[max_gid].extend(match_ref.tinterval_group.copy())\n print('%d -> %d' % (gid_ref, max_gid))\n for seg in hyp_matched_segs:\n seg.reduce()\n return hyp_matched_segs","def match(self, grp, healpixIDs, pixRA, pixDec):\n\n # print('hello', grp.columns)\n pixRA_rad = np.deg2rad(pixRA)\n pixDec_rad = np.deg2rad(pixDec)\n\n # convert data position in rad\n pRA = np.median(grp[self.RACol])\n pDec = np.median(grp[self.DecCol])\n pRA_rad = np.deg2rad(pRA)\n pDec_rad = np.deg2rad(pDec)\n\n # gnomonic projection of pixels on the focal plane\n x, y = proj_gnomonic_plane(pRA_rad, pDec_rad, pixRA_rad, pixDec_rad)\n # x, y = proj_gnomonic_plane(np.deg2rad(self.LSST_RA-pRA),np.deg2rad(self.LSST_Dec-pDec), pixRA_rad, pixDec_rad)\n\n # get LSST FP with the good scale\n # pnew = LSSTPointing(0., 0., area=np.pi*self.fpscale**2)\n fpnew = LSSTPointing_circular(0., 0., maxbound=self.fpscale)\n # fpnew = LSSTPointing(np.deg2rad(self.LSST_RA-pRA),np.deg2rad(self.LSST_Dec-pDec),area=np.pi*self.fpscale**2)\n # maxbound=self.fpscale)\n\n \"\"\"\n import matplotlib.pyplot as plt\n fig, ax = plt.subplots()\n ax.plot(x, y, 'ko')\n pf = PolygonPatch(fpnew, facecolor=(0, 0, 0, 0), edgecolor='red')\n ax.add_patch(pf)\n plt.show()\n \"\"\"\n\n # print(shapely.vectorized.contains(\n # fpnew, x, y), self.fpscale, fpnew.area)\n\n idf = shapely.vectorized.contains(fpnew, x, y)\n\n pixID_matched = list(healpixIDs[idf])\n pixRA_matched = list(pixRA[idf])\n pixDec_matched = list(pixDec[idf])\n\n # names = [grp.name]*len(pixID_matched)\n df_pix = pd.DataFrame({'healpixID': pixID_matched,\n 'pixRA': pixRA_matched,\n 'pixDec': pixDec_matched, })\n # 'groupName': names})\n\n return df_pix\n \"\"\"\n n_index = len(grp.index.values)\n\n arr_index = grp.index.values\n\n n_pix = len(df_pix)\n if n_pix > 1:\n arr_index = arr_index.repeat(n_pix)\n if n_index > 1:\n df_pix = df_pix.append([df_pix]*(n_index-1), ignore_index=True)\n\n df_pix.loc[:, 'index'] = arr_index\n \n return df_pix\n \"\"\"","def draw_match(img1, p1, img2, p2, mask=None, H=None):\n h1, w1 = img1.shape[:2]\n h2, w2 = img2.shape[:2]\n vis = np.zeros((max(h1, h2), w1 + w2), np.uint8)\n vis[:h1, :w1] = img1\n vis[:h2, w1:w1 + w2] = img2\n vis = cv2.cvtColor(vis, cv2.COLOR_GRAY2BGR)\n\n if H is not None:\n corners = np.float32([[0, 0], [w1, 0], [w1, h1], [0, h1]])\n corners = np.int32(\n cv2.perspectiveTransform(\n corners.reshape(1, -1, 2), H).reshape(-1, 2) \\\n + (w1, 0))\n cv2.polylines(vis, [corners], True, (255, 255, 255))\n\n if mask is None:\n mask = np.ones(len(p1), np.bool_)\n\n green = (63, 255, 0)\n red = (0, 0, 255)\n for (x1, y1), (x2, y2), inlier in zip(np.int32(p1), np.int32(p2), mask):\n col = [red, green][inlier]\n if inlier:\n cv2.line(vis, (x1, y1), (x2 + w1, y2), col)\n cv2.circle(vis, (x1, y1), 4, col, 2)\n cv2.circle(vis, (x2 + w1, y2), 4, col, 2)\n else:\n r = 2\n thickness = 3\n cv2.line(vis, (x1 - r, y1 - r), (x1 + r, y1 + r), col, thickness)\n cv2.line(vis, (x1 - r, y1 + r), (x1 + r, y1 - r), col, thickness)\n cv2.line(vis, (x2 + w1 - r, y2 - r), (x2 + w1 + r, y2 + r), col, thickness)\n cv2.line(vis, (x2 + w1 - r, y2 + r), (x2 + w1 + r, y2 - r), col, thickness)\n return vis","def intersect2d(A, B):\n # print 'A = ', A\n # print 'B = ', B\n a1_rows = A.view([('', A.dtype)] * A.shape[1])\n a2_rows = B.view([('', B.dtype)] * B.shape[1])\n # Now trim those bonds from BL\n C = np.intersect1d(a1_rows, a2_rows).view(A.dtype).reshape(-1, A.shape[1])\n return C","def bins_match (a, b):\n return np.sum ((a.bins - b.bins)**2) == 0","def detect_contours(self):\r\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\r\n return [DbugContour(cv_contour=contour) for contour in contours]","def clip(self, clip, s_entry, c_entry):\n\n # detect clip mode\n unionmode = not s_entry and not c_entry\n intersectionmode = s_entry and c_entry\n differencemode = not s_entry and c_entry\n\n # prep by removing repeat of startpoint at end\n first = self.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n first = clip.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n\n # TODO: maybe also remove repeat points anywhere?\n # ...\n \n # phase one - find intersections\n # ------------------------------\n anyintersection = False\n s_intsecs = []\n c_intsecs = []\n for s in self.iter(): # for each vertex Si of subject polygon do\n for c in clip.iter(): # for each vertex Cj of clip polygon do\n try:\n #print \"find isect %s - %s and %s - %s\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\n c, clip.next(c.__next__))\n \n iS = Vertex(i, alphaS, intersect=True, entry=False)\n iC = Vertex(i, alphaC, intersect=True, entry=False)\n\n iS.neighbour = iC\n iC.neighbour = iS\n \n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\n \n anyintersection = True\n \n except TypeError:\n pass # this simply means intersect() returned None\n\n # insert intersections into originals\n for iS,a,s,s_next in reversed(s_intsecs):\n if a == 0:\n self.replace(s, iS)\n elif a == 1:\n self.replace(s_next, iS)\n else:\n self.insert(iS, s, s_next)\n for iC,a,c,c_next in reversed(c_intsecs):\n if a == 0:\n self.replace(c, iC)\n elif a == 1:\n self.replace(c_next, iC)\n else:\n clip.insert(iC, c, c_next)\n\n #print \"testing if insert was done correctly\"\n for s in self.iter():\n #print s\n pass\n #print \"and\"\n for c in clip.iter():\n #print c\n pass\n \n\n # phase one and a half - no intersections between subject and clip, so correctly return results\n # --------------------\n def specialcase_insidetest():\n resultpolys = []\n if unionmode: # union\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so just return subject shell\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so just return clip shell\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so return both\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif intersectionmode: # intersection\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so no intersection to return\n pass\n elif differencemode: # difference\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n hole = Polygon()\n for c in clip.iter():\n hole.add(Vertex(c))\n polytuple = (clipped, [hole])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so there is no difference\n pass\n else:\n #clip polygon is entirely outside subject, so difference is simply the subject\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n # no need to continue so just return result\n return resultpolys\n \n if not anyintersection: \n return specialcase_insidetest()\n\n\n\n\n\n\n\n # phase two - identify entry/exit points\n # --------------------------------------\n\n # From K&K\n \n def mark_flags(poly, c, c_entry):\n \"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\"\n #print \"intersection\"\n #print \"\\t\",c\n # intersection is degenerate, is the start/endpoint of a line\n # so maybe delete intersection flag based on prev/next locations\n prevloc = testLocation(c.prev, poly)\n nextloc = testLocation(c.__next__, poly)\n if prevloc == \"on\" or nextloc == \"on\":\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\n prevloc = testLocation(prevmid, poly)\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\n nextloc = testLocation(nextmid, poly)\n if prevloc == \"in\" or nextloc == \"in\":\n poly.anyinside = True\n #print \"\\t %s -> degenintsec -> %s\" %(prevloc,nextloc)\n if prevloc == \"out\":\n if nextloc == \"out\":\n #just touching\n c.entry = \"en/ex\" if c_entry else \"ex/en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif nextloc == \"on\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif prevloc == \"in\":\n #union and difference should never go inside the other polygon\n #so this should only happen for intersectmode...\n if nextloc == \"in\":\n #just touching\n c.entry = \"ex/en\" if c_entry else \"en/ex\"\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"on\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif prevloc == \"on\":\n if nextloc == \"on\":\n c.entry = None\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n\n self.anyinside = False\n\n # set clip\n prevsingle = None\n for c in clip.iter():\n if c.intersect:\n mark_flags(self, c, c_entry)\n # set couple\n if c.entry in (\"ex\",\"en\"):\n if prevsingle and c.entry == prevsingle.entry:\n c.couple = prevsingle\n prevsingle.couple = c\n prevsingle = c\n # set crosschange\n # some modifications based on implementation in qt clipper source code\n #if c.entry == \"en/ex\" == c.neighbour.entry or c.entry == \"ex/en\" == c.neighbour.entry:\n if False: #c.entry == \"en/ex\" or c.entry == \"ex/en\":\n print(\"Maybe crosschange...\")\n # tri1\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\n dir1 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n # tri2\n #a,b,c = c.neighbour.prev, c.prev, c.next\n a,b,c = c.__next__, c.prev, c.neighbour.prev\n dir2 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n print(dir1,dir2)\n #if dir1 < 0 != dir2 < 0: # different orientation\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\n print(\"CROSSCHANGE!!!\")\n c.cross_change = True\n c.neighbour.cross_change = True # not sure if should set neighbour too\n\n # maybe early abort\n if not self.anyinside and intersectionmode:\n return []\n\n # what about perfect overlap???\n # ...\n\n if False: #DEBUG:\n print(\"view clip entries\")\n for c in clip.iter():\n print(c, c.entry)\n\n # find first isect where both neighbours have valid flag\n for c in clip.iter():\n if c.entry:\n s = c.neighbour\n mark_flags(clip, s, s_entry)\n if s.entry:\n first_c = c\n first_s = s\n # print 777,s.entry\n break\n\n else:\n return specialcase_insidetest()\n #raise Exception(\"weird special case, no neighbours that both have flag left\")\n \n # autoset subj, if neighbour of first is different, then set all as opposite\n # TODO: how deal with s_entry in case of different modes...?\n print(\"view first\")\n print(first_c, first_c.entry)\n print(first_s, first_s.entry)\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\n for c in clip.iter():\n if c.entry:\n if c.entry == \"en\": c.neighbour.entry = \"ex\"\n elif c.entry == \"ex\": c.neighbour.entry = \"en\"\n elif c.entry == \"en/ex\": c.neighbour.entry = \"ex/en\"\n elif c.entry == \"ex/en\": c.neighbour.entry = \"en/ex\"\n \n # else set all same\n else:\n for c in clip.iter():\n if c.entry:\n c.neighbour.entry = c.entry\n\n # set couple for subj (not sure if needed)\n prevsingle = None\n for s in self.iter():\n if s.entry:\n if s.entry in (\"ex\",\"en\"):\n if prevsingle and s.entry == prevsingle.entry:\n s.couple = prevsingle\n prevsingle.couple = s\n prevsingle = s\n\n if False: #DEBUG: \n print(\"view subj entries\")\n for s in self.iter():\n print(s, s.entry)\n\n\n\n\n\n # phase three - construct a list of clipped polygons\n # --------------------------------------------------\n\n ######\n # Defs\n def next_unprocessed(vert):\n origvert = vert\n while vert:\n if vert.entry and not (vert.checked or vert.neighbour.checked):\n #print \"vert, found next unproc\", vert, vert.checked, vert.neighbour.checked\n if vert.couple:\n # rule 1\n if vert.couple.entry and vert.entry:\n # rule 2\n if vert.couple.entry == \"en\" and vert.entry == \"en\":\n return vert.couple\n elif vert.couple.entry == \"ex\" and vert.entry == \"ex\":\n return vert\n # rule 3\n else:\n return vert\n \n vert = vert.__next__\n \n if vert == origvert:\n # if returned to first, return None\n return None\n\n def DeleteFlag1(cur, stat):\n if cur.entry == \"en/ex\":\n cur.entry = None\n if cur.cross_change:\n if stat == \"D3\":\n return \"D3\"\n else:\n return \"D4\"\n if stat == \"D3\":\n return \"D4\"\n else:\n return \"D3\"\n if cur.entry == \"ex/en\":\n if stat == \"D3\":\n cur.entry = \"en\"\n return \"D2\"\n else:\n cur.entry = \"ex\"\n return \"D1\"\n if cur.entry == \"en\":\n cur.entry = None\n return \"D1\"\n if cur.entry == \"ex\":\n cur.entry = None\n return \"D2\"\n\n def DeleteFlag2(cur, prev, stat):\n if cur.entry == \"en/ex\":\n if stat == \"D1\":\n cur.entry = \"ex\"\n else:\n cur.entry = \"en\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex/en\":\n if stat == \"D1\":\n cur.entry = \"en\"\n else:\n cur.entry = \"ex\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"en\":\n cur.entry = None\n if stat == \"D1\" and cur.couple and prev.couple == cur:\n return \"D1\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex\":\n cur.entry = None\n if stat != \"D1\" and cur.couple and prev.couple == cur:\n return \"D2\"\n else:\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n\n def proceed(cur, stat):\n cur.checked = True\n if stat == \"D1\":\n clipped.add(Vertex(cur))\n return cur.__next__\n elif stat == \"D2\":\n clipped.add(Vertex(cur))\n return cur.prev\n else:\n return cur.neighbour\n\n ####\n resultpolys = []\n\n self.first.checked = True\n cur = prev = start = next_unprocessed(self.first)\n\n while cur:\n # each new polygon\n print(\"new poly\")\n\n stat = DeleteFlag1(cur, \"D3\")\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n clipped = Polygon()\n cur = proceed(cur, stat)\n\n # collect vertexes\n while cur != start:\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n if cur.entry:\n if stat == \"D1\" or stat == \"D2\":\n stat = DeleteFlag2(cur, prev, stat)\n else:\n stat = DeleteFlag1(cur, stat)\n prev = cur\n cur = proceed(cur, stat)\n\n # return to first vertex\n clipped.add(Vertex(clipped.first))\n\n print(clipped)\n\n resultpolys.append((clipped,[]))\n cur = prev = start = next_unprocessed(self.first)\n\n\n\n # finally, sort into exteriors and holes\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\n for otherext,otherholes in resultpolys:\n if polyext == otherext:\n continue # don't compare to self\n if polyext.first.isInside(otherext):\n otherholes.append(polyext) #poly is within other so make into a hole\n del resultpolys[pindex] #and delete poly from being an independent poly\n return resultpolys","def match2(img1, img2, coordinates1, coordinates2, PATCH_SIZE):\n\n\tpossible_matches = pd.DataFrame(columns=['feature1', 'feature2', 'diff'])\n\n\t# iteration through all the possible pairs of features from img1 and img2\n\tfor (feature1, feature2) in product(coordinates1, coordinates2):\n\t\tpatch1 = make_patch(feature1, PATCH_SIZE, img1)\n\t\tpatch2 = make_patch(feature2, PATCH_SIZE, img2)\n\t\tdiff = count_difference(patch1, patch2)\n\t\t# print(feature1, feature2, diff)\n\t\t# next line is weird, don't ask\n\t\tpossible_matches = possible_matches.append({'feature1': feature1, 'feature2': feature2, 'diff': diff}, ignore_index=True)\n\n\n\t# sorting the possible_matches according to their difference and resetin the index\n\t# inplace=True means that changes will be performed in-place, so they will change the variable and there is no need to reassign\n\tpossible_matches.sort_values(['diff'], inplace=True)\n\tpossible_matches.reset_index(inplace=True, drop=True)\n\t# print(\"SORTED\")\n\t# print(possible_matches)\n\n\t# adding only the best matches\n\tmatches = []\n\twhile not possible_matches.empty:\n\t\tbest_match = possible_matches.loc[0]\n\t\tmatches.append(list(best_match))\n\t\t# creating a list of indicies to be dropped\n\t\ttrash = []\n\n\t\t#finding and deleting rows with features that are already used and reseting the index\n\t\tfor i, (f1, f2, d) in enumerate(possible_matches.values):\n\t\t \n\t\t\tif np.all(f1 == best_match[0]) or np.all(f2 == best_match[1]):\n\t\t\t\ttrash.append(i)\n\t\n\t\tfor i in trash:\n\t\t\tpossible_matches.drop(i, inplace=True)\n\t\tpossible_matches.reset_index(inplace=True, drop=True)\n\t\t# print(possible_matches)\n\n\treturn matches","def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\n min_ratio, max_ratio):\n output = []\n for contour in input_contours:\n x, y, w, h = cv2.boundingRect(contour)\n if (w < min_width or w > max_width):\n continue\n if (h < min_height or h > max_height):\n continue\n area = cv2.contourArea(contour)\n if (area < min_area):\n continue\n if (cv2.arcLength(contour, True) < min_perimeter):\n continue\n hull = cv2.convexHull(contour)\n solid = 100 * area / cv2.contourArea(hull)\n if (solid < solidity[0] or solid > solidity[1]):\n continue\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\n continue\n ratio = (float)(w) / h\n if (ratio < min_ratio or ratio > max_ratio):\n continue\n output.append(contour)\n return output","def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\n\n\t#creating patches for all points from img1 and img2\n\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\n\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\n\n\t# creating a matrix with dissimilarity measures for all pairs\n\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\n\n\tfor (x, y), _ in np.ndenumerate(all_matches):\n\t\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\n\n\t#looking for best left-to-right and right-to-left matches\n\tmatches = []\n\t#left-to-right\n\tfor i, coord1 in enumerate(coordinates1):\n\t\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\n\t\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\n\t\tif (i == best_rtl_match): #hurray, there is a super match\n\n\t\t\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\n\t\n\treturn matches","def compute_coverage_for_contour_pair(\n contour1: np.ndarray,\n contour2: np.ndarray,\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\n):\n im1, im2 = compute_contour_binary_masks(contour1, contour2, max_size=max_size)\n return (im1 & im2).sum() / im1.sum()","def get_matching(self):\n verts, plaqs, d_verts, d_plaqs = self.get_stabs()\n\n # def get_matching(anyons, d_anyons):\n # edges = self.get_edges(anyons)\n # for i0, i1, weight in edges:\n # nxgraph.add_edge(i0, i1, weight=-weight)\n # output = nx.algorithms.matching.max_weight_matching(nxgraph, maxcardinality=True)\n # return [[d_anyons[i0], d_anyons[i1]] for i0, i1 in output]\n\n def get_matching(anyons, d_anyons):\n output = pm.getMatching(len(anyons), self.get_edges(anyons))\n return [[d_anyons[i0], d_anyons[i1], anyons[i0], anyons[i1]] for i0, i1 in enumerate(output) if i0 > i1]\n\n self.matching = []\n if verts:\n self.matching += get_matching(verts, d_verts)\n if plaqs:\n self.matching += get_matching(plaqs, d_plaqs)","def isFusion(event,buff):\n index,diff,label = event\n label = label[0]\n if diff>0:\n return False,[]\n img_before = np.copy(buff[:,:,index-1])\n img_after = np.copy(buff[:,:,index])\n mask_before = (img_before==label).astype(np.uint8)\n nb_elts_before = np.amax(img_before)\n kernel = np.ones((7,7),np.uint8)\n neighbouring_mask = cv2.dilate(mask_before,kernel,iterations=8)\n\n new_map = np.multiply(img_before,neighbouring_mask.astype(np.uint8))\n \n #Removing the element we are currently looking at\n new_map[img_before==label]=0\n possible_candidates = []\n for i in range(nb_elts_before):\n if np.any(new_map==i+1):\n possible_candidates.append(i+1)\n #Computes the area of the cells and compares them\n size_cell_disappearing = np.count_nonzero(img_before==label)\n match = [] #lists the ratios sizeAfter/sizeBefore for possible matches\n \n for vals in possible_candidates:\n size_other_cell = np.count_nonzero(img_before==vals)\n size_before = size_other_cell+size_cell_disappearing\n size_after = np.count_nonzero(img_after==vals)\n ratio = float(size_after)/float(size_before)\n if ratio>0.8 and ratio<1.2:\n match.append((vals,abs(1-ratio)))\n if len(match)==0:\n return False,[]\n if len(match)>1:\n #Several matches, so pick the best\n values = [y for x,y in match]\n result_label,osef = match[np.argmin(values)]\n else:\n result_label, osef = match[0]\n return True,result_label","def has_match(trajs_0, trajs_1):\n for i in range(len(trajs_0)):\n for j in range(len(trajs_1)):\n R = (trajs_0[i].get_slice()[:,:2] == trajs_1[j].get_slice()[:,:2])\n if isinstance(R, bool):\n if R:\n return True \n elif R.all():\n return True \n else:\n pass \n return False","def equiv(subdiagram1, subdiagram2):\n # TODO: Make sure arguments are the right type\n # TODO: Make this work for subdiagrams of length >= 1\n # subdiagrams are not equivalent if they have different numbers of crossings\n # print \"sub1\\t\", subdiagram1, len(subdiagram1[0])\n # print \"sub2\\t\", subdiagram2, len(subdiagram2[0])\n if len(subdiagram1[0]) != len(subdiagram2[0]):\n return False\n # look for a match\n for i in range(len(subdiagram1[0])-1):\n crossing1 = subdiagram1[0][i]\n typeMatch = False\n for j in range(len(subdiagram2[0])-1):\n crossing2 = subdiagram2[0][j]\n print \"\\tc1 \",crossing1\n print \"\\tc2 \",crossing2\n # check for same crossing type\n # TODO: check for empty crossing\n if len(crossing1) == 5 and len(crossing2) == 5:\n if crossing1[0] == crossing2[0]:\n print \" :)\"\n typeMatch = True\n \n\n return True","def is_different(image1, image2):\n gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)\n gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)\n\n (score, diff) = compare_ssim(gray1, gray2, full=True)\n diff = (diff * 255).astype(\"uint8\")\n\n thresh = cv2.threshold(diff, 0, 255,\n cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\n cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL,\n cv2.CHAIN_APPROX_SIMPLE)\n cnts = cnts[0] if imutils.is_cv2() else cnts[1]\n\n return bool(cnts)","def __find_contours(input, external_only):\n if(external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\n return contours","def is_complete(self, A, B):\n return all(self.is_edge(v, w) for v in A for w in B)","def is_sub(ind_a, ind_b):\n while ind_a < len(s) and ind_b < len(p):\n if ind_a in removed or s[ind_a] != p[ind_b]:\n ind_a += 1\n continue\n ind_a += 1\n ind_b += 1\n return ind_b == len(p)","def test_commonfs_truecase():\n f1 = tempfile.mkstemp()\n f2 = tempfile.mkstemp()\n rc1 = r.RemovalCandidate(f1[1])\n rc2 = r.RemovalCandidate(f2[1])\n assert r.commonfs([rc1,rc2])","def getCV(file1, type, imgOri,iteration):\n del s_arrays[:]\n del shapesContours[:]\n\n if type == 'shapes':\n spContours = getContours(imgOri,iteration)\n file1.write(str(len(spContours)) + '\\n')\n print(len(spContours))\n spContours = clean_Con(spContours)\n file1.write(str(len(spContours)) + '\\n')\n print(len(spContours))\n cv2.drawContours(imgOri, spContours, -1, (0, 255, 128), 5)\n # del s_arrays[:]\n # for each shape\n for cons in spContours:\n sampleComVector = []\n x, y, w, h = cv2.boundingRect(cons)\n cv2.rectangle(imgOri, (x, y), (x + w, y + h), (100, 100, 100), 1)\n\n # move the points to center\n for point in cons:\n sampleComVector.append(complex(point[0][0] - x, (point[0][1] - y)))\n # sampleComVectors store CV of all testees contours\n s_arrays.append(sampleComVector)\n # sampleContours store all testees contours, same order with sampleComVectors\n shapesContours.append(cons)\n\n elif type == 'temp':\n # Automatically find templete contour\n templetTrue = imgOri\n tpContour = getContours(templetTrue,iteration)\n for contour in tpContour:\n x, y, w, h = cv2.boundingRect(contour)\n #\n for point in contour:\n # -x and -y are to make left and upper boundry start from 0\n t_array.append(complex(point[0][0] - x, (point[0][1] - y)))","def _check_flip(origin_imgs, result_imgs):\n h, w, c = origin_imgs.shape\n for i in range(h):\n for j in range(w):\n for k in range(c):\n if result_imgs[i, j, k] != origin_imgs[i, w - 1 - j, k]:\n return False\n return True","def test_tree_intersection_on_whiteboard_example(one_wb, two_wb):\n expected = [200, 150, 141, 100]\n actual = tree_intersection(one_wb, two_wb)\n assert expected == actual","def solve_part2(start):\n inputs = load_inputs(False)\n all_matches = []\n tiles = inputs.keys()\n for elem in tiles:\n matches = defaultdict(list)\n for elem2 in tiles:\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\n l = matches[elem]\n l.append(elem2)\n if matches[elem]:\n all_matches.append(matches[elem])\n\n # start frmo an aribtrary corner\n # find a match, rotate me so that the match is along the right side\n # fill in properly oriented match\n # repeat, for row = 1+, consider top-match and left-match\n\n # for eery rotations / orientation, look fot the pattern","def compara_chaves(chave1, chave2):\n for l in range(5):\n for c in range(5):\n if ref_chave(chave1, faz_pos(l, c)) != chave2[l][c]:\n return False\n return True","def cross_match(objects, img_wcs, coord, dist_thresh=1.0):\n # coordinates in arcsec\n objs_coord = img_wcs.pixel_to_world(objects[\"x\"], objects[\"y\"])\n objs_ra = objs_coord.ra.to(u.arcsec).value\n objs_dec = objs_coord.dec.to(u.arcsec).value\n\n cat_ra = np.array(coord.ra.to(u.arcsec).value)\n cat_dec = np.array(coord.dec.to(u.arcsec).value)\n\n objs_id = []\n for i in range(len(objects)):\n ra_dist = objs_ra[i] - cat_ra\n dec_dist = objs_dec[i] - cat_dec\n dist_arcsec = np.sqrt(ra_dist**2 + dec_dist**2)\n if any(dist_arcsec <= dist_thresh):\n objs_id.append(i)\n\n objs = objects.take(objs_id)\n\n return objs","def __find_contours(input, external_only):\n if (external_only):\n mode = cv2.RETR_EXTERNAL\n else:\n mode = cv2.RETR_LIST\n method = cv2.CHAIN_APPROX_SIMPLE\n contours, hierarchy = cv2.findContours(input, mode=mode, method=method)\n return contours","def bfs_is_connected(self):\n q = Queue.Queue()\n origins = [self.vertices()[0]]\n traveled = set(origins)\n while origins:\n for o in origins:\n for child in self.out_vertices(o):\n if child not in traveled:\n q.put(child)\n traveled.add(child)\n\n origins = []\n while not q.empty():\n origins.append(q.get())\n if len(traveled) == self.order():\n return True\n return False","def testMatchSwarpLanczos2SubExposure(self):\n for useDeepCopy in (False, True):\n self.compareToSwarp(\"lanczos2\", useWarpExposure=True,\n useSubregion=True, useDeepCopy=useDeepCopy)","def __find_contours(input, external_only):\r\n if(external_only):\r\n mode = cv2.RETR_EXTERNAL\r\n else:\r\n mode = cv2.RETR_LIST\r\n method = cv2.CHAIN_APPROX_SIMPLE\r\n _, contours, hierarchy = cv2.findContours(\r\n input, mode=mode, method=method)\r\n return contours","def get_instance_contours(img, contoured, instance):\n mask = np.zeros(img.shape, dtype=np.uint16)\n mask[img == instance] = 1\n ret, threshed = cv.threshold(mask, 0, 2 ** 16, cv.THRESH_BINARY)\n compressed = threshed.astype(np.uint8)\n contours, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n cv.drawContours(contoured, contours, -1, (randint(25, 255), randint(25, 255), randint(25, 255)), 3)\n img2 = contours = hierarchy = mask = None","def _extractFrames_(self, wordRulesFlag):\n\t\t#pdb.set_trace()\n\t\tsimplifyTree(self.srcTree)\n\t\tsimplifyTree(self.tgtTree)\n\n\t\tsDic, tDic = {}, {}\n\t\tframeSet = set() \n\t\tfor sSubtr in self.srcTree.subtrees():\n\t\t\tif sSubtr.height() <= 2:\n\t\t\t\tcontinue\n\n\t\t\tsTreePos = sSubtr.treeposition()\n\t\t\tsOffset = treePosition2offset(sTreePos, self.srcTree)\n\t\t\tsDic[sTreePos] = scanBlock(sOffset, 'src', self.waMatrix)\n\n\t\t\tfor tSubtr in self.tgtTree.subtrees():\n\t\t\t\tif tSubtr.height() <= 2:\n\t\t\t\t\tcontinue\n\n\t\t\t\ttTreePos = tSubtr.treeposition()\n\t\t\t\tif tTreePos not in tDic:\n\t\t\t\t\ttOffset = treePosition2offset(tTreePos, self.tgtTree)\n\t\t\t\t\ttDic[tTreePos] = scanBlock(tOffset, 'tgt', self.waMatrix)\n\t\t\t\telse:\n\t\t\t\t\ttOffset = tDic[tTreePos]\n\n\t\t\t\t#print >> debug_log, self.srcTree[sTreePos]\n\t\t\t\t#print >> debug_log, self.tgtTree[tTreePos]\n\t\t\t\tif sDic[sTreePos] == tDic[tTreePos] and -1 not in sDic[sTreePos] and -1 not in tDic[tTreePos]:\n\t\t\t\t\t#print >> debug_log, 'paird up!!'\n\t\t\t\t\tframeSet.add(Frame([sTreePos], [tTreePos], self.srcTree, self.tgtTree))\n\t\t\t\t#print >> debug_log\n\n\t\t'''\n\t\tsrcSubtreeSpanDict = self._extractSubtreeSpan_(self.srcTree, wordRulesFlag)\n\t\ttgtSubtreeSpanDict = self._extractSubtreeSpan_(self.tgtTree, wordRulesFlag)\n\n\t\tframeSet = set() \n\t\tfor span in srcSubtreeSpanDict:\n\t\t\tif not self._consistentWithWA_(span, 'src'):\n\t\t\t\tcontinue\n\t\t\ttgtSpanList = self._scanSpan_(span, 'src')\n\t\t\tfor tgtSpan in tgtSpanList:\n\t\t\t\tif tgtSpan in tgtSubtreeSpanDict:\n\t\t\t\t\t#print >> debug_log, span, tgtSpan\n\t\t\t\t\tframeSet.add(Frame([srcSubtreeSpanDict[span]], [tgtSubtreeSpanDict[tgtSpan]], self.srcTree, self.tgtTree))\n\n\t\t#print >> debug_log, '\\n'\n\t\tfor span in tgtSubtreeSpanDict:\n\t\t\tif not self._consistentWithWA_(span, 'tgt'):\n\t\t\t\tcontinue\n\t\t\tsrcSpanList = self._scanSpan_(span, 'tgt')\n\t\t\tfor srcSpan in srcSpanList:\n\t\t\t\tif srcSpan in srcSubtreeSpanDict:\n\t\t\t\t\t#print >> debug_log, srcSpan, span\n\t\t\t\t\tframeSet.add(Frame([srcSubtreeSpanDict[srcSpan]], [tgtSubtreeSpanDict[span]], self.srcTree, self.tgtTree))\n\t\t'''\n\t\t#pdb.set_trace()\n\t\tframeList = self._mergeFrames_(frameSet)\n\t\t#print >> debug_log, len(frameList)\n\t\treturn frameList","def compare_tree(self):\n result = []\n \n pathA = os.path.join(self.testpath,'A')\n pathB = os.path.join(self.testpath,'B')\n\n filesA = [os.path.relpath(f,pathA) for f in self.tree(pathA)]\n filesB = [os.path.relpath(f,pathB) for f in self.tree(pathB)]\n\n filesAB = set(filesA).union(filesB)\n for fileAB in sorted(list(filesAB)):\n\n fileA = os.path.join(self.testpath,'A',fileAB)\n fileB = os.path.join(self.testpath,'B',fileAB)\n try:\n fileAtxt = open(fileA).read()\n except IOError:\n result.append( ('missing_inA',fileAB) )\n continue\n \n try:\n fileBtxt = open(fileB).read()\n except IOError:\n result.append( ('missing_inB',fileAB) )\n continue\n\n if not fileAtxt == fileBtxt:\n result.append( ('disagree',fileAB))\n \n return result","def findtubestand_matchonobb(self, tgtpcdnp, toggledebug=False):\n\n # toggle the following command to crop the point cloud\n # tgtpcdnp = tgtpcdnp[np.logical_and(tgtpcdnp[:,2]>40, tgtpcdnp[:,2]<60)]\n\n inithomomat = self.findtubestand_obb(tgtpcdnp, toggledebug)\n inlinnerrmse, homomat = o3dh.registration_icp_ptpt(self.tstpcdnp, tgtpcdnp, inithomomat, maxcorrdist=5,\n toggledebug=toggledebug)\n inithomomatflipped = copy.deepcopy(inithomomat)\n inithomomatflipped[:3, 0] = -inithomomatflipped[:3, 0]\n inithomomatflipped[:3, 1] = -inithomomatflipped[:3, 1]\n inlinnerrmseflipped, homomatflipped = o3dh.registration_icp_ptpt(self.tstpcdnp, tgtpcdnp, inithomomatflipped,\n maxcorrdist=5, toggledebug=toggledebug)\n print(inlinnerrmse, inlinnerrmseflipped)\n if inlinnerrmseflipped < inlinnerrmse:\n homomat = homomatflipped\n return copy.deepcopy(homomat)","def match_features(self):\n type_of_None = type(None)\n if type(self.featureDesA) != type_of_None and type(self.featureDesB) != type_of_None:\n matches = self.bfMatcher.match(self.featureDesA, self.featureDesB)\n self.match = sorted(matches, key=lambda x: x.distance)\n self.match = self.match[:50]\n else:\n self.match = []","def match_greedy_sift(keypoints_A, keypoints_B, features_A, features_B, test_ratio=0.75):\n matcher = cv2.DescriptorMatcher_create(\"BruteForce\")\n matches = matcher.knnMatch(features_A, features_B, 2)\n\n refined_matches = []\n for m in matches:\n if len(m) == 2 and m[0].distance < m[1].distance * test_ratio:\n refined_matches.append((m[0].queryIdx, m[0].trainIdx))\n\n match_A, match_B = [], []\n for idA, idB in refined_matches:\n match_A.append(keypoints_A[idA])\n match_B.append(keypoints_B[idB])\n\n return np.int32(match_A), np.int32(match_B)","def getContours(img,iteration):\n nP, IDrange = upDate(iteration)\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\n kernel = np.ones((nP, nP), np.uint8)\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\n contours = []\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n if iteration == 2 :\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n elif iteration == 3:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n else:\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n\n return contours","def extractFeatures(bwimage):\n \n \n # circularity\n img = bwimage.copy()\n img1, contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n \n if len(contours)==0:\n return []\n B = contours[0]\n C = B[:,0,0]\n l = C.size\n \n \n if abs(B[0,0,0] - B[l-1,0,0]) + abs(B[0,0,1] - B[l-1,0,1]) == 2:\n P8 = math.sqrt(2)\n else:\n P8 = 1 \n for j in range(0,l-1): \n if abs((B[j+1,0,0] - B[j,0,0])) + abs(B[j+1,0,1] - B[j,0,1]) == 2:\n P8 = P8 + math.sqrt(2)\n else:\n P8 = P8 + 1\n \n n = np.count_nonzero(bwimage)\n \n circularity = P8*P8/n\n \n \n # elongation\n idx = np.nonzero(bwimage);\n c = idx[1]\n r = idx[0]\n meanx = np.mean(c)\n meany = np.mean(r)\n \n \n pows = 2*np.ones(n)\n \n sigxx = np.sum(np.power((c-meanx),pows))/n\n sigyy = np.sum(np.power((r-meany),pows))/n\n sigxy = np.sum(np.multiply((r-meany),(c-meanx)))/n\n \n covMat = np.array([[sigxx, sigxy], [sigxy, sigyy]])\n val, vects = np.linalg.eig(covMat);\n \n maxEigenValue = np.amax(val) \n minEigenValue = np.amin(val.ravel()[np.flatnonzero(val)])\n \n \n elongation = math.sqrt(maxEigenValue/minEigenValue);\n \n \n # principal axis\n maxidx = np.argmax(val)\n principalAxisVector = vects[maxidx]\n \n \n return [circularity, elongation, principalAxisVector]"],"string":"[\n \"def GetMatchedSubContourListsCollapsing(scListA, scListB):\\n\\n if (\\n scListA == scListB\\n ): # if we got the same object for some reason, just return 2 shallow clones\\n return scListA, scListB\\n\\n scsMatchedInB = [] # This keeps us from looping over both lists\\n\\n scsMatchedInB, removeFromA, removeFromB = FindMatchesAndRemovals(scListA, scListB)\\n unMatchedInB = [\\n i for i in range(len(scListB)) if i not in scsMatchedInB\\n ] # This lets us skip the indexes that already matched\\n\\n _, removeFromB_2, removeFromA_2 = FindMatchesAndRemovals(\\n scListB, scListA, searchInds=unMatchedInB\\n ) # FLIP\\n\\n removeFromA = sorted(list(set(removeFromA + removeFromA_2)))\\n removeFromB = sorted(list(set(removeFromB + removeFromB_2)))\\n\\n scListANew = deepcopy(scListA)\\n scListBNew = deepcopy(scListB)\\n\\n for i in removeFromA[::-1]:\\n RemoveSubContour(scListA, i)\\n for i in removeFromB[::-1]:\\n RemoveSubContour(scListB, i)\\n\\n return scListANew, scListBNew\",\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def analyzeContours(contours):\\n if len(contours[0]) != 4 and len(contours[0]) != 8:\\n return 0\\n\\n first, second, prev = [1, 1], [1, 1], 0\\n for i, val in enumerate(numpy.nditer(contours[0])):\\n if i % 2:\\n second = [prev, val]\\n else:\\n first = [prev, val]\\n\\n # compare pair to the previous pair\\n for num in first:\\n if num in second:\\n break\\n else:\\n return 0\\n\\n prev = val\\n\\n return 1\",\n \"def GetMatchedSubContourLists(\\n scListRef,\\n scList,\\n allValsByFrame,\\n orderOfSCsByValue,\\n splitLength=1,\\n fixedNumInteriorPoints=None,\\n):\\n ## NOT DONE! MERGE LATER??\\n return simplifiedSCListRef, simplifiedSCList\",\n \"def compare(image_a, image_b, is_camera_image):\\n\\n # Generate a unique filename\\n filename = uuid.uuid4().hex[:3]\\n\\n if is_camera_image:\\n image_a = imutils.rotate_bound(image_a, 90)\\n image_b = imutils.rotate_bound(image_b, 90)\\n\\n # Store original to show in future\\n original = image_a\\n\\n # Convert to greyscale\\n image_a = cv2.cvtColor(image_a, cv2.COLOR_BGR2GRAY)\\n image_b = cv2.cvtColor(image_b, cv2.COLOR_BGR2GRAY)\\n\\n # Reduce size and blur to account for shaky handheld camera based images\\n if is_camera_image:\\n scale_multiplier = 0.03125\\n image_a = cv2.resize(image_a, (0, 0), fx=scale_multiplier, fy=scale_multiplier)\\n image_b = cv2.resize(image_b, (0, 0), fx=scale_multiplier, fy=scale_multiplier)\\n image_a = cv2.GaussianBlur(image_a, (1001, 1001), cv2.BORDER_DEFAULT)\\n image_b = cv2.GaussianBlur(image_b, (1001, 1001), cv2.BORDER_DEFAULT)\\n\\n # Obtain SSIM and determine differences\\n try:\\n _, differences = structural_similarity(image_a, image_b, full=True, gaussian_weights=True)\\n except ValueError:\\n print('Images are not the same size')\\n return None\\n\\n # Convert to cv2 array\\n differences = (differences * 255).astype('uint8')\\n\\n # Threshold and find contours (differences)\\n thresh = cv2.threshold(differences, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\\n contours = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n contours = imutils.grab_contours(contours)\\n\\n # Draw contours (differences)\\n for cont in contours:\\n (x, y, w, h) = cv2.boundingRect(cont)\\n if is_camera_image:\\n multiplier = int(1 / scale_multiplier)\\n y *= multiplier\\n x *= multiplier\\n h *= multiplier\\n w *= multiplier\\n cv2.rectangle(original, (x, y), (x + w, y + h), (255, 0, 0), 4)\\n\\n # TODO: Create GIF highlighting differences (instead of statuic image)\\n cv2.imwrite('static/images/differences/' + filename + '.jpg', original)\\n\\n return filename\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def remove_duplicates_by_matching():\\n # 1) and 2)\\n all_blobs = vision.pqr_r\\n all_angles = np.zeros(0)\\n right = np.transpose(vision.pqr_r)\\n left = np.transpose(vision.pqr_l)\\n\\n if not right.size and not left.size:\\n return (0, 0)\\n\\n if not right.size:\\n for l in left:\\n angle = np.arctan2(l[1], l[0]) * 180 / pi\\n all_angles = np.append(all_angles, angle)\\n return (vision.pqr_l, all_angles)\\n\\n if not left.size:\\n for r in right:\\n angle = np.arctan2(r[1], r[0]) * 180 / pi\\n all_angles = np.append(all_angles, angle)\\n return (vision.pqr_r, all_angles)\\n\\n\\n for r in right:\\n angle = np.arctan2(r[1], r[0]) * 180 / pi\\n all_angles = np.append(all_angles, angle)\\n cand_r = np.zeros((3,1))\\n if angle < 15:\\n cand_r = np.append(cand_r, [[r[0]], [r[1]], [r[2]]], axis=1)\\n cand_r = np.delete(cand_r, 0, axis=1)\\n cand_r = np.transpose(cand_r)\\n\\n for l in left:\\n angle = np.arctan2(l[1], l[0]) * 180 / pi\\n dot = 0\\n if angle > -15:\\n dl = max(0.001, np.linalg.norm(l))\\n for r in cand_r:\\n dr = max(0.001, np.linalg.norm(r))\\n dot = np.dot(r, l) / (dr * dl)\\n print(dot)\\n if dot > 0.9:\\n continue\\n \\n if dot <= 0.9:\\n all_blobs = np.append(all_blobs, [[l[0]], [l[1]], [l[2]]], axis=1)\\n all_angles = np.append(all_angles, angle)\\n\\n # make even number of blobs if necessary\\n #if all_blobs.shape[1] % 2:\\n # all_blobs = np.delete(all_blobs, 0, axis=1)\\n # all_angles = np.delete(all_angles, 0)\\n\\n\\n\\n return (all_blobs, all_angles)\",\n \"def find_cards(thresh_image):\\n\\n # Find contours and sort their indices by contour size\\n cnts,hier = cv2.findContours(thresh_image,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\\n index_sort = sorted(range(len(cnts)), key=lambda i : cv2.contourArea(cnts[i]),reverse=True)\\n\\n print(\\\"Contour length\\\", len(cnts))\\n\\n # If there are no contours, do nothing\\n if len(cnts) == 0:\\n return [], []\\n\\n # Otherwise, initialize empty sorted contour and hierarchy lists\\n cnts_sort = []\\n hier_sort = []\\n cnt_is_card = np.zeros(len(cnts),dtype=int)\\n\\n # Fill empty lists with sorted contour and sorted hierarchy. Now,\\n # the indices of the contour list still correspond with those of\\n # the hierarchy list. The hierarchy array can be used to check if\\n # the contours have parents or not.\\n for i in index_sort:\\n cnts_sort.append(cnts[i])\\n hier_sort.append(hier[0][i])\\n\\n # Determine which of the contours are cards by applying the\\n # following criteria: 1) Smaller area than the maximum card size,\\n # 2), bigger area than the minimum card size, 3) have no parents,\\n # and 4) have four corners\\n\\n for i in range(len(cnts_sort)):\\n size = cv2.contourArea(cnts_sort[i])\\n peri = cv2.arcLength(cnts_sort[i],True)\\n approx = cv2.approxPolyDP(cnts_sort[i],0.01*peri,True)\\n\\n # (size < CARD_MAX_AREA) and (size > CARD_MIN_AREA)\\n # and\\n # and (hier_sort[i][3] == -1)\\n # and (len(approx) == 4)\\n if ((size > CARD_MIN_AREA)):\\n print('[inside loop]',size)\\n cnt_is_card[i] = 1\\n\\n return cnts_sort, cnt_is_card\",\n \"def findMatchesBetweenImages(image_1, image_2):\\n # matches - type: list of cv2.DMath\\n matches = None\\n # image_1_kp - type: list of cv2.KeyPoint items.\\n image_1_kp = None\\n # image_1_desc - type: numpy.ndarray of numpy.uint8 values.\\n image_1_desc = None\\n # image_2_kp - type: list of cv2.KeyPoint items.\\n image_2_kp = None\\n # image_2_desc - type: numpy.ndarray of numpy.uint8 values.\\n image_2_desc = None\\n # WRITE YOUR CODE HERE.\\n\\n sift = cv2.ORB_create()\\n image_1_kp, image_1_desc = sift.detectAndCompute(image_1, None)\\n image_2_kp, image_2_desc = sift.detectAndCompute(image_2, None)\\n\\n # bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)\\n # matches = bf.match(image_1_desc, image_2_desc)\\n # matches = sorted(matches, key = lambda x:x.distance)\\n # matches = matches[:10]\\n\\n bf = cv2.BFMatcher()\\n matches = bf.knnMatch(image_1_desc, image_2_desc, k=2)\\n\\n # Apply ratio test\\n good = []\\n for m, n in matches:\\n print(m.distance, n.distance, m.distance < .75*n.distance)\\n if m.distance < (0.75 * n.distance):\\n good.append([m])\\n\\n # We coded the return statement for you. You are free to modify it -- just\\n # make sure the tests pass.\\n print(len(good), good)\\n return image_1_kp, image_2_kp, matches\\n # END OF FUNCTION.\",\n \"def get_matches(src,dst,src_list, dst_list):\\n matches=[]\\n for src_conn in src_list:\\n print src_conn\\n if (src_conn in dst_list) & (src_conn<>dst):\\n matches.append(src_conn)\\n return matches\",\n \"def img_compare(A, B):\\r\\n A = cv2.GaussianBlur(A, (5, 5), 5)\\r\\n B = cv2.GaussianBlur(B, (5, 5), 5)\\r\\n diff = cv2.absdiff(A, B) # absolute difference\\r\\n _, diff = cv2.threshold(diff, 200, 255, cv2.THRESH_BINARY)\\r\\n return np.sum(diff)\",\n \"def parent_children_match(parent_snap_index, child_parent_snap_index):\\n # too slow\\n #parent_child_start_time = time.time()\\n #parent_index_dict = dict( \\n # (k, i) \\n # for i, k in enumerate(parent_snap_index) \\n # )\\n #child_index_dict = dict( \\n # (k, i) \\n # for i, k in enumerate(child_parent_snap_index) \\n # )\\n #parent_child_meet = np.intersect1d( parent_snap_index, child_parent_snap_index ) \\n\\n #parents = np.array([\\n # parent_index_dict[k] for k in parent_child_meet\\n # ])\\n #children = np.array([\\n # child_index_dict[k] for k in parent_child_meet\\n # ])\\n #print 'Parent Child match takes ', time.time() - parent_child_start_time, ' seconds'\\n \\n #parent_child_start_time = time.time()\\n parent_sort_index = np.argsort(parent_snap_index)\\n child_sort_index = np.argsort(child_parent_snap_index)\\n sorted_parent_snap_index = parent_snap_index[parent_sort_index]\\n sorted_child_parent_snap_index = child_parent_snap_index[child_sort_index]\\n\\n parent_child_in1d = np.in1d(sorted_parent_snap_index, sorted_child_parent_snap_index)\\n child_parent_in1d = np.in1d(sorted_child_parent_snap_index, sorted_parent_snap_index)\\n \\n parents = parent_sort_index[parent_child_in1d]\\n children = child_sort_index[child_parent_in1d]\\n #print 'Parent Child match takes ', time.time() - parent_child_start_time, ' seconds'\\n\\n return parents, children\",\n \"def match(ra1, dec1, ra2, dec2, tol, allmatches=False):\\n \\n ra1,ra2,dec1,dec2 = map(np.asarray, (ra1, ra2, dec1, dec2))\\n\\n abs = np.abs\\n\\n isorted = ra2.argsort()\\n sdec2 = dec2[isorted]\\n sra2 = ra2[isorted]\\n\\n LIM = tol * DEG_PER_ASEC\\n\\n match = []\\n # use mean dec, assumes decs similar\\n decav = np.mean(sdec2.mean() + dec1.mean())\\n RA_LIM = LIM / cos(decav * RAD_PER_DEG)\\n\\n for ra,dec in zip(ra1,dec1):\\n i1 = sra2.searchsorted(ra - RA_LIM)\\n i2 = i1 + sra2[i1:].searchsorted(ra + RA_LIM)\\n #print(i1,i2)\\n close = []\\n for j in xrange(i1,i2):\\n if abs(dec - sdec2[j]) > LIM:\\n continue\\n else:\\n # if ras and decs are within LIM arcsec, then\\n # calculate actual separation:\\n disq = ang_sep(ra, dec, sra2[j], sdec2[j])\\n close.append((disq, j))\\n\\n close.sort()\\n if not allmatches:\\n # Choose the object with the closest separation inside the\\n # requested tolerance, if one was found.\\n if len(close) > 0:\\n min_dist, jmin = close[0]\\n if min_dist < LIM:\\n match.append((isorted[jmin], min_dist))\\n continue\\n # otherwise no match\\n match.append((-1,-1))\\n else:\\n # append all the matching objects\\n jclose = []\\n seps = []\\n for dist,j in close:\\n if dist < LIM:\\n jclose.append(j)\\n seps.append(dist)\\n else:\\n break\\n match.append(fromarrays([isorted[jclose], seps],\\n dtype=[(str('ind'),str('i8')),\\n str(('sep'),str('f8'))\\n ]))\\n\\n if not allmatches:\\n # return both indices and separations in a recarray\\n temp = np.rec.fromrecords(match, names=str('ind,sep'))\\n # change to arcseconds\\n temp.sep *= 3600.\\n temp.sep[temp.sep < 0] = -1.\\n return temp\\n else:\\n return match\",\n \"def subcontract(a, b):\\n for x in a:\\n for y in b:\\n if common_side(x, y):\\n return 1\\n return 0\",\n \"def take_contours(self):\\n gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)\\n blur = cv2.GaussianBlur(gray, (5, 5), 0)\\n ret, self.th = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\\n im2, contours, hierarchy = cv2.findContours(self.th, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n return [contour for contour in contours if 1000 < cv2.contourArea(contour) < 150000]\",\n \"def find_contours(thresh):\\n thresh = thresh.astype(np.uint8)\\n contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n\\n # filter outer contours\\n filtered_cont = []\\n for i in range(len(contours)):\\n if hierarchy[0, i, 3] == NO_PARENT:\\n filtered_cont.append(contours[i])\\n\\n return filtered_cont\",\n \"def match(image1,image2,threshold,useRansac=False,t_orientation=30,t_scale=0.5):\\r\\n im1, keypoints1, descriptors1 = ReadKeys(image1)\\r\\n im2, keypoints2, descriptors2 = ReadKeys(image2)\\r\\n #\\r\\n # REPLACE THIS CODE WITH YOUR SOLUTION (ASSIGNMENT 5, QUESTION 3)\\r\\n #\\r\\n # Generate five random matches (for testing purposes)\\r\\n # matched_pairs = []\\r\\n # num = 5\\r\\n # for i in range(num):\\r\\n # matched_pairs.append([keypoints1[i],keypoints2[i]])\\r\\n # return DisplayMatches(im1, im2, matched_pairs)\\r\\n\\r\\n # END OF SECTION OF CODE TO REPLACE\\r\\n #\\r\\n\\r\\n #q3\\r\\n matched_pairs = []\\r\\n between_angles = np.arccos(np.dot(descriptors1, np.transpose(descriptors2)))\\r\\n for i, row in enumerate(between_angles):\\r\\n \\tratio = sorted(row)[0] / sorted(row)[1]\\r\\n \\tif ratio <= threshold:\\r\\n\\t \\tmatched_pairs.append([keypoints1[i], keypoints2[np.where(row == sorted(row)[0])[0][0]]])\\r\\n # print(matched_pairs)\\r\\n if useRansac is False:\\r\\n return DisplayMatches(im1, im2, matched_pairs)\\r\\n\\t# \\r\\n\\r\\n #q4\\r\\n repetition = 10\\r\\n subsets = [[]] * repetition\\r\\n for i in range(repetition):\\r\\n r = random.randint(0, len(matched_pairs))\\r\\n for match in matched_pairs:\\r\\n ds1, ds2 = matched_pairs[r][1][2]/matched_pairs[r][0][2], match[1][2]/match[0][2]\\r\\n do1, do2 = (matched_pairs[r][1][3]-matched_pairs[r][0][3]), (match[1][3]-match[0][3])\\r\\n if abs(ds2 - ds1) <= t_scale * ds1 and abs(do2 - do1) % (2 * math.pi) <= t_orientation:\\r\\n subsets[i].append(match)\\r\\n\\r\\n max_i, max_len = 0, subsets[0]\\r\\n for i in range(10):\\r\\n l = len(subsets[i])\\r\\n if l > max_len:\\r\\n max_len = l\\r\\n max_i = i\\r\\n\\r\\n im3 = DisplayMatches(im1, im2, subsets[max_i])\\r\\n return im3\",\n \"def marge_matches(fm_A, fm_B, fsv_A, fsv_B):\\n # Flag rows found in both fmA and fmB\\n # that are intersecting (both) or unique (only)\\n import vtool as vt\\n flags_both_A, flags_both_B = vt.intersect2d_flags(fm_A, fm_B)\\n flags_only_A = np.logical_not(flags_both_A)\\n flags_only_B = np.logical_not(flags_both_B)\\n # independent matches\\n fm_both_AB = fm_A.compress(flags_both_A, axis=0)\\n fm_only_A = fm_A.compress(flags_only_A, axis=0)\\n fm_only_B = fm_B.compress(flags_only_B, axis=0)\\n # independent scores\\n fsv_both_A = fsv_A.compress(flags_both_A, axis=0)\\n fsv_both_B = fsv_B.compress(flags_both_B, axis=0)\\n fsv_only_A = fsv_A.compress(flags_only_A, axis=0)\\n fsv_only_B = fsv_B.compress(flags_only_B, axis=0)\\n # build merge offsets\\n offset1 = len(fm_both_AB)\\n offset2 = offset1 + len(fm_only_A)\\n offset3 = offset2 + len(fm_only_B)\\n # Merge feature matches\\n fm_merged = np.vstack([fm_both_AB, fm_only_A, fm_only_B])\\n # Merge feature scores\\n num_rows = fm_merged.shape[0]\\n num_cols_A = fsv_A.shape[1]\\n num_cols_B = fsv_B.shape[1]\\n num_cols = num_cols_A + num_cols_B\\n fsv_merged = np.full((num_rows, num_cols), np.nan)\\n fsv_merged[0:offset1, 0:num_cols_A] = fsv_both_A\\n fsv_merged[0:offset1, num_cols_A:] = fsv_both_B\\n fsv_merged[offset1:offset2, 0:num_cols_A] = fsv_only_A\\n fsv_merged[offset2:offset3, num_cols_A:] = fsv_only_B\\n return fm_merged, fsv_merged\",\n \"def find_original_contours(self):\\r\\n\\r\\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\\r\\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\\r\\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\\r\\n int(self.cell_size), 5)\\r\\n self.thresh_orig = 255 - self.thresh_invert\\r\\n\\r\\n # Find the contours of the image. Each contour should correspond to a cell\\r\\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\\r\\n for block in orig_contours:\\r\\n area = cv2.contourArea(block)\\r\\n\\r\\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\\r\\n if area < self.min_cell_size:\\r\\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)\",\n \"def _compositions_swapped(self, thermo):\\n assert self._ref_indicators is not None\\n\\n indicators = self._singlet_comparison(thermo)\\n\\n for list1, list2 in zip(indicators, self._ref_indicators):\\n comp_swapped = True\\n for ind1, ind2 in zip(list1, list2):\\n if ind1 == ind2:\\n comp_swapped = False\\n if comp_swapped:\\n return True\\n return False\",\n \"def intersect(pieceA, pieceB):\\n return pieceA[0] in pieceB or pieceA[1] in pieceB\",\n \"def compute_contour_coverage(\\n contoursA: ContourList,\\n contoursB: ContourList,\\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\\n):\\n arr = np.zeros((len(contoursA), len(contoursB)), dtype=\\\"float32\\\")\\n box_coverage = compute_coverage(\\n *[\\n np.array(\\n [\\n np.concatenate([contour.min(axis=0), contour.max(axis=0)])\\n for contour in contours\\n ]\\n )\\n for contours in [contoursA, contoursB]\\n ]\\n )\\n for idx1, contour1 in enumerate(contoursA):\\n for idx2, contour2 in enumerate(contoursB):\\n if box_coverage[idx1, idx2] == 0:\\n arr[idx1, idx2] = 0\\n continue\\n arr[idx1, idx2] = compute_coverage_for_contour_pair(\\n contour1, contour2, max_size=max_size\\n )\\n return arr\",\n \"def __find_contours(input1, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy = cv2.findContours(input1, cv2.RETR_TREE, method=method)\\n return contours\",\n \"def matchShapes(cnt1, cnt2):\\n\\tret = cv2.matchShapes(cnt1, cnt2, 1, 0.0)\\n\\treturn ret\",\n \"def chk_chng(src_flist,dst_flist):\\n uc_flist = []\\n c_flist = []\\n for files in src_flist:\\n if files in dst_flist:\\n uc_flist.append(files)\\n else:\\n c_flist.append(files)\\n return uc_flist,c_flist\",\n \"def backtrack2(B):\\n tracH, tracV=[],[]\\n lenR, lenC = len(B)-1, len(B[0])-1\\n R,C =lenR,lenC;\\n while R>0 and C>0:\\n LL,TT,LT = B[R][C-1], B[R-1][C], B[R-1][C-1] ## Left,Top,LeftTop\\n max3=max(LL, TT, LT)\\n if max3==LT:\\n if LT==B[R][C]-1: ## otherwise, it is a subsitution\\n tracH.append(R-1); tracV.append(C-1)\\n R-=1; C-=1\\n elif max3==TT: R-=1\\n else : C-=1\\n tracV.reverse(); tracH.reverse()\\n return tracH, tracV\",\n \"def sort_filtered_contours(self):\\r\\n\\r\\n # Get the contours again\\r\\n invert = 255 - self.thresh_invert\\r\\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\\r\\n\\r\\n # Make sure that they're within the correct range for size\\r\\n # If too small, it is probably noise; if too large, then should be things around the grid\\r\\n for i, c in enumerate(real_contours, 1):\\r\\n contour_area = cv2.contourArea(c)\\r\\n if self.min_cell_size < contour_area < self.max_cell_size:\\r\\n self.good_contours.append(c)\\r\\n\\r\\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\\r\\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\\r\\n\\r\\n # Sort the contours from top to bottom\\r\\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\\\"top-to-bottom\\\")\\r\\n\\r\\n # We then sort each row from left to right\\r\\n row = []\\r\\n for i, c in enumerate(half_sorted_contours, 1):\\r\\n row.append(c)\\r\\n if i % self.board_dimension == 0:\\r\\n (full_sorted_contours, _) = contours.sort_contours(row, method=\\\"left-to-right\\\")\\r\\n self.game_board_contours.append(full_sorted_contours)\\r\\n row = []\",\n \"def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\\n orderOfSCsByValueByFrame = [\\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\\n ]\\n return scListByFrame, orderOfSCsByValueByFrame\",\n \"def _red_detect_(self, nslice = 0, thresh = 2.0):\\n zk_1 = 's_' + format(nslice, '03d')\\n zk_2 = 's_' + format(nslice+1, '03d')\\n\\n zf_1 = self.z_dense[zk_1]\\n zf_2 = self.z_dense[zk_2]\\n\\n # extract the y and x coordinates\\n y1 = zf_1[:,0]\\n x1 = zf_1[:,1]\\n\\n y2 = zf_2[:,0]\\n x2 = zf_2[:,1]\\n\\n\\n # create a meshgrid\\n [YC, YR] = np.meshgrid(y2, y1)\\n [XC, XR] = np.meshgrid(x2, x1)\\n\\n\\n dist_block = np.sqrt((YC-YR)**2 + (XC-XR)**2)\\n red_pair = np.where(dist_block <= thresh) # find out where the distance between cell i in plane k and cell j in plane k+1 is below the threshold.\\n\\n ind1 = red_pair[0] # the indices in the first frame\\n ind2 = red_pair[1] # the indices in the second frame\\n\\n\\n # select those with markers > 0 and markers < 0\\n marker_1 = zf_1[ind1, 3]\\n\\n\\n new_idx = (marker_1 == 0) # select those with zero-markers, which are never counted before. These are new cells. marker_1 needs to be updated.\\n pool_new = ind1[new_idx] # select the indices in the first frame where new redundancies are detected \\n pool_new_cov = ind2[new_idx] # select the indices in the second frame where new redundancies are detected.\\n\\n\\n pool_exist = ind1[~new_idx] # among the detected redundancies, find those already marked.\\n pool_exist_cov = ind2[~new_idx] # correspondingly, find those already marked in the adjacent slice\\n\\n n_new = len(pool_new)\\n n_exist = len(pool_exist)\\n if self.verbose:\\n print(n_new, \\\"new redundancies, \\\", n_exist, \\\"existing redundancies\\\")\\n\\n for n_count in np.arange(n_new):\\n # build the new keys\\n # also, we need to assign each new key an identity number which is unique.\\n n_ind1 = pool_new[n_count] # find the indices in the first slice that contains new redundancies\\n n_ind2 = pool_new_cov[n_count] # find the indices in the following slice \\n pr_number = nslice * 1000 + n_ind1\\n pr_key = 'sl_' + str(pr_number) # build a key \\n new_sl = Simple_list(nslice) # create a simple list with z_marker = nslice, nslice is the index of the first z-slice \\n new_sl.add([nslice, zf_1[n_ind1, 4]])\\n new_sl.add([nslice+1, zf_2[n_ind2, 4]])\\n zf_1[n_ind1, 3] = pr_number # assign the new pr_number to zf_1\\n zf_2[n_ind2, 3] = pr_number # assigne the same new pr_number to zf_2\\n\\n self.redundancy_pool[pr_key] = new_sl # stored into the redundancy pool\\n\\n\\n for n_count in np.arange(n_exist):\\n # search for the existing keys\\n n_ind1 = pool_exist[n_count]\\n n_ind2 = pool_exist_cov[n_count]\\n pr_number = int(zf_1[n_ind1, 3])# catch up the pr_number\\n pr_key = 'sl_' + str(pr_number) # this pr_key should already exist in the pool. \\n\\n self.redundancy_pool[pr_key].add([nslice+1, zf_2[n_ind2, 4]])\\n zf_2[n_ind2, 3] = pr_number # update the pr_number in the adjacent slice\",\n \"def max_disp(left_img, right_img):\\n\\n # Max initial matches\\n MAX_INI_MATCH = np.inf\\n\\n # ORB detector and brute-force matcher\\n detector = cv2.ORB_create(nfeatures=100000, edgeThreshold=5)\\n matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)\\n\\n # Find the keypoints and descriptors of both images\\n keypoint_left, descriptor_left = detector.detectAndCompute(\\n image=left_img, mask=None\\n )\\n keypoint_right, descriptor_right = detector.detectAndCompute(\\n image=right_img, mask=None\\n )\\n\\n # Find the best matches\\n matches = matcher.match(\\n queryDescriptors=descriptor_left, trainDescriptors=descriptor_right\\n )\\n matches = sorted(matches, key=lambda x: x.distance)\\n\\n if DEBUG:\\n print(f\\\"Initial matches#\\\")\\n print(f\\\"match_lr: {len(matches)}\\\")\\n\\n # Match refinement with RANSAC\\n left_pts = np.float32([keypoint_left[m.queryIdx].pt for m in matches]).reshape(\\n -1, 1, 2\\n )\\n right_pts = np.float32([keypoint_right[m.trainIdx].pt for m in matches]).reshape(\\n -1, 1, 2\\n )\\n homography, mask = cv2.findHomography(left_pts, right_pts, cv2.RANSAC, 5.0)\\n matchesMask = mask.ravel().tolist()\\n\\n ransac_matches = []\\n for (m, keep) in zip(matches, matchesMask):\\n if keep:\\n ransac_matches.append(m)\\n\\n if DEBUG:\\n print(f\\\"After RANSAC:\\\")\\n print(f\\\"match: {len(ransac_matches)}\\\")\\n ransac_img = cv2.drawMatches(\\n left_img,\\n keypoint_left,\\n right_img,\\n keypoint_right,\\n ransac_matches,\\n None,\\n flags=2,\\n )\\n cv2.imwrite(\\\"./debug/RANSAC.png\\\", ransac_img)\\n\\n # Get the range of disparity\\n disp_min = np.inf\\n disp_max = 0\\n\\n for m in ransac_matches:\\n # Keypoints coordinates\\n pt_left = np.float32(keypoint_left[m.queryIdx].pt)\\n pt_right = np.float32(keypoint_right[m.trainIdx].pt)\\n\\n # Compute the distance\\n dist = int(abs(pt_left - pt_right)[0])\\n\\n if disp_max < dist:\\n disp_max = dist\\n\\n # Ceiling the number\\n disp_max += 1\\n\\n return disp_max\",\n \"def correspondence_points(img1, img2, tag='c'):\\n if len(img1.shape) == 3:\\n img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)\\n if len(img2.shape) == 3:\\n img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)\\n\\n detector = cv2.SURF(800)\\n norm = cv2.NORM_L2\\n flann_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)\\n matcher = cv2.FlannBasedMatcher(flann_params, {}) # bug : need to pass empty dict (#1329)\\n kp1, desc1 = detector.detectAndCompute(img1, None)\\n kp2, desc2 = detector.detectAndCompute(img2, None)\\n raw_matches = matcher.knnMatch(desc1, trainDescriptors = desc2, k = 2) #2\\n p1, p2, kp_pairs = filter_matches(kp1, kp2, raw_matches)\\n\\n if len(p1) >= 4:\\n H, status = cv2.findHomography(p1, p2, cv2.RANSAC, 5.0)\\n print '%d / %d inliers/matched' % (np.sum(status), len(status))\\n status = status.reshape(-1) # flatten\\n p1 = p1[status == 1]\\n p2 = p2[status == 1]\\n kp_pairs = [kp_pairs[i] for i in range(len(kp_pairs)) if status[i] == 1]\\n else:\\n # Just depend on the thresholding for filtering matches\\n p1, p2, kp_pairs = filter_matches(kp1, kp2, raw_matches, ratio=0.3)\\n\\n draw_correspondence_points(img1, img2, kp_pairs, tag=tag)\\n return p1, p2, kp_pairs\",\n \"def get_pair_rects(contours):\\n\\n rect_pairs = []\\n for index, cnt in enumerate(contours):\\n # Rotated rect - ( center (x,y), (width, height), angle of rotation )\\n rect = cv2.minAreaRect(cnt)\\n center_x, center_y = rect[0]\\n rect_angle = -round(rect[2], 2)\\n\\n if rect_angle > 45.0:\\n # Iterate through all of the potential matches\\n min_x_dist = min_rect = min_index = None\\n for pot_index, pot_match in enumerate(contours):\\n if np.array_equal(pot_match, cnt):\\n continue\\n\\n match_rect = cv2.minAreaRect(pot_match)\\n\\n # Check if match is to the right of the contour\\n if match_rect[0][0] > rect[0][0] and abs(\\n match_rect[2] - rect_angle) > ANGLE_TOLERANCE_DEG:\\n x_distance = match_rect[0][0] - rect[0][0]\\n\\n if min_x_dist is None or x_distance < min_x_dist:\\n min_x_dist = x_distance\\n min_rect = match_rect\\n min_index = pot_index\\n\\n if min_rect is not None:\\n rect_pairs.append((rect, min_rect))\\n np.delete(contours, index)\\n np.delete(contours, min_index)\\n\\n return rect_pairs\",\n \"def compareTwoReco(reference, new, histos, debug=1):\\n\\n # Tracks with index False are the ones that have been matched to the reference track collection\\n new_valid = [True for i in new]\\n\\n # Tracks with index False are the ones that have been matched to the comparison track collection\\n original_valid = [True for i in reference]\\n print \\\" \\\".join(\\\"%10s\\\" % k for k in variables)\\n debug_verbose = checkDebug(debug, 'Verbose')\\n debug_ordinary = checkDebug(debug, 'Ordinary')\\n debug_recovery = checkDebug(debug, 'Recovery')\\n debug_lost = checkDebug(debug, 'Lost')\\n debug_fake = checkDebug(debug, 'Fake')\\n\\n for original_index, original in enumerate(reference):\\n # Fill in cumulative plots for the reference sample first\\n histos['reference_hits_vs_algo'].Fill(original.algo, original.hits)\\n histos['reference_hits_vs_orialgo'].Fill(original.orialgo, original.hits)\\n histos['reference_hits_vs_pt'].Fill(original.pt, original.hits)\\n histos['den'].Fill(original.pt)\\n histos['den_eta'].Fill(original.eta)\\n histos['den_phi'].Fill(original.phi)\\n histos['den_hits'].Fill(original.hits)\\n histos['den_algo'].Fill(original.algo)\\n histos['den_orialgo'].Fill(original.orialgo)\\n\\n # Now start to look for a matching track in the comparison track collection\\n window_depth = 400 # elements to span to look for best candidate\\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = -1, 100, 100\\n if debug_verbose:\\n print original\\n for i,j in enumerate(new):\\n if new_valid[i] == True:\\n if debug_verbose:\\n print \\\" \\\", i, j\\n if window_depth == 0:\\n break\\n dr_squared, dPt_over_pt = match(original, j)\\n if dr_squared < bestDeltaRMatch*bestDeltaRMatch and dPt_over_pt < DELTA_PT_OVER_PT_CUT:\\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = i, dr_squared, dPt_over_pt\\n if debug_verbose:\\n print \\\" \\\", window_depth, iBest, bestDeltaRMatch, dr_squared, bestDeltaPt_over_PtMatch, dPt_over_pt\\n if bestDeltaRMatch <= 0.0001 or bestDeltaPt_over_PtMatch == 0.0001:\\n break\\n window_depth -= 1\\n if iBest != -1 and bestDeltaRMatch < DELTA_R_CUT:\\n # These are the tracks in the reference track collection\\n # that have been matched to a track in the comparison\\n # track collection\\n new_valid[iBest] = False\\n original_valid[original_index] = False\\n assert original.run == new[iBest].run, \\\"run mismatch\\\"\\n assert original.ls == new[iBest].ls, \\\"ls mismatch\\\"\\n assert original.event == new[iBest].event, \\\"event mismatch\\\"\\n if debug_ordinary:\\n print original\\n print new[iBest]\\n print iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch, '\\\\n'\\n histos['num'].Fill(original.pt)\\n histos['num_eta'].Fill(original.eta)\\n histos['num_phi'].Fill(original.phi)\\n histos['num_hits'].Fill(original.hits)\\n histos['num_algo'].Fill(original.algo)\\n histos['num_orialgo'].Fill(original.orialgo)\\n histos['fake_num'].Fill(new[iBest].pt)\\n histos['fake_num_eta'].Fill(new[iBest].eta)\\n histos['fake_num_phi'].Fill(new[iBest].phi)\\n histos['fake_num_hits'].Fill(new[iBest].hits)\\n histos['fake_num_algo'].Fill(new[iBest].algo)\\n histos['fake_num_orialgo'].Fill(new[iBest].orialgo)\\n histos['comparison_algo_vs_reference_algo'].Fill(original.algo, new[iBest].algo)\\n histos['comparison_orialgo_vs_reference_orialgo'].Fill(original.orialgo, new[iBest].orialgo)\\n histos['comparison_hits_vs_reference_hits'].Fill(original.hits, new[iBest].hits)\\n\\n # Let's try a recovery loop with somewhat lesser stringent cuts\\n for original_index, original in enumerate(reference):\\n if original_valid[original_index]:\\n # Now start to look for a matching track in the comparison track collection\\n window_depth = 300 # elements to span to look for best candidate\\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = -1, 100, 100\\n if debug_verbose:\\n print \\\"Recovery \\\", original\\n for i,j in enumerate(new):\\n if new_valid[i] == True:\\n if debug_verbose:\\n print \\\"Recovery \\\", i, j\\n if window_depth == 0:\\n break\\n dr_squared, dPt_over_pt = match(original, j)\\n if dr_squared < bestDeltaRMatch*bestDeltaRMatch and dPt_over_pt < DELTA_PT_OVER_PT_CUT*6:\\n iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch = i, dr_squared, dPt_over_pt\\n if debug_verbose:\\n print \\\"Recovery \\\", window_depth, iBest, bestDeltaRMatch, dr_squared, bestDeltaPt_over_PtMatch, dPt_over_pt\\n if bestDeltaRMatch <= 0.0001 or bestDeltaPt_over_PtMatch == 0.0001:\\n break\\n window_depth -= 1\\n if iBest != -1 and bestDeltaRMatch < DELTA_R_CUT*10: # inflate cut on DeltaR to recover some good-medium matching\\n # These are the tracks in the reference track collection\\n # that have been matched to a track in the comparison\\n # track collection\\n new_valid[iBest] = False\\n original_valid[original_index] = False\\n if debug_recovery:\\n print \\\"Recovery \\\", original\\n print \\\"Recovery \\\", new[iBest]\\n print \\\"Recovery \\\", iBest, bestDeltaRMatch, bestDeltaPt_over_PtMatch\\n histos['num'].Fill(original.pt)\\n histos['num_eta'].Fill(original.eta)\\n histos['num_phi'].Fill(original.phi)\\n histos['num_hits'].Fill(original.hits)\\n histos['num_algo'].Fill(original.algo)\\n histos['num_orialgo'].Fill(original.orialgo)\\n histos['fake_num'].Fill(new[iBest].pt)\\n histos['fake_num_eta'].Fill(new[iBest].eta)\\n histos['fake_num_hits'].Fill(new[iBest].hits)\\n histos['fake_num_algo'].Fill(new[iBest].algo)\\n histos['fake_num_orialgo'].Fill(new[iBest].orialgo)\\n histos['comparison_algo_vs_reference_algo'].Fill(original.algo, new[iBest].algo)\\n histos['comparison_orialgo_vs_reference_orialgo'].Fill(original.orialgo, new[iBest].orialgo)\\n histos['comparison_hits_vs_reference_hits'].Fill(original.hits, new[iBest].hits)\\n\\n\\n # These are the tracks in the reference track collection\\n # that have *not* been associated to any track in the\\n # comparison collection == > LOST TRACKS\\n reference_not_assigned = [j for i,j in enumerate(reference) if original_valid[i]]\\n reference_not_assigned.sort(key=lambda tr: tr.algo)\\n if debug_lost:\\n print \\\"**** Lost tracks **** %d\\\" % len(reference_not_assigned)\\n for j in reference_not_assigned:\\n histos['lost_hits_vs_algo'].Fill(j.algo, j.hits)\\n histos['lost_hits_vs_orialgo'].Fill(j.orialgo, j.hits)\\n histos['lost_hits_vs_pt'].Fill(j.pt, j.hits)\\n histos['lost_eta'].Fill(j.eta)\\n if debug:\\n print j\\n if debug_lost:\\n print \\\"**** End of Lost tracks ****\\\"\\n\\n # Fake Tracks\\n for i, j in enumerate(new):\\n # Fill in the cumulative plots related to tracks in the comparison track collection\\n histos['comparison_hits_vs_algo'].Fill(j.algo, j.hits)\\n histos['comparison_hits_vs_orialgo'].Fill(j.orialgo, j.hits)\\n histos['comparison_hits_vs_pt'].Fill(j.pt, j.hits)\\n histos['fake_den'].Fill(j.pt)\\n histos['fake_den_eta'].Fill(j.eta)\\n histos['fake_den_phi'].Fill(j.phi)\\n histos['fake_den_hits'].Fill(j.hits)\\n histos['fake_den_algo'].Fill(j.algo)\\n histos['fake_den_orialgo'].Fill(j.orialgo)\\n\\n # These are the tracks in the comparison track collection\\n # that have *not* been associated to any track in the\\n # reference collection ==> FAKE TRACKS\\n new_not_assigned = [j for i,j in enumerate(new) if new_valid[i]]\\n new_not_assigned.sort(key=lambda tr: tr.algo)\\n if debug_fake:\\n print \\\"**** Fake tracks **** %d\\\" % len(new_not_assigned)\\n for j in new_not_assigned:\\n histos['fake_hits_vs_algo'].Fill(j.algo, j.hits)\\n histos['fake_hits_vs_orialgo'].Fill(j.orialgo, j.hits)\\n histos['fake_hits_vs_pt'].Fill(j.pt, j.hits)\\n if debug:\\n print j\\n if debug_fake:\\n print \\\"**** End of Fake tracks ****\\\"\",\n \"def matchExplorer(win, img1, img2, kp_pairs=(), status = None, H = None, show=True, block= True, daemon=True):\\n # FIXME keypoints visualization wrong\\n # functions\\n ## GET INITIAL VISUALIZATION\\n if len(img1.shape)<3:\\n img1 = cv2.cvtColor(img1,cv2.COLOR_GRAY2BGR)\\n if len(img2.shape)<3:\\n img2 = cv2.cvtColor(img2,cv2.COLOR_GRAY2BGR)\\n\\n h1, w1 = img1.shape[:2] # obtaining image1 dimensions\\n h2, w2 = img2.shape[:2] # obtaining image2 dimensions\\n # imgf and imgb will be visualized horizontally (left-right)\\n vis = np.zeros((max(h1, h2), w1+w2,3), np.uint8) # making visualization image\\n vis[:h1, :w1] = img1 # imgf at the left of vis\\n vis[:h2, w1:w1+w2] = img2 # imgf at the right of vis\\n\\n if status is None:\\n status = np.ones(len(kp_pairs), np.bool_) # making sure every pair of keypoints is graphed\\n\\n kp_pairs = [(dict2keyPoint(i),dict2keyPoint(j)) for i,j in kp_pairs]\\n p1 = FLOAT([kpp[0].pt for kpp in kp_pairs]) # pair of coordinates for imgf\\n p2 = FLOAT([kpp[1].pt for kpp in kp_pairs]) + (w1, 0) # pair of coordinates for imgb\\n\\n if H is not None:# does the same as getTransformedCorners\\n corners = FLOAT([[0, 0], [w1, 0], [w1, h1], [0, h1]])\\n corners = np.int32(cv2.perspectiveTransform(corners.reshape(1, -1, 2), H).reshape(-1, 2) + (w1, 0))\\n\\n def drawline(self):\\n vis = self.rimg\\n self.thick = int(sigmoid(vis.shape[0] * vis.shape[1], 1723567, 8080000, 5, 1))\\n if H is not None: # enclosing object\\n rcorners = np.array([self.real2render(corner[0],corner[1]) for corner in corners],np.int32)\\n cv2.polylines(vis, [rcorners], True, self.framecolor) # draw rendered TM encasing\\n\\n rp1,rp2 = [],[]\\n for (x1, y1), (x2, y2), inlier in zip(p1, p2, status):\\n rx1,ry1 = self.real2render(x1,y1,np.int32) # real to render\\n rx2,ry2 = self.real2render(x2,y2,np.int32) # real to render\\n rp1.append((rx1,ry1))\\n rp2.append((rx2,ry2))\\n r = self.thick\\n if inlier and self.showgoods: # drawing circles (good keypoints)\\n col = self.goodcolor\\n cv2.circle(vis, (rx1, ry1), r, col, -1) # for left keypoint (imgf)\\n cv2.circle(vis, (rx2, ry2), r, col, -1) # for right keypoint (imgf)\\n elif self.showbads: # drawing x marks (wrong keypoints)\\n col = self.badcolor\\n thickness = r+5\\n # for left keypoint (imgf)\\n cv2.line(vis, (rx1-r, ry1-r), (rx1+r, ry1+r), col, thickness)\\n cv2.line(vis, (rx1-r, ry1+r), (rx1+r, ry1-r), col, thickness)\\n # for right keypoint (imgf)\\n cv2.line(vis, (rx2-r, ry2-r), (rx2+r, ry2+r), col, thickness)\\n cv2.line(vis, (rx2-r, ry2+r), (rx2+r, ry2-r), col, thickness)\\n # drawing lines for non-onmouse event\\n self.rp1 = np.int32(rp1)\\n self.rp2 = np.int32(rp2)\\n self.vis0 = vis.copy() # saving state of the visualization for onmouse event\\n # get rendered kp_pairs\\n self.kp_pairs2 = apply2kp_pairs(kp_pairs,self.real2render,self.real2render)\\n # drawing lines for non-onmouse event\\n for (rx1, ry1), (rx2, ry2), inlier in zip(rp1, rp2, status):\\n if inlier and self.showgoods:\\n cv2.line(vis, (rx1, ry1), (rx2, ry2), self.goodcolor,r)\\n self.vis = vis#.copy() # visualization with all inliers\\n\\n def drawrelation(self):\\n if self.flags & cv2.EVENT_FLAG_LBUTTON:\\n x,y = self.rx, self.ry\\n cur_vis = self.vis0.copy() # actual visualization\\n r = self.thick + 8 # proximity to keypoint\\n m = (anorm(self.rp1 - (x, y)) < r) | (anorm(self.rp2 - (x, y)) < r)\\n idxs = np.where(m)[0] # get indexes near pointer\\n kp1s, kp2s = [], []\\n for i in idxs: # for all keypints near pointer\\n (rx1, ry1), (rx2, ry2) = self.rp1[i], self.rp2[i] # my keypoint\\n col = (self.badcolor, self.goodcolor)[status[i]] # choosing False=red,True=green\\n cv2.line(cur_vis, (rx1,ry1), (rx2,ry2), col, self.thick) # drawing line\\n # keypoints to show on event\\n kp1, kp2 = self.kp_pairs2[i]\\n kp1s.append(kp1)\\n kp2s.append(kp2)\\n # drawing keypoints near pointer for imgf and imgb\\n cur_vis = cv2.drawKeypoints(cur_vis, kp1s, flags=4, color=self.kpcolor)\\n cur_vis = cv2.drawKeypoints(cur_vis, kp2s, flags=4, color=self.kpcolor)\\n self.rimg = cur_vis\\n else:\\n self.rimg = self.vis\\n\\n if self.y is not None and self.x is not None:\\n self.builtinplot(self.sample[self.y,self.x])\\n\\n def randomColor():\\n return (np.random.randint(0,255), np.random.randint(0,255), np.random.randint(0,255))\\n\\n def mousefunc(self):\\n if self.builtincontrol():\\n self.updaterenderer()\\n drawline(self)\\n\\n drawrelation(self)\\n\\n def keyfunc(self):\\n if self.builtincmd():\\n drawline(self)\\n drawrelation(self)\\n if self.y is not None and self.x is not None:\\n self.builtinplot(self.img[self.y,self.x])\\n else:\\n self.builtinplot()\\n\\n self = plotim(win, vis)\\n self.mousefunc = mousefunc\\n self.keyfunc = keyfunc\\n self.showgoods = True\\n self.showbads = False\\n from image import colors\\n self.__dict__.update(colors)\\n self.randomColor = randomColor\\n self.goodcolor = self.green\\n self.badcolor = self.red\\n self.kpcolor = self.orange\\n self.framecolor = self.blue\\n self.cmdlist.extend([\\\"showgoods\\\",\\\"showbads\\\",\\\"framecolor\\\",\\\"kpcolor\\\",\\\"badcolor\\\",\\\"goodcolor\\\"])\\n drawline(self)\\n # show window\\n if show: self.show(block= block, daemon=daemon)\\n return self #self.rimg # return coordinates\",\n \"def matchShapesImages(img1, img2):\\n\\tcnt1 = findContours(img1)[0]\\n\\tcnt2 = findContours(img2)[0]\\n\\tret = cv2.matchShapes(cnt1, cnt2, 1, 0.0)\\n\\treturn ret\",\n \"def intersect(A,B,C,D):\\n def ccw(A,B,C):\\n return (C[iY]-A[iY]) * (B[iX]-A[iX]) > (B[iY]-A[iY]) * (C[iX]-A[iX])\\n return ccw(A,C,D) != ccw(B,C,D) and ccw(A,B,C) != ccw(A,B,D)\",\n \"def bins_match (a, b):\\n return 0 == (\\n np.sum ((a.xbins - b.xbins)**2)\\n + np.sum ((a.ybins - b.ybins)**2) )\",\n \"def find_contours(dframe):\\n #Blur the image.\\n blurred = cv2.GaussianBlur(dframe, (11,11), 0)\\n #if debug:\\n #plt.imshow(fixColor(blurred))\\n #plt.show()\\n #Get a threshold image, numbers where tested for the given video.\\n ret, tframe= cv2.threshold(blurred,50,255,cv2.THRESH_BINARY)\\n (cnts, _) = cv2.findContours(tframe.copy(), cv2.RETR_EXTERNAL, \\n cv2.CHAIN_APPROX_SIMPLE)\\n return cnts\",\n \"def create_non_correspondences(uv_b_matches, img_b_shape, num_non_matches_per_match=100, img_b_mask=None):\\n image_width = img_b_shape[1]\\n image_height = img_b_shape[0]\\n # print(\\\"uv_b_matches: \\\", uv_b_matches)\\n if uv_b_matches == None:\\n return None\\n\\n num_matches = len(uv_b_matches[0])\\n\\n def get_random_uv_b_non_matches():\\n return pytorch_rand_select_pixel(width=image_width,height=image_height, \\n num_samples=num_matches*num_non_matches_per_match)\\n\\n if img_b_mask is not None:\\n img_b_mask_flat = img_b_mask.view(-1,1).squeeze(1)\\n mask_b_indices_flat = torch.nonzero(img_b_mask_flat)\\n if len(mask_b_indices_flat) == 0:\\n print(\\\"warning, empty mask b\\\")\\n uv_b_non_matches = get_random_uv_b_non_matches()\\n else:\\n num_samples = num_matches*num_non_matches_per_match\\n rand_numbers_b = torch.rand(num_samples)*len(mask_b_indices_flat)\\n rand_indices_b = torch.floor(rand_numbers_b).long()\\n randomized_mask_b_indices_flat = torch.index_select(mask_b_indices_flat, 0, rand_indices_b).squeeze(1)\\n uv_b_non_matches = (randomized_mask_b_indices_flat%image_width, randomized_mask_b_indices_flat/image_width)\\n else:\\n uv_b_non_matches = get_random_uv_b_non_matches()\\n \\n # for each in uv_a, we want non-matches\\n # first just randomly sample \\\"non_matches\\\"\\n # we will later move random samples that were too close to being matches\\n uv_b_non_matches = (uv_b_non_matches[0].view(num_matches,num_non_matches_per_match), uv_b_non_matches[1].view(num_matches,num_non_matches_per_match))\\n\\n # uv_b_matches can now be used to make sure no \\\"non_matches\\\" are too close\\n # to preserve tensor size, rather than pruning, we can perturb these in pixel space\\n copied_uv_b_matches_0 = torch.t(uv_b_matches[0].repeat(num_non_matches_per_match, 1))\\n copied_uv_b_matches_1 = torch.t(uv_b_matches[1].repeat(num_non_matches_per_match, 1))\\n\\n diffs_0 = copied_uv_b_matches_0 - uv_b_non_matches[0].type(dtype_float)\\n diffs_1 = copied_uv_b_matches_1 - uv_b_non_matches[1].type(dtype_float)\\n\\n diffs_0_flattened = diffs_0.contiguous().view(-1,1)\\n diffs_1_flattened = diffs_1.contiguous().view(-1,1)\\n\\n diffs_0_flattened = torch.abs(diffs_0_flattened).squeeze(1)\\n diffs_1_flattened = torch.abs(diffs_1_flattened).squeeze(1)\\n\\n\\n need_to_be_perturbed = torch.zeros_like(diffs_0_flattened)\\n ones = torch.zeros_like(diffs_0_flattened)\\n num_pixels_too_close = 1.0\\n threshold = torch.ones_like(diffs_0_flattened)*num_pixels_too_close\\n\\n # determine which pixels are too close to being matches\\n need_to_be_perturbed = where(diffs_0_flattened < threshold, ones, need_to_be_perturbed)\\n need_to_be_perturbed = where(diffs_1_flattened < threshold, ones, need_to_be_perturbed)\\n\\n minimal_perturb = num_pixels_too_close/2\\n minimal_perturb_vector = (torch.rand(len(need_to_be_perturbed))*2).floor()*(minimal_perturb*2)-minimal_perturb\\n std_dev = 10\\n random_vector = torch.randn(len(need_to_be_perturbed))*std_dev + minimal_perturb_vector\\n perturb_vector = need_to_be_perturbed*random_vector\\n\\n uv_b_non_matches_0_flat = uv_b_non_matches[0].view(-1,1).type(dtype_float).squeeze(1)\\n uv_b_non_matches_1_flat = uv_b_non_matches[1].view(-1,1).type(dtype_float).squeeze(1)\\n\\n uv_b_non_matches_0_flat = uv_b_non_matches_0_flat + perturb_vector\\n uv_b_non_matches_1_flat = uv_b_non_matches_1_flat + perturb_vector\\n\\n # now just need to wrap around any that went out of bounds\\n\\n # handle wrapping in width\\n lower_bound = 0.0\\n upper_bound = image_width*1.0 - 1\\n lower_bound_vec = torch.ones_like(uv_b_non_matches_0_flat) * lower_bound\\n upper_bound_vec = torch.ones_like(uv_b_non_matches_0_flat) * upper_bound\\n\\n uv_b_non_matches_0_flat = where(uv_b_non_matches_0_flat > upper_bound_vec, \\n uv_b_non_matches_0_flat - upper_bound_vec, \\n uv_b_non_matches_0_flat)\\n\\n uv_b_non_matches_0_flat = where(uv_b_non_matches_0_flat < lower_bound_vec, \\n uv_b_non_matches_0_flat + upper_bound_vec, \\n uv_b_non_matches_0_flat)\\n\\n # handle wrapping in height\\n lower_bound = 0.0\\n upper_bound = image_height*1.0 - 1\\n lower_bound_vec = torch.ones_like(uv_b_non_matches_1_flat) * lower_bound\\n upper_bound_vec = torch.ones_like(uv_b_non_matches_1_flat) * upper_bound\\n\\n uv_b_non_matches_1_flat = where(uv_b_non_matches_1_flat > upper_bound_vec, \\n uv_b_non_matches_1_flat - upper_bound_vec, \\n uv_b_non_matches_1_flat)\\n\\n uv_b_non_matches_1_flat = where(uv_b_non_matches_1_flat < lower_bound_vec, \\n uv_b_non_matches_1_flat + upper_bound_vec, \\n uv_b_non_matches_1_flat)\\n\\n return (uv_b_non_matches_0_flat.view(num_matches, num_non_matches_per_match),\\n uv_b_non_matches_1_flat.view(num_matches, num_non_matches_per_match))\",\n \"def find_inplane_to_match(phiA,thetaA,phiB,thetaB,psiA=0,psiB=0):\\n\\t#from math import pi, sqrt, cos, acos, sin\\n\\n\\tRA = Transform({'type': 'spider', 'phi': phiA, 'theta': thetaA, 'psi': psiA})\\n\\tRB = Transform({'type': 'spider', 'phi': phiB, 'theta': thetaB, 'psi': psiB})\\n\\tRBT = RB.transpose()\\n\\tRABT = RA * RBT\\n\\n\\tRABTeuler = RABT.get_rotation('spider')\\n\\tRABTphi = RABTeuler['phi']\\n\\tRABTtheta = RABTeuler['theta']\\n\\tRABTpsi = RABTeuler['psi']\\n\\n\\t#deg_to_rad = pi/180.0\\n\\t#thetaAR = thetaA*deg_to_rad\\n\\t#thetaBR = thetaB*deg_to_rad\\n\\t#phiAR = phiA*deg_to_rad\\n\\t#phiBR = phiB *deg_to_rad\\n\\n\\t#d12=cos(thetaAR)*cos(thetaBR) + sin(thetaAR)*sin(thetaBR)*cos(phiAR-phiBR)\\n\\treturn (-RABTpsi-RABTphi),RABTtheta # 180.0*acos(d12)/pi;\",\n \"def recognize_pieces(edges, v, squares):\\n\\n pieces = []\\n\\n v = cv2.equalizeHist(v)\\n for p1, p2 in squares:\\n # count the number of slightly centered edges\\n occupancy = sum(edges[y][x]\\n for x in range(p1.x + 5, p2.x - 5)\\n for y in range(p1.y + 5, p2.y - 5))\\n\\n if occupancy > 70*255:\\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\\n v[p2.y][p1.x], v[p2.y][p2.x])\\n\\n # average v-component of the corners\\n avg = sum(map(float, corners)) / len(corners)\\n\\n # black pixels should be relatively black\\n # when compared to the corner average\\n black = sum(v[y][x] / avg < 0.2\\n for x in range(p1.x, p2.x + 1)\\n for y in range(p1.y, p2.y + 1))\\n\\n if black >= 1000 and black != 1049:\\n color = \\\"B\\\"\\n else:\\n color = \\\"W\\\"\\n\\n pieces.append(color)\\n else:\\n pieces.append(None)\\n\\n return pieces\",\n \"def intersect(A,B,C,D):\\n i = ccw(A,C,D) != ccw(B,C,D) and ccw(A,B,C) != ccw(A,B,D)\\n #if i:\\n # canvas.polyline( [ A,B ], style=4 , tags = (\\\"debug\\\"))\\n # canvas.polyline( [ C,D ], style=4 , tags = (\\\"debug\\\"))\\n #else:\\n # canvas.polyline( [ A,B ], style=1 , tags = (\\\"debug\\\")) # green\\n # canvas.polyline( [ C,D ], style=1 , tags = (\\\"debug\\\"))\\n return i\",\n \"def find_targets(contours, frame):\\n # If there aren't any contours present, return frame without drawing\\n if len(contours) == 0:\\n return frame\\n # Copy frame, TODO why do we need to do this?\\n image = frame.copy()\\n screen_height, screen_width, _ = image.shape;\\n # TODO: Why subtract?\\n center_x = screen_width / 2 - .5\\n center_y = screen_height / 2 - .5\\n # List for storing found targets\\n targets = []\\n\\n if len(contours) >= 2:\\n # Sort contours in descending order by size\\n contours.sort(key=lambda contour: cv2.contourArea(contour), reverse=True)\\n\\n valid_contours = []\\n for contour in contours:\\n # Calculate areas of contour\\n contour_area = cv2.contourArea(contour)\\n if contour_area >= MIN_CONTOUR_SIZE:\\n # Get moments of contour for centroid calculations\\n moments = cv2.moments(contour)\\n # Find centroid of contour\\n if moments[\\\"m00\\\"] != 0:\\n cx = int(moments[\\\"m10\\\"] / moments[\\\"m00\\\"])\\n cy = int(moments[\\\"m01\\\"] / moments[\\\"m00\\\"])\\n else:\\n cx, cy = 0, 0\\n\\n ### CALCULATE CONTOUR ROTATION BY FITTING ELLIPSE ###\\n rotation = get_ellipse_rotation(image, contour)\\n\\n ### DRAW CONTOUR ###\\n # Draw white circle at center of contour\\n cv2.circle(image, (cx, cy), 6, (255, 255, 255))\\n\\n # Draw contour in green\\n cv2.drawContours(image, [contour], 0, (0, 200, 0), 1)\\n\\n # Append important info to array\\n valid_contours.append({\\\"cx\\\": cx, \\\"cy\\\": cy, \\\"rotation\\\": rotation})\\n\\n # Sort array based on coordinates (left to right) to make sure contours are adjacent\\n valid_contours.sort(key=lambda contour: contour[\\\"cx\\\"])\\n\\n # Find targets from contours\\n for i in range(len(valid_contours) - 1):\\n # Check rotation of adjacent contours\\n tilt_left = valid_contours[i][\\\"rotation\\\"]\\n tilt_right = valid_contours[i + 1][\\\"rotation\\\"]\\n\\n # Contour coordinates\\n cx_left = valid_contours[i][\\\"cx\\\"]\\n cx_right = valid_contours[i + 1][\\\"cx\\\"]\\n cy_left = valid_contours[i][\\\"cy\\\"]\\n cy_right = valid_contours[i + 1][\\\"cy\\\"]\\n\\n # If contour angles are opposite\\n # Negative tilt -> Rotated to the right\\n # NOTE: if using rotated rect (min area rectangle), negative tilt means rotated to left\\n # If left contour rotation is tilted to the left then skip iteration\\n # If right contour rotation is tilted to the right then skip iteration\\n if (len(valid_contours) == 2) or (np.sign(tilt_left) != np.sign(tilt_right) and\\n not (tilt_left > 0 and cx_left < cx_right or tilt_right > 0 and cx_right < cx_left)):\\n\\n target_cx = (cx_left + cx_right) / 2\\n target_cy = (cy_left + cy_right) / 2\\n\\n target_yaw = calculate_yaw(target_cx, center_x)\\n target_pitch = calculate_pitch(target_cy, center_y)\\n\\n targets.append({\\\"cx\\\": target_cx,\\n \\\"cy\\\": target_cy,\\n \\\"yaw\\\": target_yaw,\\n \\\"pitch\\\": target_pitch})\\n\\n # Check if there are targets seen\\n if len(targets) > 0:\\n # Get target with smallest yaw\\n nearest_target = min(targets, key=lambda target: math.fabs(target[\\\"yaw\\\"]))\\n # Write yaw of target in corner of image\\n cv2.putText(image, \\\"Yaw: %.3f\\\" % nearest_target[\\\"yaw\\\"], (1, 12), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255))\\n # Draw line at center of target\\n cv2.line(image, (int(nearest_target[\\\"cx\\\"]), screen_height), (int(nearest_target[\\\"cx\\\"]), 0), (255, 0, 0), 1)\\n # Draw line at center of screen\\n cv2.line(image, (round(center_x), screen_height), (round(center_x), 0), (255, 255, 255), 1)\\n\\n # Send our final data to NetworkTables\\n table.putBoolean(\\\"target_present\\\", True)\\n table.putNumber(\\\"targets_seen\\\", len(targets))\\n table.putNumber(\\\"target_yaw\\\", nearest_target[\\\"yaw\\\"])\\n table.putNumber(\\\"target_pitch\\\", nearest_target[\\\"pitch\\\"])\\n else:\\n table.putBoolean(\\\"target_present\\\", False)\\n table.putNumber(\\\"targets_seen\\\", 0)\\n table.putNumber(\\\"target_yaw\\\", 0)\\n table.putNumber(\\\"target_pitch\\\", 0)\\n table.putNumber(\\\"target_distance\\\", 0)\\n\\n return image\",\n \"def draw_matches(img1, kp1, img2, kp2, matches, inliers, ignore_indexes, filter_by_dist=True, color=None):\\n # We're drawing them side by side. Get dimensions accordingly.\\n # Handle both color and grayscale images.\\n\\n\\n\\n img1 = cv2.cvtColor(img1, cv2.COLOR_GRAY2RGB)\\n img2 = cv2.cvtColor(img2, cv2.COLOR_GRAY2RGB)\\n if len(img1.shape) == 3:\\n new_shape = (img1.shape[0] + img2.shape[0], max(img1.shape[1], img2.shape[1]), img1.shape[2])\\n elif len(img1.shape) == 2:\\n new_shape = (img1.shape[0] + img2.shape[0], max(img1.shape[1], img2.shape[1]))\\n new_img = np.zeros(new_shape, type(img1.flat[0])) \\n # Place images onto the new image.\\n new_img[0:img1.shape[0],0:img1.shape[1]] = img1\\n new_img[img1.shape[0]:img1.shape[0]+img2.shape[0],0:img1.shape[1]] = img2\\n \\n # Draw lines between matches. Make sure to offset kp coords in second image appropriately.\\n r = 1\\n thickness = 1\\n if color:\\n c = color\\n\\n # print(new_img.shape)\\n distances = []\\n for m in matches:\\n distances.append(m.distance)\\n \\n dist_threshold = min(distances) * 2\\n # print(dist_threshold)\\n \\n for i, m in enumerate(matches):\\n if inliers:\\n if not i in inliers:\\n continue\\n if ignore_indexes:\\n if i in ignore_indexes:\\n continue\\n if filter_by_dist:\\n if m.distance > 50:\\n continue\\n \\n # Generate random color for RGB/BGR and grayscale images as needed.\\n if not color: \\n c = tuple(np.random.randint(0,256,3)) if len(img1.shape) == 3 else np.random.randint(0,256)\\n c = ( int (c [ 0 ]), int (c [ 1 ]), int (c [ 2 ])) \\n \\n # So the keypoint locs are stored as a tuple of floats. cv2.line(), like most other things,\\n # wants locs as a tuple of ints.\\n\\n try:\\n end1 = tuple(np.round(kp1[m.queryIdx].pt).astype(int))\\n end2 = tuple(np.round(kp2[m.trainIdx].pt).astype(int) + np.array([ 0, img1.shape[0]]))\\n cv2.line(new_img, end1, end2, c, thickness)\\n cv2.circle(new_img, end1, r, c, thickness)\\n cv2.circle(new_img, end2, r, c, thickness)\\n except:\\n continue\\n \\n\\n return new_img\",\n \"def intersects_segment(A, B, X):\\n \\n AX = np.array([X.x - A.x, X.y - A.y])\\n XB = np.array([B.x - X.x, B.y - X.y])\\n equal_signs = np.array_equal(np.sign(AX), np.sign(XB))\\n\\n return equal_signs\",\n \"def test_compute_cbca_subpixel(self):\\n stereo_matcher = stereo.AbstractStereo(**{'stereo_method': 'sad', 'window_size': 1, 'subpix': 2})\\n sad = stereo_matcher.compute_cost_volume(img_ref=self.ref, img_sec=self.sec, disp_min=-1, disp_max=1,\\n **{'valid_pixels': 0, 'no_data': 1})\\n\\n # Computes the cost aggregation with the cross-based cost aggregation method,\\n # with cbca_intensity=5 and cbca_distance=3\\n cbca_obj = aggregation.AbstractAggregation(**{'aggregation_method': 'cbca',\\n 'cbca_intensity': 5., 'cbca_distance': 3})\\n\\n cv_aggreg = cbca_obj.cost_volume_aggregation(self.ref, self.sec, sad)\\n\\n # Aggregate cost volume ground truth with the cross-based cost aggregation method for the stereo image\\n aggregated_ground_truth = np.array([[[np.nan, np.nan, 36./6, 25./7, 0.],\\n [36./6, 46./7, 66./9, 38.5/12, 0.],\\n [55./9, 64.5/12, 74./12, 32.5/10, 0.],\\n [55./9, 59.5/10, 52./9, 31.5/9, 0.],\\n [41./6, 43.5/9, 52./9, np.nan, np.nan]],\\n\\n [[np.nan, np.nan, 36./6, 25./7, 0.],\\n [36./6, 46./7, 66./9, 38.5/12, 0.],\\n [55./9, 64.5/12, 74./12, 32.5/10, 0.],\\n [55./9, 59.5/10, 52./9, 31.5/9, 0.],\\n [41./6, 43.5/9, 52./9, np.nan, np.nan]],\\n\\n [[np.nan, np.nan, 36./6, 25./7, 0.],\\n [36./6, 46./7, 66./9, 38.5/12, 0.],\\n [55./9, 64.5/12, 74./12, 32.5/10, 0.],\\n [55./9, 59.5/10, 52./9, 31.5/9, 0.],\\n [41./6, 43.5/9, 52./9, np.nan, np.nan]]])\\n\\n # Check if the calculated standard deviation is equal ( to desired tolerance 1e-07 ) to the ground truth\\n np.testing.assert_allclose(cv_aggreg['cost_volume'].data, aggregated_ground_truth, rtol=1e-07)\",\n \"def find_homography(kp1, kp2, goodmatches):\\n src_pts = np.float32([kp1[m.trainIdx].pt for m in goodmatches]).reshape(-1, 1, 2)\\n dst_pts = np.float32([kp2[m.trainIdx].pt for m in goodmatches]).reshape(-1, 1, 2)\\n M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)\\n matchesMask = mask.ravel().tolist()\\n return M, matchesMask\",\n \"def get_matches(jig_sol, blocks_roi):\\n\\n match_data = {}\\n height, width,= jig_sol.shape\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n\\n #identify the puzzle peice number based on the peice block position in solution image\\n identity = {\\n (1, 1): 1,\\n (2, 1): 2,\\n (3, 1): 3,\\n (1, 2): 4,\\n (2, 2): 5,\\n (3, 2): 6,\\n (1, 3): 7,\\n (2, 3): 8,\\n (3, 3): 9,\\n }\\n\\n #iterate through the blocks roi\\n for i in blocks_roi.keys():\\n blk = blocks_roi[i].copy()\\n blk = cv2.cvtColor(blk,cv2.COLOR_BGR2GRAY)\\n max_list = []\\n\\n #for eack blk rotate is by 90 degrees and try template matching\\n for k in range(0,360,90):\\n #cv2.resize(blk,(int(width/3),int(height/3)), interpolation= cv2.INTER_CUBIC)\\n blk_copy = imutils.rotate_bound(blk, -k)\\n\\n #get the resulting heat map of template matching\\n result = cv2.matchTemplate(jig_sol,blk_copy,cv2.TM_CCOEFF_NORMED)\\n\\n #get the max value and its location in the heat map\\n _, max_val, _, max_loc = cv2.minMaxLoc(result)\\n\\n #append a tuple consisting of max location, value and peice rotation to max_list\\n max_list.append((max_loc, max_val, k))#((k+1)*90)%360))\\n\\n #find the location with maximum value of template matching regardless of peice rotation\\n top_left = max(max_list, key=lambda x: x[1])[0]\\n\\n #get the peice rotation of that template matching\\n rot = max(max_list, key=lambda x: x[1])[2]\\n\\n #calculate the bottom right cordinates of the block\\n bottom_right = (top_left[0] + int(width/3), top_left[1] + int(height/3))\\n\\n #find the center of the block\\n centx = 0\\n centy = 0\\n for (l,m) in [top_left, bottom_right]:\\n centx += l\\n centy += m\\n centx = int(centx/2)\\n centy = int(centy/2)\\n\\n #get the puzzle peice block position in solution image\\n piece = (math.ceil(3*centx/width), math.ceil(3*centy/height))\\n\\n if piece not in identity.keys():\\n continue\\n\\n match_data.update({i: (identity[piece], rot)})\\n\\n return match_data\",\n \"def sub(input_a, input_b):\\n sub_comp = input_b.duplicate()\\n\\n ImageBufAlgo.sub(sub_comp, input_a, input_b)\\n\\n if sub_comp.has_error:\\n print \\\"Error merging subtracting:\\\", sub_comp.geterror()\\n\\n return sub_comp\",\n \"def matchsize(A, B):\\n wA, hA = cv.GetSize(A)\\n wB, hB = cv.GetSize(B)\\n if wA == wB and hA == hB:\\n return A\\n SetImageROI = cv.SetImageROI\\n out = cv.CreateImage((wB, hB), A.depth, A.channels)\\n wOut, hOut = cv.GetSize(out)\\n if wA < wOut and hA < hOut:\\n SetImageROI(out, (0, 0, wA, hA))\\n elif wA >= wOut and hA < hOut:\\n SetImageROI(out, (0, 0, wOut, hA))\\n SetImageROI(A, (0, 0, wOut, hA))\\n elif wA < wOut and hA >= hOut:\\n SetImageROI(out, (0, 0, wA, hOut))\\n SetImageROI(A, (0, 0, wA, hOut))\\n else: # wA >= wOut and hA >= hOut:\\n SetImageROI(A, (0, 0, wOut, hOut))\\n cv.Copy(A, out)\\n cv.ResetImageROI(out)\\n cv.ResetImageROI(A)\\n return out\",\n \"def create_masks(img_path, frame_num):\\n #import the images\\n key_frame = cv2.imread(img_path + \\\"_\\\" + str(frame_num) + \\\".png\\\")\\n beam_mask = filter_beam(key_frame)\\n key_frame = cv2.cvtColor(cv2.bitwise_and(beam_mask,key_frame), cv2.COLOR_BGR2GRAY)\\n cv2.imwrite(img_path + \\\"_\\\" + str(frame_num) + \\\"_beamed.png\\\",key_frame)\\n key_frame = change_contrast(key_frame, 4.0)\\n\\n #key_mask = cv2.imread(img_path + \\\"_mask_\\\" + str(frame_num) + \\\".png\\\",0)\\n #masked_key = cv2.bitwise_and(key_frame,key_mask)\\n new_frame = cv2.imread(img_path + \\\"_\\\" + str(frame_num + 1) + \\\".png\\\")\\n new_frame = cv2.cvtColor(cv2.bitwise_and(beam_mask,new_frame), cv2.COLOR_BGR2GRAY)\\n new_frame = change_contrast(new_frame, 4.0)\\n\\n #trying with a couple methods here:\\n #SIFT method\\n sift = cv2.SIFT_create()\\n keypoints_1, descriptors_1 = sift.detectAndCompute(key_frame,None)\\n keypoints_2, descriptors_2 = sift.detectAndCompute(new_frame,None)\\n bf = cv2.BFMatcher(cv2.NORM_L1, crossCheck=True)\\n\\n matches = bf.match(descriptors_1,descriptors_2)\\n matches = sorted(matches, key = lambda x:x.distance)\\n for x in keypoints_1:\\n print(x.pt)\\n\\n img3 = cv2.drawMatches(key_frame, keypoints_1, new_frame, keypoints_2, matches, new_frame, flags=2)\\n cv2.imshow(\\\"matched\\\",img3)\\n cv2.waitKey(0)\\n\\n #use the SIFT paradigm but do it semi-manually\\n\\n #active contouring method\",\n \"def test_compare_confs(self):\\n ch4_1 = {'symbols': ('C', 'H', 'H', 'H', 'H'),\\n 'isotopes': (12, 1, 1, 1, 1),\\n 'coords': ((0.0, 0.0, 0.0),\\n (0.6300326, 0.6300326, 0.6300326),\\n (-0.6300326, -0.6300326, 0.6300326),\\n (-0.6300326, 0.6300326, -0.6300326),\\n (0.6300326, -0.6300326, -0.6300326))}\\n self.assertTrue(converter.compare_confs(ch4_1, ch4_1))\\n self.assertEqual(converter.compare_confs(ch4_1, ch4_1, rmsd_score=True), 0.0)\\n\\n ch4_2 = {'symbols': ('C', 'H', 'H', 'H', 'H'),\\n 'isotopes': (12, 1, 1, 1, 1),\\n 'coords': ((0.0, 0.0, 0.0),\\n (0.630032999999999999, 0.6300326, 0.6300326),\\n (-0.6300326, -0.6300326, 0.6300326),\\n (-0.6300326, 0.6300326, -0.6300326),\\n (0.6300326, -0.6300326, -0.6300326))}\\n self.assertTrue(converter.compare_confs(ch4_1, ch4_2))\\n self.assertAlmostEqual(converter.compare_confs(ch4_1, ch4_2, rmsd_score=True), 0.0, places=4)\\n\\n ch4_3 = {'symbols': ('C', 'H', 'H', 'H', 'H'),\\n 'isotopes': (12, 1, 1, 1, 1),\\n 'coords': ((0.0, 0.0, 0.0),\\n (0.81, 0.6300326, 0.6300326),\\n (-0.6300326, -0.6300326, 0.6300326),\\n (-0.6300326, 0.6300326, -0.6300326),\\n (0.6300326, -0.6300326, -0.6300326))}\\n self.assertFalse(converter.compare_confs(ch4_1, ch4_3))\\n self.assertAlmostEqual(converter.compare_confs(ch4_1, ch4_3, rmsd_score=True), 0.0973755, 5)\\n\\n occco_1 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\\n 'coords': ((-1.645138856907744, 0.4855258453193825, -1.269098295435587),\\n (-1.826155038047953, 0.3950495294463964, 0.14042133077839267),\\n (-1.809422000751755, 1.7890058616007063, 0.7598491740499427),\\n (-0.5144047765537177, 2.5412406931938802, 0.46679697338621373),\\n (-0.4166415293412751, 2.87702090326361, -0.9112962716273996),\\n (-1.7523716337780308, -0.4153106947877299, -1.6252584016046343),\\n (-2.785951955397608, -0.09251469392615361, 0.33828359656775064),\\n (-1.0240452528998532, -0.22437445960667116, 0.5540970106165476),\\n (-2.6481280678220354, 2.3642983699082096, 0.34958017984053996),\\n (-1.948589699885299, 1.7026595551213293, 1.842711580226941),\\n (0.3611954633790452, 1.9455154222553817, 0.7436960027091665),\\n (-0.4846097814890448, 3.4746190180148613, 1.0370826136306412),\\n (-0.7517118479102434, 2.0995465744609016, -1.4084474547843668))}\\n self.assertTrue(converter.compare_confs(occco_1, occco_1))\\n self.assertEqual(converter.compare_confs(occco_1, occco_1, rmsd_score=True), 0.0)\\n\\n occco_2 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\\n 'coords': ((-1.7947360038254172, -0.2800502342395655, -0.94718691702442),\\n (-1.3484923712374388, 0.3115024061252556, 0.26578718691263836),\\n (0.048477626636679344, -0.18145884392561823, 0.6324014558703148),\\n (0.06768533157823732, -1.6675011458530478, 0.9732242593946415),\\n (-0.3530408338556874, -2.4414941005488964, -0.14539995931042984),\\n (-1.6993365552401258, -1.24904809118412, -0.8336640895923935),\\n (-1.3364382254722125, 1.3960688766201377, 0.12095890535651209),\\n (-2.0720954664081472, 0.08255875951942339, 1.0547463625584224),\\n (0.7166058894071794, -0.006871191098481536, -0.21939247767770087),\\n (0.42416153066953804, 0.38997256785153595, 1.4878132135000073),\\n (-0.6073710844027356, -1.8828156181698352, 1.8073934203380306),\\n (1.0743805139106757, -1.9882575918786236, 1.2595102280098387),\\n (0.35195568839394714, -2.3791987519096245, -0.81652943836054))}\\n self.assertFalse(converter.compare_confs(occco_1, occco_2))\\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_2, rmsd_score=True), 1.00940798, 5)\\n\\n occco_3 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\\n 'coords': ((-2.1449415573976087, 0.22095421320805855, -1.1761667487081628),\\n (-1.8458576972054956, 0.34850267283416353, 0.21018774322610537),\\n (-1.7946333596155588, 1.8224048429109774, 0.6001541290065803),\\n (-0.7643941488427433, 2.603963636650936, -0.21014179435545444),\\n (-1.160550573561837, 2.7172772321690157, -1.5709018700345496),\\n (-2.2541573481252226, -0.7309807530987936, -1.3543442072197793),\\n (-2.624019853257233, -0.1650323593077789, 0.7836186270202112),\\n (-0.885183881101036, -0.13905038811734782, 0.4040751763466029),\\n (-2.7832838991835382, 2.2645645737400506, 0.427600829327477),\\n (-1.562954529947271, 1.9038127448704014, 1.6674459390753227),\\n (0.21794991835079414, 2.1225495495404854, -0.17169963700580776),\\n (-0.6621011473071822, 3.6174144955483376, 0.18956005497753062),\\n (-1.544021016988015, 1.848253867499642, -1.8191893347265315))}\\n self.assertTrue(converter.compare_confs(occco_1, occco_3))\\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_3, rmsd_score=True), 0.0, places=4)\\n\\n occco_4 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\\n 'coords': ((-2.149273800177333, 0.3878561319363274, -1.067994536622897),\\n (-1.8905197406541119, 0.16731522843849514, 0.3147948930907352),\\n (-2.2871289950009728, 1.398560959638718, 1.1233863494505283),\\n (-1.5514369216953363, 2.6559008371480006, 0.6687883285931627),\\n (-1.97578532983754, 3.0584350426221696, -0.6271056229665328),\\n (-1.9649535743321451, -0.45216201833697967, -1.5265252922322194),\\n (-2.469954748031858, -0.7010050003658949, 0.6439649209501082),\\n (-0.8252433635746496, -0.052453567250684806, 0.43760424203717113),\\n (-3.36502756891988, 1.5624906595612045, 1.0051865026931144),\\n (-2.0814509723064316, 1.2139856682154606, 2.18312358675434),\\n (-0.4688204416342118, 2.495542838358611, 0.6472342384223745),\\n (-1.759053255113454, 3.4819317812208626, 1.3557210162758644),\\n (-2.0785703072969466, 2.2346795710060765, -1.151280970188824))}\\n self.assertTrue(converter.compare_confs(occco_1, occco_4))\\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_4, rmsd_score=True), 0.0, places=4)\\n\\n occco_5 = {'symbols': ('O', 'C', 'C', 'C', 'O', 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'),\\n 'isotopes': (16, 12, 12, 12, 16, 1, 1, 1, 1, 1, 1, 1, 1),\\n 'coords': (\\n (-2.4583263702786398, 0.0718285271168676, -1.073208642860504),\\n (-1.937015981064579, 0.0890930305098165, 0.25179580507902494),\\n (-2.348398726927575, 1.376978495961958, 0.9583384372437844),\\n (-1.8770165015484177, 2.6245423907540975, 0.21659228399276115),\\n (-2.569162634647042, 2.781228761671768, -1.015409941988472),\\n (-2.2457141392131477, -0.8022675472463131, -1.4481857725877),\\n (-2.3295554159352525, -0.7779156570908263, 0.792431073403323),\\n (-0.8469088168553344, 0.006439213644634347, 0.19675913068823528),\\n (-3.4425715658912557, 1.4040720104173179, 1.0273387203822888),\\n (-1.939605978646692, 1.375711847707625, 1.9743606178959265),\\n (-0.8029097001610058, 2.5806396078360736, 0.010183430117069694),\\n (-2.07095189274604, 3.516416462694289, 0.8201309204066712),\\n (-2.650256378769789, 1.8823222470150054, -1.4017891959903757))}\\n self.assertTrue(converter.compare_confs(occco_1, occco_5))\\n self.assertAlmostEqual(converter.compare_confs(occco_1, occco_5, rmsd_score=True), 0.0, places=4)\",\n \"def find_optimal_components_subset(contours, edges):\\n c_info = props_for_contours(contours, edges)\\n c_info.sort(key=lambda x: -x['sum'])\\n total = np.sum(edges) / 255\\n area = edges.shape[0] * edges.shape[1]\\n\\n c = c_info[0]\\n del c_info[0]\\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\\n crop = this_crop\\n covered_sum = c['sum']\\n\\n while covered_sum < total:\\n changed = False\\n recall = 1.0 * covered_sum / total\\n prec = 1 - 1.0 * crop_area(crop) / area\\n f1 = 2 * (prec * recall / (prec + recall))\\n # print '----'\\n for i, c in enumerate(c_info):\\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\\n new_crop = union_crops(crop, this_crop)\\n new_sum = covered_sum + c['sum']\\n new_recall = 1.0 * new_sum / total\\n new_prec = 1 - 1.0 * crop_area(new_crop) / area\\n new_f1 = 2 * new_prec * new_recall / (new_prec + new_recall)\\n\\n # Add this crop if it improves f1 score,\\n # _or_ it adds 25% of the remaining pixels for <15% crop expansion.\\n # ^^^ very ad-hoc! make this smoother\\n remaining_frac = c['sum'] / (total - covered_sum)\\n new_area_frac = 1.0 * crop_area(new_crop) / crop_area(crop) - 1\\n if new_f1 > f1 or (\\n remaining_frac > 0.25 and new_area_frac < 0.15):\\n print('%d %s -> %s / %s (%s), %s -> %s / %s (%s), %s -> %s' % (\\n i, covered_sum, new_sum, total, remaining_frac,\\n crop_area(crop), crop_area(new_crop), area, new_area_frac,\\n f1, new_f1))\\n crop = new_crop\\n covered_sum = new_sum\\n del c_info[i]\\n changed = True\\n break\\n\\n if not changed:\\n break\\n\\n return crop\",\n \"def ransac(keypoints1, keypoints2, matches, sampling_ratio=0.5, n_iters=500, threshold=20):\\n N = matches.shape[0]\\n n_samples = int(N * sampling_ratio)\\n\\n # Please note that coordinates are in the format (y, x)\\n matched1 = pad(keypoints1[matches[:,0]])\\n matched2 = pad(keypoints2[matches[:,1]])\\n matched1_unpad = keypoints1[matches[:,0]]\\n matched2_unpad = keypoints2[matches[:,1]]\\n\\n max_inliers = np.zeros(N)\\n n_inliers = 0\\n\\n # RANSAC iteration start\\n ### YOUR CODE HERE\\n raise NotImplementedError() # Delete this line\\n ### END YOUR CODE\\n return H, matches[max_inliers]\",\n \"def ransac(matches, kp1, kp2, s=4, threshold=3, maxIterations=2000, returnMatches=False, inlierRatio=0.05, ransacRatio=0.6):\\n\\n sizes_kp1 = [kp1[dt[0].queryIdx].size for dt in matches]\\n sizes_kp2 = [kp1[dt[0].trainIdx].size for dt in matches]\\n tup_matches_kp1 = [kp1[dt[0].queryIdx].pt for dt in matches]\\n tup_matches_kp2 = [kp2[dt[0].trainIdx].pt for dt in matches]\\n matches_kp1 = np.array([[h for h in kp] + [1] for kp in tup_matches_kp1])\\n matches_kp2 = np.array([[h for h in kp] + [1] for kp in tup_matches_kp2])\\n\\n cnt_matches = len(matches)\\n\\n max_matches = []\\n max_p1, max_p2 = [], []\\n max_p1_sizes, max_p2_sizes = [], []\\n max_total = 0\\n\\n for iter in range(maxIterations):\\n # Find Homography based on random sample\\n data = random.sample(matches, s)\\n data_p1 = np.array([matches_kp1[dt[0].queryIdx] for dt in data])\\n data_p2 = np.array([matches_kp2[dt[0].trainIdx] for dt in data])\\n homography = homomat(data_p1[:, :2], data_p2[:, :2])\\n\\n # Find P1 projection from the homography matrix\\n projected_p2 = np.dot(homography, matches_kp1.transpose())\\n projected_p2 = projected_p2[0:3] / projected_p2[2] # make sure w' is 1\\n projected_p2 = projected_p2.transpose()\\n\\n # Initialize Current Matches\\n current_matches = []\\n current_p1, current_p2 = [], []\\n current_p1_sizes, current_p2_sizes = [], []\\n current_total = 0\\n\\n # Check for inliers and outliers for each matches\\n for i, (match) in enumerate(matches):\\n # normalize the error\\n error = np.linalg.norm(matches_kp2[i] - projected_p2[i])\\n\\n # Check for inliers\\n if error < threshold:\\n current_matches.append([cv.DMatch(current_total, current_total, match[0].distance)])\\n current_p1.append(matches_kp1[i][0:2])\\n current_p2.append(matches_kp2[i][0:2])\\n current_p1_sizes.append(sizes_kp1[i])\\n current_p2_sizes.append(sizes_kp2[i])\\n current_total += 1\\n\\n # If\\n if current_total > max_total and current_total >= np.round(inlierRatio*cnt_matches):\\n max_matches = current_matches\\n max_p1 = current_p1\\n max_p2 = current_p2\\n max_p1_sizes = current_p1_sizes\\n max_p2_sizes = current_p2_sizes\\n max_total = current_total\\n\\n # # we are done in case we have enough inliers\\n if current_total > cnt_matches * ransacRatio:\\n break\\n\\n\\n # Re-evaluate the Homography based on the best inliers\\n max_homography = homomat(np.array(max_p1), np.array(max_p2))\\n\\n if returnMatches:\\n max_kp1 = [cv.KeyPoint(d[0], d[1], max_p1_sizes[i]) for i, d in enumerate(max_p1)]\\n max_kp2 = [cv.KeyPoint(d[0], d[1], max_p2_sizes[i]) for i, d in enumerate(max_p2)]\\n return max_homography, max_matches, max_kp1, max_kp2\\n\\n return max_homography\",\n \"def find_occluded(tlbrs, occlusion_thresh):\\n occluded_mask = np.zeros(tlbrs.shape[0], dtype=np.bool_)\\n for i in nb.prange(tlbrs.shape[0]):\\n area_self = area(tlbrs[i, :])\\n for j in range(tlbrs.shape[0]):\\n if i != j:\\n iw = min(tlbrs[i, 2], tlbrs[j, 2]) - max(tlbrs[i, 0], tlbrs[j, 0]) + 1\\n ih = min(tlbrs[i, 3], tlbrs[j, 3]) - max(tlbrs[i, 1], tlbrs[j, 1]) + 1\\n if iw > 0 and ih > 0:\\n ios = iw * ih / area_self\\n if ios >= occlusion_thresh:\\n occluded_mask[i] = True\\n break\\n return occluded_mask\",\n \"def _poly_exactly_coincident(a,b):\\n n_holes = len(a.holes)\\n n_parts = len(a.parts)\\n if n_holes != len(b.holes):\\n return False\\n if n_parts != len(b.parts):\\n return False\\n b_in_a = [None]*n_holes\\n a_in_b = [None]*n_holes\\n for i, a_hole in a.holes:\\n for j, b_hole in b.holes:\\n i_j = coincident(a_hole, b_hole)\\n if i_j:\\n b_in_a[j] = True\\n a_in_b[i] = True\\n break\\n if not a_in_b[i]:\\n return False\\n if any(in_b):\\n return False\\n for b_hole in b.holes:\\n in_a = [not coincident(b_hole, a_hole) for a_hole in a.holes]\\n if any(in_a):\\n return False\\n return True\",\n \"def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\\n min_ratio, max_ratio):\\n output = []\\n for contour in input_contours:\\n x,y,w,h = cv2.boundingRect(contour)\\n if (w < min_width or w > max_width):\\n continue\\n if (h < min_height or h > max_height):\\n continue\\n area = cv2.contourArea(contour)\\n if (area < min_area):\\n continue\\n if (cv2.arcLength(contour, True) < min_perimeter):\\n continue\\n hull = cv2.convexHull(contour)\\n solid = 100 * area / max(cv2.contourArea(hull),1)\\n if (solid < solidity[0] or solid > solidity[1]):\\n continue\\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\\n continue\\n ratio = (float)(w) / h\\n if (ratio < min_ratio or ratio > max_ratio):\\n continue\\n output.append(contour)\\n return output\",\n \"def venn(a,b):\\n a = set(a)\\n b = set(b)\\n return map(list, (a.difference(b), a.intersection(b), b.difference(a)))\",\n \"def match_marking_points(point_a, point_b):\\n \\n squared_distance_thresh = 0.000277778 # 10 pixel in 600*600 image\\n direction_angle_thresh = 0.5235987755982988 # 30 degree in rad \\n \\n dist_square = calc_point_squre_dist(point_a, point_b)\\n #if min(point_a.shape[1], point_b.shape[1]) <= 2:\\n if True:\\n return dist_square < squared_distance_thresh\\n\\n angle = calc_point_direction_angle(point_a, point_b)\\n if point_a[3] > 0.5 and point_b[3] < 0.5:\\n return False\\n if point_a[3] < 0.5 and point_b[3] > 0.5:\\n return False\\n return (dist_square < squared_distance_thresh\\n and angle < direction_angle_thresh)\",\n \"def match_twosided(desc1,desc2,threshold=0.5):\\n matches_12 = match(desc1,desc2,threshold)\\n matches_21 = match(desc2,desc1,threshold)\\n ndx_12 = np.where(matches_12 >= 0)[0]\\n # remove matches that are not symmetric\\n for n in ndx_12:\\n if matches_21[matches_12[n]] != n:\\n matches_12[n] = -1\\n return matches_12\",\n \"def __find_contours(input, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n im2, contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def find_matching_segments(self):\\n hyp_matched_segs = [TIntervalGroup() for i in range(len(self.hyp))]\\n for gid_ref, match_ref in enumerate(self.ref):\\n bg_ref = match_ref.bbox_group\\n max_gid, max_area = -1, 0\\n for gid_hyp, bg_hyp in enumerate(self.hyp.get_bbox_groups()):\\n rx, ry = bg_ref.page_range(), bg_hyp.page_range()\\n if ry[0] > rx[1]:\\n break\\n area = (bg_ref & bg_hyp)\\n if area > max_area:\\n max_gid, max_area = gid_hyp, area\\n if max_gid != -1:\\n hyp_matched_segs[max_gid].extend(match_ref.tinterval_group.copy())\\n print('%d -> %d' % (gid_ref, max_gid))\\n for seg in hyp_matched_segs:\\n seg.reduce()\\n return hyp_matched_segs\",\n \"def match(self, grp, healpixIDs, pixRA, pixDec):\\n\\n # print('hello', grp.columns)\\n pixRA_rad = np.deg2rad(pixRA)\\n pixDec_rad = np.deg2rad(pixDec)\\n\\n # convert data position in rad\\n pRA = np.median(grp[self.RACol])\\n pDec = np.median(grp[self.DecCol])\\n pRA_rad = np.deg2rad(pRA)\\n pDec_rad = np.deg2rad(pDec)\\n\\n # gnomonic projection of pixels on the focal plane\\n x, y = proj_gnomonic_plane(pRA_rad, pDec_rad, pixRA_rad, pixDec_rad)\\n # x, y = proj_gnomonic_plane(np.deg2rad(self.LSST_RA-pRA),np.deg2rad(self.LSST_Dec-pDec), pixRA_rad, pixDec_rad)\\n\\n # get LSST FP with the good scale\\n # pnew = LSSTPointing(0., 0., area=np.pi*self.fpscale**2)\\n fpnew = LSSTPointing_circular(0., 0., maxbound=self.fpscale)\\n # fpnew = LSSTPointing(np.deg2rad(self.LSST_RA-pRA),np.deg2rad(self.LSST_Dec-pDec),area=np.pi*self.fpscale**2)\\n # maxbound=self.fpscale)\\n\\n \\\"\\\"\\\"\\n import matplotlib.pyplot as plt\\n fig, ax = plt.subplots()\\n ax.plot(x, y, 'ko')\\n pf = PolygonPatch(fpnew, facecolor=(0, 0, 0, 0), edgecolor='red')\\n ax.add_patch(pf)\\n plt.show()\\n \\\"\\\"\\\"\\n\\n # print(shapely.vectorized.contains(\\n # fpnew, x, y), self.fpscale, fpnew.area)\\n\\n idf = shapely.vectorized.contains(fpnew, x, y)\\n\\n pixID_matched = list(healpixIDs[idf])\\n pixRA_matched = list(pixRA[idf])\\n pixDec_matched = list(pixDec[idf])\\n\\n # names = [grp.name]*len(pixID_matched)\\n df_pix = pd.DataFrame({'healpixID': pixID_matched,\\n 'pixRA': pixRA_matched,\\n 'pixDec': pixDec_matched, })\\n # 'groupName': names})\\n\\n return df_pix\\n \\\"\\\"\\\"\\n n_index = len(grp.index.values)\\n\\n arr_index = grp.index.values\\n\\n n_pix = len(df_pix)\\n if n_pix > 1:\\n arr_index = arr_index.repeat(n_pix)\\n if n_index > 1:\\n df_pix = df_pix.append([df_pix]*(n_index-1), ignore_index=True)\\n\\n df_pix.loc[:, 'index'] = arr_index\\n \\n return df_pix\\n \\\"\\\"\\\"\",\n \"def draw_match(img1, p1, img2, p2, mask=None, H=None):\\n h1, w1 = img1.shape[:2]\\n h2, w2 = img2.shape[:2]\\n vis = np.zeros((max(h1, h2), w1 + w2), np.uint8)\\n vis[:h1, :w1] = img1\\n vis[:h2, w1:w1 + w2] = img2\\n vis = cv2.cvtColor(vis, cv2.COLOR_GRAY2BGR)\\n\\n if H is not None:\\n corners = np.float32([[0, 0], [w1, 0], [w1, h1], [0, h1]])\\n corners = np.int32(\\n cv2.perspectiveTransform(\\n corners.reshape(1, -1, 2), H).reshape(-1, 2) \\\\\\n + (w1, 0))\\n cv2.polylines(vis, [corners], True, (255, 255, 255))\\n\\n if mask is None:\\n mask = np.ones(len(p1), np.bool_)\\n\\n green = (63, 255, 0)\\n red = (0, 0, 255)\\n for (x1, y1), (x2, y2), inlier in zip(np.int32(p1), np.int32(p2), mask):\\n col = [red, green][inlier]\\n if inlier:\\n cv2.line(vis, (x1, y1), (x2 + w1, y2), col)\\n cv2.circle(vis, (x1, y1), 4, col, 2)\\n cv2.circle(vis, (x2 + w1, y2), 4, col, 2)\\n else:\\n r = 2\\n thickness = 3\\n cv2.line(vis, (x1 - r, y1 - r), (x1 + r, y1 + r), col, thickness)\\n cv2.line(vis, (x1 - r, y1 + r), (x1 + r, y1 - r), col, thickness)\\n cv2.line(vis, (x2 + w1 - r, y2 - r), (x2 + w1 + r, y2 + r), col, thickness)\\n cv2.line(vis, (x2 + w1 - r, y2 + r), (x2 + w1 + r, y2 - r), col, thickness)\\n return vis\",\n \"def intersect2d(A, B):\\n # print 'A = ', A\\n # print 'B = ', B\\n a1_rows = A.view([('', A.dtype)] * A.shape[1])\\n a2_rows = B.view([('', B.dtype)] * B.shape[1])\\n # Now trim those bonds from BL\\n C = np.intersect1d(a1_rows, a2_rows).view(A.dtype).reshape(-1, A.shape[1])\\n return C\",\n \"def bins_match (a, b):\\n return np.sum ((a.bins - b.bins)**2) == 0\",\n \"def detect_contours(self):\\r\\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\r\\n return [DbugContour(cv_contour=contour) for contour in contours]\",\n \"def clip(self, clip, s_entry, c_entry):\\n\\n # detect clip mode\\n unionmode = not s_entry and not c_entry\\n intersectionmode = s_entry and c_entry\\n differencemode = not s_entry and c_entry\\n\\n # prep by removing repeat of startpoint at end\\n first = self.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n first = clip.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n\\n # TODO: maybe also remove repeat points anywhere?\\n # ...\\n \\n # phase one - find intersections\\n # ------------------------------\\n anyintersection = False\\n s_intsecs = []\\n c_intsecs = []\\n for s in self.iter(): # for each vertex Si of subject polygon do\\n for c in clip.iter(): # for each vertex Cj of clip polygon do\\n try:\\n #print \\\"find isect %s - %s and %s - %s\\\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\\n c, clip.next(c.__next__))\\n \\n iS = Vertex(i, alphaS, intersect=True, entry=False)\\n iC = Vertex(i, alphaC, intersect=True, entry=False)\\n\\n iS.neighbour = iC\\n iC.neighbour = iS\\n \\n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\\n \\n anyintersection = True\\n \\n except TypeError:\\n pass # this simply means intersect() returned None\\n\\n # insert intersections into originals\\n for iS,a,s,s_next in reversed(s_intsecs):\\n if a == 0:\\n self.replace(s, iS)\\n elif a == 1:\\n self.replace(s_next, iS)\\n else:\\n self.insert(iS, s, s_next)\\n for iC,a,c,c_next in reversed(c_intsecs):\\n if a == 0:\\n self.replace(c, iC)\\n elif a == 1:\\n self.replace(c_next, iC)\\n else:\\n clip.insert(iC, c, c_next)\\n\\n #print \\\"testing if insert was done correctly\\\"\\n for s in self.iter():\\n #print s\\n pass\\n #print \\\"and\\\"\\n for c in clip.iter():\\n #print c\\n pass\\n \\n\\n # phase one and a half - no intersections between subject and clip, so correctly return results\\n # --------------------\\n def specialcase_insidetest():\\n resultpolys = []\\n if unionmode: # union\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so just return subject shell\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so just return clip shell\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so return both\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif intersectionmode: # intersection\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so no intersection to return\\n pass\\n elif differencemode: # difference\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n hole = Polygon()\\n for c in clip.iter():\\n hole.add(Vertex(c))\\n polytuple = (clipped, [hole])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so there is no difference\\n pass\\n else:\\n #clip polygon is entirely outside subject, so difference is simply the subject\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n # no need to continue so just return result\\n return resultpolys\\n \\n if not anyintersection: \\n return specialcase_insidetest()\\n\\n\\n\\n\\n\\n\\n\\n # phase two - identify entry/exit points\\n # --------------------------------------\\n\\n # From K&K\\n \\n def mark_flags(poly, c, c_entry):\\n \\\"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\\\"\\n #print \\\"intersection\\\"\\n #print \\\"\\\\t\\\",c\\n # intersection is degenerate, is the start/endpoint of a line\\n # so maybe delete intersection flag based on prev/next locations\\n prevloc = testLocation(c.prev, poly)\\n nextloc = testLocation(c.__next__, poly)\\n if prevloc == \\\"on\\\" or nextloc == \\\"on\\\":\\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\\n prevloc = testLocation(prevmid, poly)\\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\\n nextloc = testLocation(nextmid, poly)\\n if prevloc == \\\"in\\\" or nextloc == \\\"in\\\":\\n poly.anyinside = True\\n #print \\\"\\\\t %s -> degenintsec -> %s\\\" %(prevloc,nextloc)\\n if prevloc == \\\"out\\\":\\n if nextloc == \\\"out\\\":\\n #just touching\\n c.entry = \\\"en/ex\\\" if c_entry else \\\"ex/en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif prevloc == \\\"in\\\":\\n #union and difference should never go inside the other polygon\\n #so this should only happen for intersectmode...\\n if nextloc == \\\"in\\\":\\n #just touching\\n c.entry = \\\"ex/en\\\" if c_entry else \\\"en/ex\\\"\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif prevloc == \\\"on\\\":\\n if nextloc == \\\"on\\\":\\n c.entry = None\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n\\n self.anyinside = False\\n\\n # set clip\\n prevsingle = None\\n for c in clip.iter():\\n if c.intersect:\\n mark_flags(self, c, c_entry)\\n # set couple\\n if c.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and c.entry == prevsingle.entry:\\n c.couple = prevsingle\\n prevsingle.couple = c\\n prevsingle = c\\n # set crosschange\\n # some modifications based on implementation in qt clipper source code\\n #if c.entry == \\\"en/ex\\\" == c.neighbour.entry or c.entry == \\\"ex/en\\\" == c.neighbour.entry:\\n if False: #c.entry == \\\"en/ex\\\" or c.entry == \\\"ex/en\\\":\\n print(\\\"Maybe crosschange...\\\")\\n # tri1\\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\\n dir1 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n # tri2\\n #a,b,c = c.neighbour.prev, c.prev, c.next\\n a,b,c = c.__next__, c.prev, c.neighbour.prev\\n dir2 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n print(dir1,dir2)\\n #if dir1 < 0 != dir2 < 0: # different orientation\\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\\n print(\\\"CROSSCHANGE!!!\\\")\\n c.cross_change = True\\n c.neighbour.cross_change = True # not sure if should set neighbour too\\n\\n # maybe early abort\\n if not self.anyinside and intersectionmode:\\n return []\\n\\n # what about perfect overlap???\\n # ...\\n\\n if False: #DEBUG:\\n print(\\\"view clip entries\\\")\\n for c in clip.iter():\\n print(c, c.entry)\\n\\n # find first isect where both neighbours have valid flag\\n for c in clip.iter():\\n if c.entry:\\n s = c.neighbour\\n mark_flags(clip, s, s_entry)\\n if s.entry:\\n first_c = c\\n first_s = s\\n # print 777,s.entry\\n break\\n\\n else:\\n return specialcase_insidetest()\\n #raise Exception(\\\"weird special case, no neighbours that both have flag left\\\")\\n \\n # autoset subj, if neighbour of first is different, then set all as opposite\\n # TODO: how deal with s_entry in case of different modes...?\\n print(\\\"view first\\\")\\n print(first_c, first_c.entry)\\n print(first_s, first_s.entry)\\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\\n for c in clip.iter():\\n if c.entry:\\n if c.entry == \\\"en\\\": c.neighbour.entry = \\\"ex\\\"\\n elif c.entry == \\\"ex\\\": c.neighbour.entry = \\\"en\\\"\\n elif c.entry == \\\"en/ex\\\": c.neighbour.entry = \\\"ex/en\\\"\\n elif c.entry == \\\"ex/en\\\": c.neighbour.entry = \\\"en/ex\\\"\\n \\n # else set all same\\n else:\\n for c in clip.iter():\\n if c.entry:\\n c.neighbour.entry = c.entry\\n\\n # set couple for subj (not sure if needed)\\n prevsingle = None\\n for s in self.iter():\\n if s.entry:\\n if s.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and s.entry == prevsingle.entry:\\n s.couple = prevsingle\\n prevsingle.couple = s\\n prevsingle = s\\n\\n if False: #DEBUG: \\n print(\\\"view subj entries\\\")\\n for s in self.iter():\\n print(s, s.entry)\\n\\n\\n\\n\\n\\n # phase three - construct a list of clipped polygons\\n # --------------------------------------------------\\n\\n ######\\n # Defs\\n def next_unprocessed(vert):\\n origvert = vert\\n while vert:\\n if vert.entry and not (vert.checked or vert.neighbour.checked):\\n #print \\\"vert, found next unproc\\\", vert, vert.checked, vert.neighbour.checked\\n if vert.couple:\\n # rule 1\\n if vert.couple.entry and vert.entry:\\n # rule 2\\n if vert.couple.entry == \\\"en\\\" and vert.entry == \\\"en\\\":\\n return vert.couple\\n elif vert.couple.entry == \\\"ex\\\" and vert.entry == \\\"ex\\\":\\n return vert\\n # rule 3\\n else:\\n return vert\\n \\n vert = vert.__next__\\n \\n if vert == origvert:\\n # if returned to first, return None\\n return None\\n\\n def DeleteFlag1(cur, stat):\\n if cur.entry == \\\"en/ex\\\":\\n cur.entry = None\\n if cur.cross_change:\\n if stat == \\\"D3\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if stat == \\\"D3\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D3\\\":\\n cur.entry = \\\"en\\\"\\n return \\\"D2\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n return \\\"D1\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n return \\\"D1\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n return \\\"D2\\\"\\n\\n def DeleteFlag2(cur, prev, stat):\\n if cur.entry == \\\"en/ex\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"ex\\\"\\n else:\\n cur.entry = \\\"en\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"en\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n if stat == \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D1\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n if stat != \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D2\\\"\\n else:\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n\\n def proceed(cur, stat):\\n cur.checked = True\\n if stat == \\\"D1\\\":\\n clipped.add(Vertex(cur))\\n return cur.__next__\\n elif stat == \\\"D2\\\":\\n clipped.add(Vertex(cur))\\n return cur.prev\\n else:\\n return cur.neighbour\\n\\n ####\\n resultpolys = []\\n\\n self.first.checked = True\\n cur = prev = start = next_unprocessed(self.first)\\n\\n while cur:\\n # each new polygon\\n print(\\\"new poly\\\")\\n\\n stat = DeleteFlag1(cur, \\\"D3\\\")\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n clipped = Polygon()\\n cur = proceed(cur, stat)\\n\\n # collect vertexes\\n while cur != start:\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n if cur.entry:\\n if stat == \\\"D1\\\" or stat == \\\"D2\\\":\\n stat = DeleteFlag2(cur, prev, stat)\\n else:\\n stat = DeleteFlag1(cur, stat)\\n prev = cur\\n cur = proceed(cur, stat)\\n\\n # return to first vertex\\n clipped.add(Vertex(clipped.first))\\n\\n print(clipped)\\n\\n resultpolys.append((clipped,[]))\\n cur = prev = start = next_unprocessed(self.first)\\n\\n\\n\\n # finally, sort into exteriors and holes\\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\\n for otherext,otherholes in resultpolys:\\n if polyext == otherext:\\n continue # don't compare to self\\n if polyext.first.isInside(otherext):\\n otherholes.append(polyext) #poly is within other so make into a hole\\n del resultpolys[pindex] #and delete poly from being an independent poly\\n return resultpolys\",\n \"def match2(img1, img2, coordinates1, coordinates2, PATCH_SIZE):\\n\\n\\tpossible_matches = pd.DataFrame(columns=['feature1', 'feature2', 'diff'])\\n\\n\\t# iteration through all the possible pairs of features from img1 and img2\\n\\tfor (feature1, feature2) in product(coordinates1, coordinates2):\\n\\t\\tpatch1 = make_patch(feature1, PATCH_SIZE, img1)\\n\\t\\tpatch2 = make_patch(feature2, PATCH_SIZE, img2)\\n\\t\\tdiff = count_difference(patch1, patch2)\\n\\t\\t# print(feature1, feature2, diff)\\n\\t\\t# next line is weird, don't ask\\n\\t\\tpossible_matches = possible_matches.append({'feature1': feature1, 'feature2': feature2, 'diff': diff}, ignore_index=True)\\n\\n\\n\\t# sorting the possible_matches according to their difference and resetin the index\\n\\t# inplace=True means that changes will be performed in-place, so they will change the variable and there is no need to reassign\\n\\tpossible_matches.sort_values(['diff'], inplace=True)\\n\\tpossible_matches.reset_index(inplace=True, drop=True)\\n\\t# print(\\\"SORTED\\\")\\n\\t# print(possible_matches)\\n\\n\\t# adding only the best matches\\n\\tmatches = []\\n\\twhile not possible_matches.empty:\\n\\t\\tbest_match = possible_matches.loc[0]\\n\\t\\tmatches.append(list(best_match))\\n\\t\\t# creating a list of indicies to be dropped\\n\\t\\ttrash = []\\n\\n\\t\\t#finding and deleting rows with features that are already used and reseting the index\\n\\t\\tfor i, (f1, f2, d) in enumerate(possible_matches.values):\\n\\t\\t \\n\\t\\t\\tif np.all(f1 == best_match[0]) or np.all(f2 == best_match[1]):\\n\\t\\t\\t\\ttrash.append(i)\\n\\t\\n\\t\\tfor i in trash:\\n\\t\\t\\tpossible_matches.drop(i, inplace=True)\\n\\t\\tpossible_matches.reset_index(inplace=True, drop=True)\\n\\t\\t# print(possible_matches)\\n\\n\\treturn matches\",\n \"def __filter_contours(input_contours, min_area, min_perimeter, min_width, max_width,\\n min_height, max_height, solidity, max_vertex_count, min_vertex_count,\\n min_ratio, max_ratio):\\n output = []\\n for contour in input_contours:\\n x, y, w, h = cv2.boundingRect(contour)\\n if (w < min_width or w > max_width):\\n continue\\n if (h < min_height or h > max_height):\\n continue\\n area = cv2.contourArea(contour)\\n if (area < min_area):\\n continue\\n if (cv2.arcLength(contour, True) < min_perimeter):\\n continue\\n hull = cv2.convexHull(contour)\\n solid = 100 * area / cv2.contourArea(hull)\\n if (solid < solidity[0] or solid > solidity[1]):\\n continue\\n if (len(contour) < min_vertex_count or len(contour) > max_vertex_count):\\n continue\\n ratio = (float)(w) / h\\n if (ratio < min_ratio or ratio > max_ratio):\\n continue\\n output.append(contour)\\n return output\",\n \"def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\\n\\n\\t#creating patches for all points from img1 and img2\\n\\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\\n\\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\\n\\n\\t# creating a matrix with dissimilarity measures for all pairs\\n\\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\\n\\n\\tfor (x, y), _ in np.ndenumerate(all_matches):\\n\\t\\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\\n\\n\\t#looking for best left-to-right and right-to-left matches\\n\\tmatches = []\\n\\t#left-to-right\\n\\tfor i, coord1 in enumerate(coordinates1):\\n\\t\\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\\n\\t\\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\\n\\t\\tif (i == best_rtl_match): #hurray, there is a super match\\n\\n\\t\\t\\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\\n\\t\\n\\treturn matches\",\n \"def compute_coverage_for_contour_pair(\\n contour1: np.ndarray,\\n contour2: np.ndarray,\\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\\n):\\n im1, im2 = compute_contour_binary_masks(contour1, contour2, max_size=max_size)\\n return (im1 & im2).sum() / im1.sum()\",\n \"def get_matching(self):\\n verts, plaqs, d_verts, d_plaqs = self.get_stabs()\\n\\n # def get_matching(anyons, d_anyons):\\n # edges = self.get_edges(anyons)\\n # for i0, i1, weight in edges:\\n # nxgraph.add_edge(i0, i1, weight=-weight)\\n # output = nx.algorithms.matching.max_weight_matching(nxgraph, maxcardinality=True)\\n # return [[d_anyons[i0], d_anyons[i1]] for i0, i1 in output]\\n\\n def get_matching(anyons, d_anyons):\\n output = pm.getMatching(len(anyons), self.get_edges(anyons))\\n return [[d_anyons[i0], d_anyons[i1], anyons[i0], anyons[i1]] for i0, i1 in enumerate(output) if i0 > i1]\\n\\n self.matching = []\\n if verts:\\n self.matching += get_matching(verts, d_verts)\\n if plaqs:\\n self.matching += get_matching(plaqs, d_plaqs)\",\n \"def isFusion(event,buff):\\n index,diff,label = event\\n label = label[0]\\n if diff>0:\\n return False,[]\\n img_before = np.copy(buff[:,:,index-1])\\n img_after = np.copy(buff[:,:,index])\\n mask_before = (img_before==label).astype(np.uint8)\\n nb_elts_before = np.amax(img_before)\\n kernel = np.ones((7,7),np.uint8)\\n neighbouring_mask = cv2.dilate(mask_before,kernel,iterations=8)\\n\\n new_map = np.multiply(img_before,neighbouring_mask.astype(np.uint8))\\n \\n #Removing the element we are currently looking at\\n new_map[img_before==label]=0\\n possible_candidates = []\\n for i in range(nb_elts_before):\\n if np.any(new_map==i+1):\\n possible_candidates.append(i+1)\\n #Computes the area of the cells and compares them\\n size_cell_disappearing = np.count_nonzero(img_before==label)\\n match = [] #lists the ratios sizeAfter/sizeBefore for possible matches\\n \\n for vals in possible_candidates:\\n size_other_cell = np.count_nonzero(img_before==vals)\\n size_before = size_other_cell+size_cell_disappearing\\n size_after = np.count_nonzero(img_after==vals)\\n ratio = float(size_after)/float(size_before)\\n if ratio>0.8 and ratio<1.2:\\n match.append((vals,abs(1-ratio)))\\n if len(match)==0:\\n return False,[]\\n if len(match)>1:\\n #Several matches, so pick the best\\n values = [y for x,y in match]\\n result_label,osef = match[np.argmin(values)]\\n else:\\n result_label, osef = match[0]\\n return True,result_label\",\n \"def has_match(trajs_0, trajs_1):\\n for i in range(len(trajs_0)):\\n for j in range(len(trajs_1)):\\n R = (trajs_0[i].get_slice()[:,:2] == trajs_1[j].get_slice()[:,:2])\\n if isinstance(R, bool):\\n if R:\\n return True \\n elif R.all():\\n return True \\n else:\\n pass \\n return False\",\n \"def equiv(subdiagram1, subdiagram2):\\n # TODO: Make sure arguments are the right type\\n # TODO: Make this work for subdiagrams of length >= 1\\n # subdiagrams are not equivalent if they have different numbers of crossings\\n # print \\\"sub1\\\\t\\\", subdiagram1, len(subdiagram1[0])\\n # print \\\"sub2\\\\t\\\", subdiagram2, len(subdiagram2[0])\\n if len(subdiagram1[0]) != len(subdiagram2[0]):\\n return False\\n # look for a match\\n for i in range(len(subdiagram1[0])-1):\\n crossing1 = subdiagram1[0][i]\\n typeMatch = False\\n for j in range(len(subdiagram2[0])-1):\\n crossing2 = subdiagram2[0][j]\\n print \\\"\\\\tc1 \\\",crossing1\\n print \\\"\\\\tc2 \\\",crossing2\\n # check for same crossing type\\n # TODO: check for empty crossing\\n if len(crossing1) == 5 and len(crossing2) == 5:\\n if crossing1[0] == crossing2[0]:\\n print \\\" :)\\\"\\n typeMatch = True\\n \\n\\n return True\",\n \"def is_different(image1, image2):\\n gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)\\n gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)\\n\\n (score, diff) = compare_ssim(gray1, gray2, full=True)\\n diff = (diff * 255).astype(\\\"uint8\\\")\\n\\n thresh = cv2.threshold(diff, 0, 255,\\n cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\\n cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL,\\n cv2.CHAIN_APPROX_SIMPLE)\\n cnts = cnts[0] if imutils.is_cv2() else cnts[1]\\n\\n return bool(cnts)\",\n \"def __find_contours(input, external_only):\\n if(external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy =cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def is_complete(self, A, B):\\n return all(self.is_edge(v, w) for v in A for w in B)\",\n \"def is_sub(ind_a, ind_b):\\n while ind_a < len(s) and ind_b < len(p):\\n if ind_a in removed or s[ind_a] != p[ind_b]:\\n ind_a += 1\\n continue\\n ind_a += 1\\n ind_b += 1\\n return ind_b == len(p)\",\n \"def test_commonfs_truecase():\\n f1 = tempfile.mkstemp()\\n f2 = tempfile.mkstemp()\\n rc1 = r.RemovalCandidate(f1[1])\\n rc2 = r.RemovalCandidate(f2[1])\\n assert r.commonfs([rc1,rc2])\",\n \"def getCV(file1, type, imgOri,iteration):\\n del s_arrays[:]\\n del shapesContours[:]\\n\\n if type == 'shapes':\\n spContours = getContours(imgOri,iteration)\\n file1.write(str(len(spContours)) + '\\\\n')\\n print(len(spContours))\\n spContours = clean_Con(spContours)\\n file1.write(str(len(spContours)) + '\\\\n')\\n print(len(spContours))\\n cv2.drawContours(imgOri, spContours, -1, (0, 255, 128), 5)\\n # del s_arrays[:]\\n # for each shape\\n for cons in spContours:\\n sampleComVector = []\\n x, y, w, h = cv2.boundingRect(cons)\\n cv2.rectangle(imgOri, (x, y), (x + w, y + h), (100, 100, 100), 1)\\n\\n # move the points to center\\n for point in cons:\\n sampleComVector.append(complex(point[0][0] - x, (point[0][1] - y)))\\n # sampleComVectors store CV of all testees contours\\n s_arrays.append(sampleComVector)\\n # sampleContours store all testees contours, same order with sampleComVectors\\n shapesContours.append(cons)\\n\\n elif type == 'temp':\\n # Automatically find templete contour\\n templetTrue = imgOri\\n tpContour = getContours(templetTrue,iteration)\\n for contour in tpContour:\\n x, y, w, h = cv2.boundingRect(contour)\\n #\\n for point in contour:\\n # -x and -y are to make left and upper boundry start from 0\\n t_array.append(complex(point[0][0] - x, (point[0][1] - y)))\",\n \"def _check_flip(origin_imgs, result_imgs):\\n h, w, c = origin_imgs.shape\\n for i in range(h):\\n for j in range(w):\\n for k in range(c):\\n if result_imgs[i, j, k] != origin_imgs[i, w - 1 - j, k]:\\n return False\\n return True\",\n \"def test_tree_intersection_on_whiteboard_example(one_wb, two_wb):\\n expected = [200, 150, 141, 100]\\n actual = tree_intersection(one_wb, two_wb)\\n assert expected == actual\",\n \"def solve_part2(start):\\n inputs = load_inputs(False)\\n all_matches = []\\n tiles = inputs.keys()\\n for elem in tiles:\\n matches = defaultdict(list)\\n for elem2 in tiles:\\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\\n l = matches[elem]\\n l.append(elem2)\\n if matches[elem]:\\n all_matches.append(matches[elem])\\n\\n # start frmo an aribtrary corner\\n # find a match, rotate me so that the match is along the right side\\n # fill in properly oriented match\\n # repeat, for row = 1+, consider top-match and left-match\\n\\n # for eery rotations / orientation, look fot the pattern\",\n \"def compara_chaves(chave1, chave2):\\n for l in range(5):\\n for c in range(5):\\n if ref_chave(chave1, faz_pos(l, c)) != chave2[l][c]:\\n return False\\n return True\",\n \"def cross_match(objects, img_wcs, coord, dist_thresh=1.0):\\n # coordinates in arcsec\\n objs_coord = img_wcs.pixel_to_world(objects[\\\"x\\\"], objects[\\\"y\\\"])\\n objs_ra = objs_coord.ra.to(u.arcsec).value\\n objs_dec = objs_coord.dec.to(u.arcsec).value\\n\\n cat_ra = np.array(coord.ra.to(u.arcsec).value)\\n cat_dec = np.array(coord.dec.to(u.arcsec).value)\\n\\n objs_id = []\\n for i in range(len(objects)):\\n ra_dist = objs_ra[i] - cat_ra\\n dec_dist = objs_dec[i] - cat_dec\\n dist_arcsec = np.sqrt(ra_dist**2 + dec_dist**2)\\n if any(dist_arcsec <= dist_thresh):\\n objs_id.append(i)\\n\\n objs = objects.take(objs_id)\\n\\n return objs\",\n \"def __find_contours(input, external_only):\\n if (external_only):\\n mode = cv2.RETR_EXTERNAL\\n else:\\n mode = cv2.RETR_LIST\\n method = cv2.CHAIN_APPROX_SIMPLE\\n contours, hierarchy = cv2.findContours(input, mode=mode, method=method)\\n return contours\",\n \"def bfs_is_connected(self):\\n q = Queue.Queue()\\n origins = [self.vertices()[0]]\\n traveled = set(origins)\\n while origins:\\n for o in origins:\\n for child in self.out_vertices(o):\\n if child not in traveled:\\n q.put(child)\\n traveled.add(child)\\n\\n origins = []\\n while not q.empty():\\n origins.append(q.get())\\n if len(traveled) == self.order():\\n return True\\n return False\",\n \"def testMatchSwarpLanczos2SubExposure(self):\\n for useDeepCopy in (False, True):\\n self.compareToSwarp(\\\"lanczos2\\\", useWarpExposure=True,\\n useSubregion=True, useDeepCopy=useDeepCopy)\",\n \"def __find_contours(input, external_only):\\r\\n if(external_only):\\r\\n mode = cv2.RETR_EXTERNAL\\r\\n else:\\r\\n mode = cv2.RETR_LIST\\r\\n method = cv2.CHAIN_APPROX_SIMPLE\\r\\n _, contours, hierarchy = cv2.findContours(\\r\\n input, mode=mode, method=method)\\r\\n return contours\",\n \"def get_instance_contours(img, contoured, instance):\\n mask = np.zeros(img.shape, dtype=np.uint16)\\n mask[img == instance] = 1\\n ret, threshed = cv.threshold(mask, 0, 2 ** 16, cv.THRESH_BINARY)\\n compressed = threshed.astype(np.uint8)\\n contours, hierarchy = cv.findContours(compressed, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n cv.drawContours(contoured, contours, -1, (randint(25, 255), randint(25, 255), randint(25, 255)), 3)\\n img2 = contours = hierarchy = mask = None\",\n \"def _extractFrames_(self, wordRulesFlag):\\n\\t\\t#pdb.set_trace()\\n\\t\\tsimplifyTree(self.srcTree)\\n\\t\\tsimplifyTree(self.tgtTree)\\n\\n\\t\\tsDic, tDic = {}, {}\\n\\t\\tframeSet = set() \\n\\t\\tfor sSubtr in self.srcTree.subtrees():\\n\\t\\t\\tif sSubtr.height() <= 2:\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tsTreePos = sSubtr.treeposition()\\n\\t\\t\\tsOffset = treePosition2offset(sTreePos, self.srcTree)\\n\\t\\t\\tsDic[sTreePos] = scanBlock(sOffset, 'src', self.waMatrix)\\n\\n\\t\\t\\tfor tSubtr in self.tgtTree.subtrees():\\n\\t\\t\\t\\tif tSubtr.height() <= 2:\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\ttTreePos = tSubtr.treeposition()\\n\\t\\t\\t\\tif tTreePos not in tDic:\\n\\t\\t\\t\\t\\ttOffset = treePosition2offset(tTreePos, self.tgtTree)\\n\\t\\t\\t\\t\\ttDic[tTreePos] = scanBlock(tOffset, 'tgt', self.waMatrix)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttOffset = tDic[tTreePos]\\n\\n\\t\\t\\t\\t#print >> debug_log, self.srcTree[sTreePos]\\n\\t\\t\\t\\t#print >> debug_log, self.tgtTree[tTreePos]\\n\\t\\t\\t\\tif sDic[sTreePos] == tDic[tTreePos] and -1 not in sDic[sTreePos] and -1 not in tDic[tTreePos]:\\n\\t\\t\\t\\t\\t#print >> debug_log, 'paird up!!'\\n\\t\\t\\t\\t\\tframeSet.add(Frame([sTreePos], [tTreePos], self.srcTree, self.tgtTree))\\n\\t\\t\\t\\t#print >> debug_log\\n\\n\\t\\t'''\\n\\t\\tsrcSubtreeSpanDict = self._extractSubtreeSpan_(self.srcTree, wordRulesFlag)\\n\\t\\ttgtSubtreeSpanDict = self._extractSubtreeSpan_(self.tgtTree, wordRulesFlag)\\n\\n\\t\\tframeSet = set() \\n\\t\\tfor span in srcSubtreeSpanDict:\\n\\t\\t\\tif not self._consistentWithWA_(span, 'src'):\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\ttgtSpanList = self._scanSpan_(span, 'src')\\n\\t\\t\\tfor tgtSpan in tgtSpanList:\\n\\t\\t\\t\\tif tgtSpan in tgtSubtreeSpanDict:\\n\\t\\t\\t\\t\\t#print >> debug_log, span, tgtSpan\\n\\t\\t\\t\\t\\tframeSet.add(Frame([srcSubtreeSpanDict[span]], [tgtSubtreeSpanDict[tgtSpan]], self.srcTree, self.tgtTree))\\n\\n\\t\\t#print >> debug_log, '\\\\n'\\n\\t\\tfor span in tgtSubtreeSpanDict:\\n\\t\\t\\tif not self._consistentWithWA_(span, 'tgt'):\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tsrcSpanList = self._scanSpan_(span, 'tgt')\\n\\t\\t\\tfor srcSpan in srcSpanList:\\n\\t\\t\\t\\tif srcSpan in srcSubtreeSpanDict:\\n\\t\\t\\t\\t\\t#print >> debug_log, srcSpan, span\\n\\t\\t\\t\\t\\tframeSet.add(Frame([srcSubtreeSpanDict[srcSpan]], [tgtSubtreeSpanDict[span]], self.srcTree, self.tgtTree))\\n\\t\\t'''\\n\\t\\t#pdb.set_trace()\\n\\t\\tframeList = self._mergeFrames_(frameSet)\\n\\t\\t#print >> debug_log, len(frameList)\\n\\t\\treturn frameList\",\n \"def compare_tree(self):\\n result = []\\n \\n pathA = os.path.join(self.testpath,'A')\\n pathB = os.path.join(self.testpath,'B')\\n\\n filesA = [os.path.relpath(f,pathA) for f in self.tree(pathA)]\\n filesB = [os.path.relpath(f,pathB) for f in self.tree(pathB)]\\n\\n filesAB = set(filesA).union(filesB)\\n for fileAB in sorted(list(filesAB)):\\n\\n fileA = os.path.join(self.testpath,'A',fileAB)\\n fileB = os.path.join(self.testpath,'B',fileAB)\\n try:\\n fileAtxt = open(fileA).read()\\n except IOError:\\n result.append( ('missing_inA',fileAB) )\\n continue\\n \\n try:\\n fileBtxt = open(fileB).read()\\n except IOError:\\n result.append( ('missing_inB',fileAB) )\\n continue\\n\\n if not fileAtxt == fileBtxt:\\n result.append( ('disagree',fileAB))\\n \\n return result\",\n \"def findtubestand_matchonobb(self, tgtpcdnp, toggledebug=False):\\n\\n # toggle the following command to crop the point cloud\\n # tgtpcdnp = tgtpcdnp[np.logical_and(tgtpcdnp[:,2]>40, tgtpcdnp[:,2]<60)]\\n\\n inithomomat = self.findtubestand_obb(tgtpcdnp, toggledebug)\\n inlinnerrmse, homomat = o3dh.registration_icp_ptpt(self.tstpcdnp, tgtpcdnp, inithomomat, maxcorrdist=5,\\n toggledebug=toggledebug)\\n inithomomatflipped = copy.deepcopy(inithomomat)\\n inithomomatflipped[:3, 0] = -inithomomatflipped[:3, 0]\\n inithomomatflipped[:3, 1] = -inithomomatflipped[:3, 1]\\n inlinnerrmseflipped, homomatflipped = o3dh.registration_icp_ptpt(self.tstpcdnp, tgtpcdnp, inithomomatflipped,\\n maxcorrdist=5, toggledebug=toggledebug)\\n print(inlinnerrmse, inlinnerrmseflipped)\\n if inlinnerrmseflipped < inlinnerrmse:\\n homomat = homomatflipped\\n return copy.deepcopy(homomat)\",\n \"def match_features(self):\\n type_of_None = type(None)\\n if type(self.featureDesA) != type_of_None and type(self.featureDesB) != type_of_None:\\n matches = self.bfMatcher.match(self.featureDesA, self.featureDesB)\\n self.match = sorted(matches, key=lambda x: x.distance)\\n self.match = self.match[:50]\\n else:\\n self.match = []\",\n \"def match_greedy_sift(keypoints_A, keypoints_B, features_A, features_B, test_ratio=0.75):\\n matcher = cv2.DescriptorMatcher_create(\\\"BruteForce\\\")\\n matches = matcher.knnMatch(features_A, features_B, 2)\\n\\n refined_matches = []\\n for m in matches:\\n if len(m) == 2 and m[0].distance < m[1].distance * test_ratio:\\n refined_matches.append((m[0].queryIdx, m[0].trainIdx))\\n\\n match_A, match_B = [], []\\n for idA, idB in refined_matches:\\n match_A.append(keypoints_A[idA])\\n match_B.append(keypoints_B[idB])\\n\\n return np.int32(match_A), np.int32(match_B)\",\n \"def getContours(img,iteration):\\n nP, IDrange = upDate(iteration)\\n imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n retvalth, imgthreshold = cv2.threshold(imgray, 50, 255, cv2.THRESH_BINARY)\\n kernel = np.ones((nP, nP), np.uint8)\\n imgdilation = cv2.dilate(imgthreshold, kernel, iterations=2)\\n contours = []\\n # two vertion of cv2 for findcontours-> (old vertion): imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n #contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n if iteration == 2 :\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n elif iteration == 3:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n else:\\n contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n ##imgcontours, contours, hierarchy = cv2.findContours(imgdilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\n return contours\",\n \"def extractFeatures(bwimage):\\n \\n \\n # circularity\\n img = bwimage.copy()\\n img1, contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n \\n if len(contours)==0:\\n return []\\n B = contours[0]\\n C = B[:,0,0]\\n l = C.size\\n \\n \\n if abs(B[0,0,0] - B[l-1,0,0]) + abs(B[0,0,1] - B[l-1,0,1]) == 2:\\n P8 = math.sqrt(2)\\n else:\\n P8 = 1 \\n for j in range(0,l-1): \\n if abs((B[j+1,0,0] - B[j,0,0])) + abs(B[j+1,0,1] - B[j,0,1]) == 2:\\n P8 = P8 + math.sqrt(2)\\n else:\\n P8 = P8 + 1\\n \\n n = np.count_nonzero(bwimage)\\n \\n circularity = P8*P8/n\\n \\n \\n # elongation\\n idx = np.nonzero(bwimage);\\n c = idx[1]\\n r = idx[0]\\n meanx = np.mean(c)\\n meany = np.mean(r)\\n \\n \\n pows = 2*np.ones(n)\\n \\n sigxx = np.sum(np.power((c-meanx),pows))/n\\n sigyy = np.sum(np.power((r-meany),pows))/n\\n sigxy = np.sum(np.multiply((r-meany),(c-meanx)))/n\\n \\n covMat = np.array([[sigxx, sigxy], [sigxy, sigyy]])\\n val, vects = np.linalg.eig(covMat);\\n \\n maxEigenValue = np.amax(val) \\n minEigenValue = np.amin(val.ravel()[np.flatnonzero(val)])\\n \\n \\n elongation = math.sqrt(maxEigenValue/minEigenValue);\\n \\n \\n # principal axis\\n maxidx = np.argmax(val)\\n principalAxisVector = vects[maxidx]\\n \\n \\n return [circularity, elongation, principalAxisVector]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67644656","0.5664181","0.55579877","0.5505676","0.5449042","0.5422501","0.53664684","0.535521","0.5319952","0.53025115","0.5284908","0.5258869","0.52418005","0.52386093","0.52161735","0.5211302","0.51943326","0.5173569","0.51730245","0.51399046","0.5133151","0.51314515","0.51101196","0.50840884","0.5071955","0.5063328","0.5051881","0.5051371","0.5050778","0.5045553","0.50450057","0.50445026","0.50330406","0.502129","0.5015832","0.5013009","0.5011949","0.501095","0.5007306","0.5004419","0.50027364","0.50018954","0.49977982","0.499467","0.49945503","0.49934122","0.49892884","0.49843603","0.49643713","0.4962654","0.49508002","0.4940182","0.49275962","0.49275017","0.49125597","0.49060497","0.49054354","0.49027053","0.4898697","0.48916653","0.48905128","0.4880277","0.48754495","0.48683116","0.4863642","0.48499203","0.48485655","0.48458973","0.4842166","0.4841219","0.4838661","0.48379505","0.4823639","0.48192275","0.4817023","0.48056266","0.4801853","0.479818","0.47976515","0.4795935","0.47898996","0.4789753","0.477391","0.47678787","0.47642186","0.4763047","0.47625166","0.47576666","0.4757104","0.47563407","0.47541827","0.4753677","0.47523302","0.47511357","0.47457814","0.47421414","0.47408372","0.4730348","0.47286186","0.4722074"],"string":"[\n \"0.67644656\",\n \"0.5664181\",\n \"0.55579877\",\n \"0.5505676\",\n \"0.5449042\",\n \"0.5422501\",\n \"0.53664684\",\n \"0.535521\",\n \"0.5319952\",\n \"0.53025115\",\n \"0.5284908\",\n \"0.5258869\",\n \"0.52418005\",\n \"0.52386093\",\n \"0.52161735\",\n \"0.5211302\",\n \"0.51943326\",\n \"0.5173569\",\n \"0.51730245\",\n \"0.51399046\",\n \"0.5133151\",\n \"0.51314515\",\n \"0.51101196\",\n \"0.50840884\",\n \"0.5071955\",\n \"0.5063328\",\n \"0.5051881\",\n \"0.5051371\",\n \"0.5050778\",\n \"0.5045553\",\n \"0.50450057\",\n \"0.50445026\",\n \"0.50330406\",\n \"0.502129\",\n \"0.5015832\",\n \"0.5013009\",\n \"0.5011949\",\n \"0.501095\",\n \"0.5007306\",\n \"0.5004419\",\n \"0.50027364\",\n \"0.50018954\",\n \"0.49977982\",\n \"0.499467\",\n \"0.49945503\",\n \"0.49934122\",\n \"0.49892884\",\n \"0.49843603\",\n \"0.49643713\",\n \"0.4962654\",\n \"0.49508002\",\n \"0.4940182\",\n \"0.49275962\",\n \"0.49275017\",\n \"0.49125597\",\n \"0.49060497\",\n \"0.49054354\",\n \"0.49027053\",\n \"0.4898697\",\n \"0.48916653\",\n \"0.48905128\",\n \"0.4880277\",\n \"0.48754495\",\n \"0.48683116\",\n \"0.4863642\",\n \"0.48499203\",\n \"0.48485655\",\n \"0.48458973\",\n \"0.4842166\",\n \"0.4841219\",\n \"0.4838661\",\n \"0.48379505\",\n \"0.4823639\",\n \"0.48192275\",\n \"0.4817023\",\n \"0.48056266\",\n \"0.4801853\",\n \"0.479818\",\n \"0.47976515\",\n \"0.4795935\",\n \"0.47898996\",\n \"0.4789753\",\n \"0.477391\",\n \"0.47678787\",\n \"0.47642186\",\n \"0.4763047\",\n \"0.47625166\",\n \"0.47576666\",\n \"0.4757104\",\n \"0.47563407\",\n \"0.47541827\",\n \"0.4753677\",\n \"0.47523302\",\n \"0.47511357\",\n \"0.47457814\",\n \"0.47421414\",\n \"0.47408372\",\n \"0.4730348\",\n \"0.47286186\",\n \"0.4722074\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64999247"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93482,"cells":{"query":{"kind":"string","value":"Make 2 simplified subcontour networks, making sure that there is a 1to1 mapping between all points; this function collapses pairs of subcontours that do not match but are in between the same 4 cells"},"document":{"kind":"string","value":"def GetMatchedSubContourListsCollapsing(scListA, scListB):\n\n if (\n scListA == scListB\n ): # if we got the same object for some reason, just return 2 shallow clones\n return scListA, scListB\n\n scsMatchedInB = [] # This keeps us from looping over both lists\n\n scsMatchedInB, removeFromA, removeFromB = FindMatchesAndRemovals(scListA, scListB)\n unMatchedInB = [\n i for i in range(len(scListB)) if i not in scsMatchedInB\n ] # This lets us skip the indexes that already matched\n\n _, removeFromB_2, removeFromA_2 = FindMatchesAndRemovals(\n scListB, scListA, searchInds=unMatchedInB\n ) # FLIP\n\n removeFromA = sorted(list(set(removeFromA + removeFromA_2)))\n removeFromB = sorted(list(set(removeFromB + removeFromB_2)))\n\n scListANew = deepcopy(scListA)\n scListBNew = deepcopy(scListB)\n\n for i in removeFromA[::-1]:\n RemoveSubContour(scListA, i)\n for i in removeFromB[::-1]:\n RemoveSubContour(scListB, i)\n\n return scListANew, scListBNew"},"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 multiple_intersections():\n levels = np.array([966., 937.2, 925., 904.6, 872.6, 853., 850., 836., 821., 811.6, 782.3,\n 754.2, 726.9, 700., 648.9, 624.6, 601.1, 595., 587., 576., 555.7,\n 534.2, 524., 500., 473.3, 400., 384.5, 358., 343., 308.3, 300., 276.,\n 273., 268.5, 250., 244.2, 233., 200.]) * units.mbar\n temperatures = np.array([18.2, 16.8, 16.2, 15.1, 13.3, 12.2, 12.4, 14., 14.4,\n 13.7, 11.4, 9.1, 6.8, 4.4, -1.4, -4.4, -7.3, -8.1,\n -7.9, -7.7, -8.7, -9.8, -10.3, -13.5, -17.1, -28.1, -30.7,\n -35.3, -37.1, -43.5, -45.1, -49.9, -50.4, -51.1, -54.1, -55.,\n -56.7, -57.5]) * units.degC\n dewpoints = np.array([16.9, 15.9, 15.5, 14.2, 12.1, 10.8, 8.6, 0., -3.6, -4.4,\n -6.9, -9.5, -12., -14.6, -15.8, -16.4, -16.9, -17.1, -27.9, -42.7,\n -44.1, -45.6, -46.3, -45.5, -47.1, -52.1, -50.4, -47.3, -57.1,\n -57.9, -58.1, -60.9, -61.4, -62.1, -65.1, -65.6,\n -66.7, -70.5]) * units.degC\n return levels, temperatures, dewpoints","def sub_graph_merging(self):","def undrawGrid(draw,points,coeff2,newColorArray):\r\n ## This is the merge function.\r\n ## If two neighboring regions are considered to be the same color by the comparison function then this function replaces the black line between them by a line of their color (making it invisible).\r\n for j in range(0,coeff2-1):\r\n if comparisonFunction(newColorArray[0][j],newColorArray[0][j+1]):\r\n draw.line((points*0, points*(j+1), points*(0+1)-3, points*(j+1)), fill=newColorArray[0][j], width=lineWidth)\r\n\r\n for i in range(0,coeff2-1):\r\n if comparisonFunction(newColorArray[i][0],newColorArray[i+1][0]):\r\n draw.line((points*(i+1), points*0, points*(i+1), points*1-3), fill=newColorArray[i][0], width=lineWidth)\r\n\r\n for i in range(1,coeff2):\r\n for j in range(1,coeff2):\r\n if comparisonFunction(newColorArray[i][j],newColorArray[i][j-1]):\r\n draw.line((points*i+3, points*j, points*(i+1)-3, points*j), fill=newColorArray[i][j], width=lineWidth)\r\n\r\n if comparisonFunction(newColorArray[i][j],newColorArray[i-1][j]):\r\n draw.line((points*i, points*j+3, points*i, points*(j+1)-3), fill=newColorArray[i][j], width=lineWidth)","def GetMatchedSubContourLists(\n scListRef,\n scList,\n allValsByFrame,\n orderOfSCsByValue,\n splitLength=1,\n fixedNumInteriorPoints=None,\n):\n ## NOT DONE! MERGE LATER??\n return simplifiedSCListRef, simplifiedSCList","def addGrids(self, grid, label):\n self.grid = grid\n self.label = label\n self.H = len(grid)\n self.W = len(grid[0])\n self.visited = [[False] * self.W for _ in range(self.H)]\n self.clusters = [self._resort_size(r, c) for r, c in product(range(self.H), range(self.W)) if self.grid[r][c] != 0 and not self.visited[r][c]]\n self.subsets = []\n\n assert len(self.V) == len(self.neighbours.keys())\n\n if len(self.V) == 0 or not any(self.neighbours.values()):\n for addresstamp in self.clusters:\n footprint = Footprint(self.source, label, addresstamp)\n self.source += 1\n self.neighbours[footprint.uid] = []\n for v in self.V:\n if v.is_overlappedFootprint(footprint):\n self.E.append((v, footprint))\n self.neighbours.get(v.uid).append(footprint.uid)\n self.neighbours.get(footprint.uid).append(v.uid)\n self.resorts[v] = Resort([footprint])\n self.V.append(footprint)\n return\n\n connected_footprints = []\n for sub in self.recursive_findDenseZones(self.neighbours):\n self.subsets.append(sub)\n connected_footprints.extend(sub.getFootprintId())\n for addresstamp in self.clusters:\n footprint = Footprint(self.source, label, addresstamp)\n self.source += 1\n self.neighbours[footprint.uid] = []\n if len(addresstamp) == 1:\n self.V.append(footprint)\n continue\n new_sub = 1\n for sub in self.subsets:\n if sub.check_collision(footprint):\n new_sub = 0\n new_resort = 1\n for key, resort in sub.resorts.items():\n if resort.getLastFootprint().is_overlappedFootprint(footprint):\n new_resort = 0\n for n in resort.footprints:\n self.E.append((n, footprint))\n self.neighbours.get(n.uid).append(footprint.uid)\n self.neighbours.get(footprint.uid).append(n.uid)\n sub.resorts[key].addFootprint(footprint)\n self.resorts[key].addFootprint(footprint)\n break\n if new_resort:\n sub.resorts[footprint] = Resort([footprint])\n self.resorts[footprint] = Resort([footprint])\n break\n if new_sub:\n min_distance = sqrt(self.H**2 + self.W**2)\n closest = None\n for key, resort in self.resorts.items():\n if footprint.distance_from_resort(resort) < min_distance:\n min_distance = footprint.distance_from_resort(resort)\n closest = key\n assert closest\n for n in self.resorts[closest].footprints:\n self.E.append((n, footprint))\n self.neighbours.get(n.uid).append(footprint.uid)\n self.neighbours.get(footprint.uid).append(n.uid)\n self.V.append(footprint)","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def compute_contour_binary_masks(\n contour1: np.ndarray,\n contour2: np.ndarray,\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\n) -> typing.Tuple[np.ndarray, np.ndarray]:\n points = np.concatenate([contour1, contour2], axis=0)\n offset = points.min(axis=0)\n points, contour1, contour2 = [v - offset for v in [points, contour1, contour2]]\n scale = min(max_size / points.max(axis=0).min(), 1)\n if scale < 1:\n points, contour1, contour2 = [v * scale for v in [points, contour1, contour2]]\n w, h = points.max(axis=0).astype(\"int32\")\n im1, im2 = [\n cv2.drawContours(\n np.zeros((h, w), dtype=\"uint8\"),\n contours=(box[np.newaxis]).round().astype(\"int32\"),\n color=255,\n thickness=-1,\n contourIdx=0,\n )\n > 0\n for box in [contour1, contour2]\n ]\n return im1, im2","def voronoi_sub_mask_1d_index_to_pixeliztion_1d_index_from_grids_and_geometry(\n grid,\n mask_1d_index_to_nearest_pixelization_1d_index,\n sub_mask_1d_index_to_mask_1d_index,\n pixel_centres,\n pixel_neighbors,\n pixel_neighbors_size,\n):\n\n sub_mask_1d_index_to_pixeliztion_1d_index = np.zeros((grid.shape[0]))\n\n for sub_mask_1d_index in range(grid.shape[0]):\n\n nearest_pixelization_1d_index = mask_1d_index_to_nearest_pixelization_1d_index[\n sub_mask_1d_index_to_mask_1d_index[sub_mask_1d_index]\n ]\n\n while True:\n\n nearest_pixelization_pixel_center = pixel_centres[\n nearest_pixelization_1d_index\n ]\n\n sub_pixel_to_nearest_pixelization_distance = (\n (grid[sub_mask_1d_index, 0] - nearest_pixelization_pixel_center[0]) ** 2\n + (grid[sub_mask_1d_index, 1] - nearest_pixelization_pixel_center[1])\n ** 2\n )\n\n closest_separation_from_pixelization_to_neighbor = 1.0e8\n\n for neighbor_pixelization_1d_index in range(\n pixel_neighbors_size[nearest_pixelization_1d_index]\n ):\n\n neighbor = pixel_neighbors[\n nearest_pixelization_1d_index, neighbor_pixelization_1d_index\n ]\n\n separation_from_neighbor = (\n grid[sub_mask_1d_index, 0] - pixel_centres[neighbor, 0]\n ) ** 2 + (grid[sub_mask_1d_index, 1] - pixel_centres[neighbor, 1]) ** 2\n\n if (\n separation_from_neighbor\n < closest_separation_from_pixelization_to_neighbor\n ):\n closest_separation_from_pixelization_to_neighbor = (\n separation_from_neighbor\n )\n closest_neighbor_pixelization_1d_index = (\n neighbor_pixelization_1d_index\n )\n\n neighboring_pixelization_1d_index = pixel_neighbors[\n nearest_pixelization_1d_index, closest_neighbor_pixelization_1d_index\n ]\n sub_pixel_to_neighboring_pixelization_distance = (\n closest_separation_from_pixelization_to_neighbor\n )\n\n if (\n sub_pixel_to_nearest_pixelization_distance\n <= sub_pixel_to_neighboring_pixelization_distance\n ):\n sub_mask_1d_index_to_pixeliztion_1d_index[\n sub_mask_1d_index\n ] = nearest_pixelization_1d_index\n break\n else:\n nearest_pixelization_1d_index = neighboring_pixelization_1d_index\n\n return sub_mask_1d_index_to_pixeliztion_1d_index","def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def test_1_2_2D_cube_splits(self):\n check = [(0, 0), (1, 1), (1, 0), (0, 1), (0.5, 0.5), (0.0, 0.5),\n (0.5, 0.0),\n (0.25, 0.25), (1.0, 0.5), (0.5, 1.0), (0.75, 0.75),\n (0.75, 0.25),\n (0.25, 0.75), (0.5, 0.25), (0.25, 0.5), (0.375, 0.375),\n (0.0, 0.25),\n (0.25, 0.0), (0.125, 0.125), (0.125, 0.375), (0.375, 0.125),\n (0.5, 0.75), (0.75, 0.5), (0.625, 0.625), (1.0, 0.75),\n (0.75, 1.0),\n (0.875, 0.875), (0.875, 0.625), (0.625, 0.875), (0.625, 0.375),\n (1.0, 0.25), (0.75, 0.0), (0.875, 0.125), (0.875, 0.375),\n (0.625, 0.125), (0.375, 0.625), (0.0, 0.75), (0.25, 1.0),\n (0.125, 0.875), (0.125, 0.625), (0.375, 0.875)]\n\n nn_checks = {(0, 0): [(0.25, 0.0), (0.0, 0.25), (0.125, 0.125)],\n (0.625, 0.375): [(0.5, 0.5), (0.75, 0.25), (0.75, 0.5),\n (0.5, 0.25)],\n (0, 1): [(0.25, 1.0), (0.125, 0.875),(0.0, 0.75)],\n (0.625, 0.125): [(0.5, 0.0), (0.75, 0.25), (0.75, 0.0),\n (0.5, 0.25)]}\n\n\n init_triangulation(2, 2, check, nn_checks)","def tracklet_fast(g1: nx.graph, g2: nx.graph, seg_img1: np.ndarray, seg_img2: np.ndarray, maxtrackid: int, time: int, \n linelist: list, tracksavedir: str, cellcenter1: np.ndarray, cellcenter2: np.ndarray) \\\n -> (int, list):\n f1 = {}\n f2 = {}\n dict_associate = {}\n loc1 = g1.degree(weight=\"weight\")\n loc2 = g2.degree(weight=\"weight\")\n new_seg_img2 = np.zeros(seg_img2.shape)\n\n for ele1 in loc1:\n cell = ele1[0]\n f1[cell] = [cellcenter1[cell], ele1[1]]\n\n for ele2 in loc2:\n cell = ele2[0]\n f2[cell] = [cellcenter2[cell], ele2[1]]\n\n for cell in f2.keys():\n tmp_center = f2[cell][0]\n min_distance = seg_img2.shape[0]**2 + seg_img2.shape[1]**2 + seg_img2.shape[2]**2\n\n for ref_cell in f1.keys():\n ref_tmp_center = f1[ref_cell][0]\n distance = (tmp_center[0]-ref_tmp_center[0])**2 + (tmp_center[1] -\n ref_tmp_center[1])**2 + (tmp_center[2]-ref_tmp_center[2])**2\n if distance < min_distance:\n dict_associate[cell] = ref_cell\n min_distance = distance\n\n inverse_dict_ass = {}\n\n for cell in dict_associate:\n if dict_associate[cell] in inverse_dict_ass:\n inverse_dict_ass[dict_associate[cell]].append(cell)\n else:\n inverse_dict_ass[dict_associate[cell]] = [cell]\n\n maxtrackid = max(maxtrackid, max(inverse_dict_ass.keys()))\n\n for cell in inverse_dict_ass.keys():\n if len(inverse_dict_ass[cell]) > 1:\n for cellin2 in inverse_dict_ass[cell]:\n maxtrackid = maxtrackid + 1\n new_seg_img2[seg_img2 == cellin2] = maxtrackid\n string = '{} {} {} {}'.format(maxtrackid, time+1, time+1, cell)\n linelist.append(string)\n else:\n cellin2 = inverse_dict_ass[cell][0]\n new_seg_img2[seg_img2 == cellin2] = cell\n i = 0\n\n for line in linelist:\n i = i+1\n if i == cell:\n list_tmp = line.split()\n new_string = '{} {} {} {}'.format(list_tmp[0], list_tmp[1], time+1, list_tmp[3])\n linelist[i-1] = new_string\n\n with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:\n thread1 = executor.submit(save_img_as_tiff, seg_img1, time, tracksavedir)\n thread2 = executor.submit(save_img_as_tiff, new_seg_img2, time+1, tracksavedir)\n\n return maxtrackid, linelist","def test_1_1_2D_rec_init(self): # TODO: REMOVE FUNC AFTER SPLIT\n check = [(-1.0, -2.0), (7.0, 6.0), (7.0, -2.0), (-1.0, 6.0), (3.0, 2.0)]\n nn_checks = {(-1.0, -2.0): [(7, -2), (3.0, 2.0), (-1, 6)],\n (7.0, 6.0): [(7, -2), (3.0, 2.0), (-1, 6)],\n (7.0, -2.0): [(7, 6), (3.0, 2.0), (-1, -2)]}\n init_triangulation(2, 0, check, nn_checks, bounds=[(-1, 7), (-2, 6)])","def prepareConjMap(self):\n\n # Convert nullbits count into binary\n self.nullbits = [int(x) for x in np.binary_repr(\n self.nullbits).zfill(self.gridSize)]\n\n # Add nullbits count at the start of conjMap\n self.conjMap = self.nullbits + self.conjMap\n\n # Add trash bits to conjMap at appropriate intervals\n tmparr = []\n while self.conjMap:\n self.conjMap = self.tb + self.conjMap\n b = self.conjMap[:self.gridSize * self.gridSize]\n self.conjMap = self.conjMap[len(b):]\n while len(b) < self.gridSize*self.gridSize:\n b.append(0)\n b = np.array(b).reshape((self.gridSize, self.gridSize))\n tmparr.append(b)\n\n self.conjMap = np.array(tmparr)","def merge_nodes(self,n0,n1):\n # -- Sanity checks - does not yet allow for collapsing edges.\n\n # if they share any cells, would update the cells, but for now\n # just signal failure.\n n0_cells=list(self.node_to_cells(n0))\n n1_cells=list(self.node_to_cells(n1))\n cell_to_edge_cache={}\n\n for c in n1_cells:\n if c in n0_cells:\n print(\"cell %d common to both nodes\"%c)\n raise GridException(\"Not ready for merging nodes in the same cell\")\n # otherwise record and fix up below\n\n # while we're looping, cache the edges as they will\n # be mutated along the way.\n cell_to_edge_cache[c]=self.cell_to_edges(c).copy()\n\n # do they share an edge, but not already fixed in the above stanza?\n j=self.nodes_to_edge(n0,n1)\n if j is not None:\n raise GridException(\"Not ready for merging endpoints of an edge\")\n\n edge_map={} # index of superceded edge => superceding edge\n\n # Update edges of n1 to point to n0\n # if that would cause a duplicate edge, then the n1 version is deleted\n n1_edges=list(self.node_to_edges(n1)) # make copy since we'll mutate it\n for j in n1_edges:\n if self.edges['nodes'][j,0]==n1:\n nj=0\n elif self.edges['nodes'][j,1]==n1:\n nj=1\n else:\n assert False # sanity check\n newnodes=self.edges[j]['nodes'].copy()\n newnodes[nj]=n0\n # it's possible that this is an edge which already exists\n jother=self.nodes_to_edge(*newnodes)\n if jother is not None:\n # want to keep jother, delete j. but is there info on\n # cells which should be brought over?\n edge_map[j]=jother\n # wait to delete j until after cells have been moved to jother.\n else:\n self.log.debug(\"Modifying edge j=%d\"%j)\n self.modify_edge(j,nodes=newnodes)\n\n # -- Transition any cells. \n for c in n1_cells:\n # update the node list:\n cnodes=self.cell_to_nodes(c).copy()\n nc=list(cnodes).index(n1)\n cnodes[nc]=n0\n\n # Dangerous to use cell_to_edges, since it may\n # have to consult the edge topology, which is disrupted\n # in the above code. \n # cell_to_edges: first checks cells['edges'], may \n # go to cell_to_nodes(c): that's safe.\n # and nodes_to_edge\n # -> node_to_edges, which in turn may consult self.edges['nodes']\n\n #cedges=self.cell_to_edges(c).copy()\n cedges=cell_to_edge_cache[c]\n\n for ji,j in enumerate(cedges):\n if j in edge_map:\n # is there were edges['cells'] should be updated?\n\n # sever the edge=>cell pointer, to p\n # could just set to [-1,-1], but this keeps things very explicit\n # for debugging\n j_cells=list(self.edges['cells'][j])\n j_cells_side=j_cells.index(c)\n j_cells[ j_cells_side ] = -1\n self.modify_edge(j,cells=j_cells)\n\n # and modify the receiving edge, too\n jo=edge_map[j]\n jo_cells=list(self.edges['cells'][jo])\n # which side of jo? a bit tedious...\n if list(self.edges['nodes'][j]).index(n1) == list(self.edges['nodes'][jo]).index(n0):\n # same orientation\n jo_cells_side=j_cells_side\n elif list( self.edges['nodes'][j]).index(n1) == 1-list(self.edges['nodes'][jo]).index(n0):\n jo_cells_side=1-j_cells_side\n else:\n raise Exception(\"Failed in some tedium\")\n assert jo_cells[jo_cells_side]<0\n jo_cells[jo_cells_side]=c\n self.modify_edge(edge_map[j],cells=jo_cells)\n # yikes. any chance that worked?\n\n cedges[ji]=edge_map[j]\n\n # maybe this is where we'd update cells['edges'] too?\n self.modify_cell(c,nodes=cnodes,edges=cedges)\n\n for dead_edge in edge_map:\n self.delete_edge(dead_edge)\n\n self.delete_node(n1)","def get_overlapping_conn(conn1: NDArray,\n conn2: NDArray) -> Tuple[NDArray, NDArray]:\n\n conn_union = np.empty((0, 3), dtype=np.int32)\n\n # Get unique components\n if np.ma.is_masked(conn1):\n concomp1 = np.unique(conn1).compressed()\n else:\n concomp1 = np.unique(conn1)\n\n if np.ma.is_masked(conn2):\n concomp2 = np.unique(conn2).compressed()\n else:\n concomp2 = np.unique(conn2)\n\n # Loop through them and connect size and number of overlapping data\n for ix2 in concomp2:\n for ix1 in concomp1:\n # Skip 0 component combination with other components\n if not ix1 == 0 and not ix2 == 0:\n idx = np.where((conn1 == ix1) & (conn2 == ix2))[0]\n if np.count_nonzero(idx) > 0:\n carray = np.array([ix2, ix1, np.count_nonzero(idx)],\n dtype=np.int32, ndmin=2)\n\n conn_union = np.concatenate((conn_union, carray), axis=0)\n\n # Get 0 components in both frames\n elif ix1 == 0 and ix2 == 0:\n idx = np.where((conn1 == ix2) & (conn2 == ix1))[0]\n if np.count_nonzero(idx) > 0:\n carray = np.array([ix2, ix1, np.count_nonzero(idx)],\n dtype=np.int32, ndmin=2)\n\n conn_union = np.concatenate((conn_union, carray), axis=0)\n\n # Find components to correct in Frame 2\n conn_pairs = np.empty((0, 3), dtype=np.int32)\n\n for k in np.unique(conn_union[:, 0]):\n ik = conn_union[:, 0] == k\n # find number of times components is referenced\n count = np.sum(conn_union[:, 0] == k)\n\n if count > 1:\n max_points = np.max(conn_union[ik][:, 2])\n # Select the one with the most points\n ik = np.where((conn_union[:, 0] == k) &\n (conn_union[:, 2] == max_points))[0]\n # Select first if there are more pairs with same num of points\n ik = np.array(ik[0], ndmin=1) if ik.shape[0] > 1 else ik\n\n conn_pairs = np.concatenate((conn_pairs, conn_union[ik]), axis=0)\n\n return conn_pairs","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 test():\n test_map1 = np.array([\n [1, 1, 1, 1, 1, 1, 1, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1]])\n x_spacing1 = 0.13\n y_spacing1 = 0.2\n start1 = np.array([[0.3], [0.3], [0]])\n goal1 = np.array([[0.6], [1], [0]])\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\n true_path1 = np.array([\n [ 0.3 , 0.3 ],\n [ 0.325, 0.3 ],\n [ 0.325, 0.5 ],\n [ 0.325, 0.7 ],\n [ 0.455, 0.7 ],\n [ 0.455, 0.9 ],\n [ 0.585, 0.9 ],\n [ 0.600, 1.0 ]\n ])\n if np.array_equal(path1,true_path1):\n print(\"Path 1 passes\")\n\n test_map2 = np.array([\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [1, 1, 1, 1, 1, 1, 1, 1],\n [1, 0, 0, 1, 1, 0, 0, 1],\n [1, 0, 0, 1, 1, 0, 0, 1],\n [1, 0, 0, 1, 1, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 0, 0, 0, 0, 0, 0, 1],\n [1, 1, 1, 1, 1, 1, 1, 1]])\n start2 = np.array([[0.5], [1.0], [1.5707963267948966]])\n goal2 = np.array([[1.1], [0.9], [-1.5707963267948966]])\n x_spacing2 = 0.2\n y_spacing2 = 0.2\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\n true_path2 = np.array([[ 0.5, 1.0],\n [ 0.5, 1.1],\n [ 0.5, 1.3],\n [ 0.5, 1.5],\n [ 0.7, 1.5],\n [ 0.9, 1.5],\n [ 1.1, 1.5],\n [ 1.1, 1.3],\n [ 1.1, 1.1],\n [ 1.1, 0.9]])\n if np.array_equal(path2,true_path2):\n print(\"Path 2 passes\")","def mergeRoundaboutChunks(segments):\n \n roundabouts = segments[segments.tag.apply(lambda x : ('junction' in x and(x['junction'] in ['circular','roundabout'] )))]\n roundabouts=roundabouts.nodes.apply(lambda x : pd.Series((x[0],x[-1]),index=['in','out']))\n roundabouts=roundabouts[roundabouts['in']!=roundabouts['out']]\n incopmleteRoundabouts = roundabouts[~roundabouts['in'].isin(roundabouts['out'])].index.values\n while(len(incopmleteRoundabouts)!=0):\n roundabouts.drop(incopmleteRoundabouts,inplace=True)\n incopmleteRoundabouts = roundabouts[~roundabouts['in'].isin(roundabouts['out'])].index.values\n\n\n def getRoundaboutFromChunks(startSeg,chunks):\n \"\"\"\n connect roundabout chunks\n \"\"\"\n \n sequence=[startSeg]\n nextIndex=startSeg\n while len(sequence)<=1 or sequence[0]!=sequence[-1]:\n outValue = chunks.loc[nextIndex]['out']\n nextIndex = chunks[chunks['in']==outValue].index[0]\n sequence.append(nextIndex)\n return sequence[:-1]\n\n sequences=roundabouts.index.map(lambda x : getRoundaboutFromChunks(x,roundabouts))\n\n sequences=pd.Series(sequences)\n\n sequences = sequences.groupby(lambda x : sorted(sequences.loc[x])[0]).first()\n\n sequences=sequences.apply(lambda x : np.concatenate([ segments.nodes.loc[seg] for seg in x]).tolist())\n \n segments.drop(roundabouts.loc[~roundabouts.index.isin(sequences.index)].index,inplace=True)\n for idx in sequences.index:\n segments.at[idx,'nodes']=sequences.loc[idx]","def create_jointsmap(uv_coord, size):\r\n\r\n\t# define connections and colors of the bones\r\n\t# print(coords_hw[-1]) # this is center ( the 22nd point)\r\n\tcanvas = np.zeros((size, size, 3))\r\n\tbones = [\r\n\t\t((1, 2), THUMB_COLOR1),\r\n\t\t((2, 3), THUMB_COLOR2),\r\n\t\t((3, 4), THUMB_COLOR3),\r\n\r\n\t\t((5, 6), INDEX_COLOR1),\r\n\t\t((6, 7), INDEX_COLOR2),\r\n\t\t((7, 8), INDEX_COLOR3),\r\n\r\n\t\t((9, 10), MIDDLE_COLOR1),\r\n\t\t((10, 11), MIDDLE_COLOR2),\r\n\t\t((11, 12), MIDDLE_COLOR3),\r\n\r\n\t\t((13, 14), RING_COLOR1),\r\n\t\t((14, 15), RING_COLOR2),\r\n\t\t((15, 16), RING_COLOR3),\r\n\r\n\t\t((17, 18), PINKY_COLOR1),\r\n\t\t((18, 19), PINKY_COLOR2),\r\n\t\t((19, 20), PINKY_COLOR3)]\r\n\tpalm = []\r\n\tfor connection, _ in [((0, 1), []),\r\n\t\t\t\t\t\t ((1, 5), []),\r\n\t\t\t\t\t\t ((5, 9), []),\r\n\t\t\t\t\t\t ((9, 13), []),\r\n\t\t\t\t\t\t ((13, 17), []),\r\n\t\t\t\t\t\t ((17, 0), []), ]:\r\n\t\tcoord1 = uv_coord[connection[0]]\r\n\t\tpalm.append([int(coord1[0]), int(coord1[1])])\r\n\t# palm.append([int((coord1[0]-.5)* W_scale+ W_offset ), int(-(coord1[1]- .5)* H_scale+ H_offset)])\r\n\t# print(palm)\r\n\tcv2.fillConvexPoly(canvas, np.array([palm], dtype=np.int32), PALM_COLOR)\r\n\tfor connection, color in bones:\r\n\t\tcoord1 = uv_coord[connection[0]]\r\n\t\tcoord2 = uv_coord[connection[1]]\r\n\t\tcoords = np.stack([coord1, coord2])\r\n\t\t# 0.5, 0.5 is the center\r\n\t\tx = coords[:, 0]\r\n\t\ty = coords[:, 1]\r\n\t\tmX = x.mean()\r\n\t\tmY = y.mean()\r\n\t\tlength = ((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** 0.5\r\n\t\tangle = np.math.degrees(np.math.atan2(y[0] - y[1], x[0] - x[1]))\r\n\t\tpolygon = cv2.ellipse2Poly((int(mX), int(mY)), (int(length / 2), 16), int(angle), 0, 360, 1)\r\n\t\tcv2.fillConvexPoly(canvas, polygon, color)\r\n\treturn canvas","def handle_diagonals_crossing_connections(self, conn: Connection):\n if not self.is_connection_diagonal(conn):\n return False\n j1 = self.get_junc_from_node(conn.me)\n j2 = self.get_junc_from_node(conn.other)\n # check if top-left to bottom-right diagonal of top-right to bottom-left diagonal\n indices_diff = (j1.indices.row - j2.indices.row, j1.indices.col - j2.indices.col)\n if indices_diff[0] == indices_diff[1]:\n # top-left to bottom-right\n top_left = j1 if indices_diff[0] == -1 else j2 # else diff is 1\n top_right = self.get_junc((top_left.indices.row, top_left.indices.col + 1))\n bottom_left = self.get_junc((top_left.indices.row + 1, top_left.indices.col))\n if self.are_juncs_connected(top_right, bottom_left):\n # print(conn, top_right, bottom_left, sep=\"\\n\")\n # we should remove the connection.\n if bottom_left.right.node_id in top_right.down.get_connections_ids():\n top_right.down.remove_connection_by_id(bottom_left.right.node_id)\n if bottom_left.up.node_id in top_right.left.get_connections_ids():\n top_right.left.remove_connection_by_id(bottom_left.up.node_id)\n else:\n # top-right to bottom-left\n top_right = j1 if indices_diff[0] == -1 else j2 # else diff is 1\n top_left = self.get_junc((top_right.indices.row, top_right.indices.col - 1))\n bottom_right = self.get_junc((top_right.indices.row + 1, top_right.indices.col))\n if self.are_juncs_connected(top_left, bottom_right):\n # print(conn, top_left, bottom_right, sep=\"\\n\")\n # we should remove the connection.\n if bottom_right.left.node_id in top_left.down.get_connections_ids():\n top_left.down.remove_connection_by_id(bottom_right.left.node_id)\n if bottom_right.up.node_id in top_left.right.get_connections_ids():\n top_left.right.remove_connection_by_id(bottom_right.up.node_id)","def stitch_unw2frames(unw_data1: NDArray, conn_data1: NDArray, rdict1: dict,\n unw_data2: NDArray, conn_data2: NDArray, rdict2: dict,\n correction_method: Optional[str] = 'cycle2pi',\n range_correction: Optional[bool] = False,\n verbose: Optional[bool] = False) -> \\\n Tuple[NDArray, NDArray, dict]:\n\n # Adjust connected Component in Frame 2 to start\n # with last component number in Frame-1\n\n conn_data2 = conn_data2 + np.nanmax(conn_data1)\n conn_data2[conn_data2 == np.nanmax(conn_data1)] = 0.0\n\n # GET FRAME OVERLAP\n box_1, box_2 = frame_overlap(\n rdict1['SNWE'], rdict2['SNWE'],\n [rdict1['LAT_SPACING'], rdict1['LON_SPACING']],\n [rdict2['LAT_SPACING'], rdict2['LON_SPACING']])\n\n # LOOP OVER COMPONENTS WITHIN THE OVERLAP\n # Get connected component pairs\n if verbose:\n print('\\nGetting overlapping components')\n\n # Forward correction\n conn_pairs = get_overlapping_conn(conn_data1[box_1],\n conn_data2[box_2])\n\n for pair in conn_pairs:\n diff, cycles2pi, range_corr = _integer_2pi_cycles(\n unw_data1[box_1],\n conn_data1[box_1],\n np.float32(pair[1]),\n unw_data2[box_2],\n conn_data2[box_2],\n np.float32(pair[0]),\n range_correction=range_correction,\n print_msg=verbose)\n\n # Correction methods: mean difference, 2pi integer cycles\n if correction_method == 'cycle2pi':\n correction = cycles2pi\n elif correction_method == 'meanoff':\n correction = diff\n range_correction = False\n else:\n raise ValueError(f'Wrong correction method {correction_method}, ',\n 'Select one of available: \"cycle2pi\", \"meanoff\"')\n\n # add range correction\n if range_correction:\n correction += range_corr\n ik = conn_data2 == np.float32(pair[0])\n unw_data2[ik] += correction\n conn_data2[ik] = np.float32(pair[1])\n\n # Backward correction\n conn_reverse = get_overlapping_conn(conn_data2[box_2],\n conn_data1[box_1])\n\n # Keep only different componentes in pairing\n ik = np.where(conn_reverse[:, 0] != conn_reverse[:, 1])\n conn_reverse = conn_reverse[ik]\n\n for pair in conn_reverse:\n print('Going backward!') if verbose else None\n diff, cycles2pi, range_corr = _integer_2pi_cycles(\n unw1=unw_data1[box_1],\n concom1=conn_data1[box_1],\n ix1=np.float32(pair[0]),\n unw2=unw_data2[box_2],\n concom2=conn_data2[box_2],\n ix2=np.float32(pair[1]),\n range_correction=range_correction,\n print_msg=verbose)\n\n # Correction methods: mean difference, 2pi integer cycles\n if correction_method == 'cycle2pi':\n correction = cycles2pi\n elif correction_method == 'meanoff':\n correction = diff\n range_correction = False\n else:\n raise ValueError(f'Wrong correction method {correction_method}, ',\n 'Select one of available: \"cycle2pi\", \"meanoff\"')\n\n # add range correction\n if range_correction:\n correction += range_corr\n\n ik = conn_data1 == np.float32(pair[0])\n unw_data1[ik] -= correction\n conn_data1[ik] = np.float32(pair[1])\n\n # Update connected component frame 2 naming\n idx1 = np.max(conn_data1)\n idx = np.unique(conn_data2[conn_data2 > idx1]).compressed()\n conn_data2 = update_connect_components(conn_data2, idx, idx1+1)\n\n # Combine corrected unwrappedPhase and connectedComponents arrays\n comb_snwe = [rdict1['SNWE'], rdict2['SNWE']]\n comb_latlon = [[rdict1['LAT_SPACING'], rdict1['LON_SPACING']],\n [rdict2['LAT_SPACING'], rdict2['LON_SPACING']]]\n\n (combined_unwrap,\n combined_snwe,\n combined_latlon_spacing) = combine_data_to_single(\n [_nan_filled_array(unw_data1),\n _nan_filled_array(unw_data2)],\n comb_snwe, comb_latlon,\n method='mean')\n combined_conn, _, _ = combine_data_to_single(\n [_nan_filled_array(conn_data1),\n _nan_filled_array(conn_data2)],\n comb_snwe, comb_latlon,\n method='min')\n # combined dict\n combined_dict = dict(SNWE=combined_snwe,\n LAT_SPACING=combined_latlon_spacing[0],\n LON_SPACING=combined_latlon_spacing[1])\n\n combined_unwrap = np.ma.masked_invalid(combined_unwrap)\n np.ma.set_fill_value(combined_unwrap, 0.)\n combined_conn = np.ma.masked_invalid(combined_conn)\n np.ma.set_fill_value(combined_conn, -1.)\n\n return combined_unwrap, combined_conn, combined_dict","def find_optimal_components_subset(contours, edges):\n c_info = props_for_contours(contours, edges)\n c_info.sort(key=lambda x: -x['sum'])\n total = np.sum(edges) / 255\n area = edges.shape[0] * edges.shape[1]\n\n c = c_info[0]\n del c_info[0]\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\n crop = this_crop\n covered_sum = c['sum']\n\n while covered_sum < total:\n changed = False\n recall = 1.0 * covered_sum / total\n prec = 1 - 1.0 * crop_area(crop) / area\n f1 = 2 * (prec * recall / (prec + recall))\n # print '----'\n for i, c in enumerate(c_info):\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\n new_crop = union_crops(crop, this_crop)\n new_sum = covered_sum + c['sum']\n new_recall = 1.0 * new_sum / total\n new_prec = 1 - 1.0 * crop_area(new_crop) / area\n new_f1 = 2 * new_prec * new_recall / (new_prec + new_recall)\n\n # Add this crop if it improves f1 score,\n # _or_ it adds 25% of the remaining pixels for <15% crop expansion.\n # ^^^ very ad-hoc! make this smoother\n remaining_frac = c['sum'] / (total - covered_sum)\n new_area_frac = 1.0 * crop_area(new_crop) / crop_area(crop) - 1\n if new_f1 > f1 or (\n remaining_frac > 0.25 and new_area_frac < 0.15):\n print('%d %s -> %s / %s (%s), %s -> %s / %s (%s), %s -> %s' % (\n i, covered_sum, new_sum, total, remaining_frac,\n crop_area(crop), crop_area(new_crop), area, new_area_frac,\n f1, new_f1))\n crop = new_crop\n covered_sum = new_sum\n del c_info[i]\n changed = True\n break\n\n if not changed:\n break\n\n return crop","def compute_coverage_for_contour_pair(\n contour1: np.ndarray,\n contour2: np.ndarray,\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\n):\n im1, im2 = compute_contour_binary_masks(contour1, contour2, max_size=max_size)\n return (im1 & im2).sum() / im1.sum()","def test_1_2_2D_rec_splits(self):\n check = [(3.0, -2.0), (7.0, -1.0), (7.0, -2.0), (3.0, -1.0),\n (5.0, -1.5), (3.0, -1.5), (5.0, -2.0), (4.0, -1.75),\n (7.0, -1.5), (5.0, -1.0), (6.0, -1.25), (6.0, -1.75),\n (4.0, -1.25), (5.0, -1.75), (4.0, -1.5), (4.5, -1.625),\n (3.0, -1.75), (4.0, -2.0), (3.5, -1.875), (3.5, -1.625),\n (4.5, -1.875), (5.0, -1.25), (6.0, -1.5), (5.5, -1.375),\n (7.0, -1.25), (6.0, -1.0), (6.5, -1.125), (6.5, -1.375),\n (5.5, -1.125), (5.5, -1.625), (7.0, -1.75), (6.0, -2.0),\n (6.5, -1.875), (6.5, -1.625), (5.5, -1.875), (4.5, -1.375),\n (3.0, -1.25), (4.0, -1.0), (3.5, -1.125), (3.5, -1.375),\n (4.5, -1.125)]\n nn_checks = {(3.0, -2.0): [(3.0, -1.75), (3.5, -1.875), (4.0, -2.0)],\n (5.0, -1.75): [(5.0, -2.0), (5.0, -1.5), (5.5, -1.625),\n (5.5, -1.875), (4.5, -1.625), (6.0, -1.75),\n (4.5, -1.875), (4.0, -1.75)],\n (6.0, -2.0): [(5.0, -2.0), (5.5, -1.875), (6.0, -1.75),\n (6.5, -1.875), (7, -2)],\n (4.5, -1.125): [(5.0, -1.0), (4.0, -1.25), (5.0, -1.25),\n (4.0, -1.0)]}\n\n init_triangulation(2, 2, check, nn_checks, bounds=[(3, 7), (-2, -1)])","def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\n # number of nodes\n nx = 5 # along x\n ny = 5 # along y\n\n # getting integration points\n nint = 4\n points, weights = get_points_weights(nint=nint)\n\n # geometry\n a = 3 # along x\n b = 3 # along y\n\n # material properties\n E = 200e9\n nu = 0.3\n laminaprop = (E, E, nu)\n stack = [0]\n h = 0.001\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\n\n # creating mesh\n x = np.linspace(0, a, nx)\n y = np.linspace(0, b, ny)\n xmesh, ymesh = np.meshgrid(x, y)\n\n # node coordinates and position in the global matrix\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\n nids = 1 + np.arange(ncoords.shape[0])\n nid_pos = dict(zip(nids, np.arange(len(nids))))\n\n # identifying nodal connectivity for plate elements\n # similar than Nastran's CQUAD4\n #\n # ^ y\n # |\n #\n # 4 ________ 3\n # | |\n # | | --> x\n # | |\n # |_______|\n # 1 2\n\n\n nids_mesh = nids.reshape(nx, ny)\n n1s = nids_mesh[:-1, :-1].flatten()\n n2s = nids_mesh[1:, :-1].flatten()\n n3s = nids_mesh[1:, 1:].flatten()\n n4s = nids_mesh[:-1, 1:].flatten()\n\n num_elements = len(n1s)\n print('num_elements', num_elements)\n\n N = DOF*nx*ny\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n init_k_KC0 = 0\n init_k_KG = 0\n\n plates = []\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\n plate = BFSPlate2D()\n plate.n1 = n1\n plate.n2 = n2\n plate.n3 = n3\n plate.n4 = n4\n plate.c1 = DOF*nid_pos[n1]\n plate.c2 = DOF*nid_pos[n2]\n plate.c3 = DOF*nid_pos[n3]\n plate.c4 = DOF*nid_pos[n4]\n plate.ABD = lam.ABD\n plate.lex = a/(nx - 1)\n plate.ley = b/(ny - 1)\n plate.init_k_KC0 = init_k_KC0\n plate.init_k_KG = init_k_KG\n update_KC0(plate, points, weights, Kr, Kc, Kv)\n init_k_KC0 += KC0_SPARSE_SIZE\n init_k_KG += KG_SPARSE_SIZE\n plates.append(plate)\n\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\n\n # applying boundary conditions\n\n # locating nodes\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\n\n x = ncoords[:, 0]\n y = ncoords[:, 1]\n\n # applying boundary conditions\n # simply supported\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\n bk[2::DOF] = check\n check = isclose(x, 0) | isclose(x, a)\n bk[3::DOF] = check\n # point supports\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\n bk[0::DOF] = check\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\n bk[1::DOF] = check\n\n # unconstrained nodes\n bu = ~bk # logical_not\n\n # defining external force vector\n fext = np.zeros(KC0.shape[0], dtype=float)\n\n # applying unitary load along u at x=a\n # nodes at vertices get 1/2 the force\n for plate in plates:\n pos1 = nid_pos[plate.n1]\n pos2 = nid_pos[plate.n2]\n pos3 = nid_pos[plate.n3]\n pos4 = nid_pos[plate.n4]\n if isclose(x[pos3], a):\n Nxx = -1\n xi = +1\n elif isclose(x[pos1], 0):\n Nxx = +1\n xi = -1\n else:\n continue\n lex = plate.lex\n ley = plate.ley\n indices = []\n c1 = DOF*pos1\n c2 = DOF*pos2\n c3 = DOF*pos3\n c4 = DOF*pos4\n cs = [c1, c2, c3, c4]\n for ci in cs:\n for i in range(DOF):\n indices.append(ci + i)\n fe = np.zeros(4*DOF, dtype=float)\n for j in range(nint):\n eta = points[j]\n plate.update_Nu(xi, eta)\n Nu = np.asarray(plate.Nu)\n fe += ley/2*weights[j]*Nu*Nxx\n fext[indices] += fe\n\n Kuu = KC0[bu, :][:, bu]\n fextu = fext[bu]\n\n # static solver\n uu = spsolve(Kuu, fextu)\n u = np.zeros(KC0.shape[0], dtype=float)\n u[bu] = uu\n\n if plot_static:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n uplot = u[0::DOF].reshape(nx, ny).T\n vplot = u[1::DOF].reshape(nx, ny).T\n print('u extremes', uplot.min(), uplot.max())\n print('v extremes', vplot.min(), vplot.max())\n levels = np.linspace(uplot.min(), uplot.max(), 300)\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n # eigenvalue solver\n\n # getting integration points\n for plate in plates:\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\n KGuu = KG[bu, :][:, bu]\n\n # solving modified generalized eigenvalue problem\n # Original: (KC0 + lambda*KG)*v = 0\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\n num_eigenvalues = 5\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\n tol=1e-6, sigma=1., mode='cayley')\n eigvals = -1./eigvals\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\n eigvecs[bu, :] = eigvecsu\n\n if plot_lb:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n mode = 0\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\n levels = np.linspace(wplot.min(), wplot.max(), 300)\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\n assert isclose(kc, 6.6, rtol=0.05)","def threeRoadConnect(data, x1, y1, x2, y2):\n temp_data = np.pad(data, (1, 1), 'constant', constant_values=0)\n # init\n points = [[x1, y1]]\n flagX = False\n flagY = False\n if not data[y1][x1] == data[y2][x2]:\n return False, []\n # Two lines parallel to the X-AXIS\n posX = 0\n for i in range(0, 18):\n if temp_data[y1 + 1][i] == 0 and temp_data[y2 + 1][i] == 0:\n if XRoadConnect(temp_data, i, y1 + 1, x1 + 1, y1 + 1) \\\n and XRoadConnect(temp_data, i, y2 + 1, x2 + 1, y2 + 1) \\\n and YRoadConnect(temp_data, i, y1 + 1, i, y2 + 1):\n flagX = True\n posX = i - 1\n if flagX:\n points.append([posX, y1])\n points.append([posX, y2])\n\n # Two lines parallel to the Y-AXIS\n posY = 0\n for i in range(0, 10):\n if temp_data[i][x1 + 1] == 0 and temp_data[i][x2 + 1] == 0:\n if YRoadConnect(temp_data, x1 + 1, i, x1 + 1, y1 + 1) \\\n and YRoadConnect(temp_data, x2 + 1, i, x2 + 1, y2 + 1) \\\n and XRoadConnect(temp_data, x1 + 1, i, x2 + 1, i):\n flagY = True\n posY = i - 1\n if flagY and flagX == False:\n points.append([x1, posY])\n points.append([x2, posY])\n\n if flagX or flagY:\n data[y1][x1] = data[y2][x2] = 0\n points.append([x2, y2])\n print(data)\n print(3)\n return flagX or flagY, points","def simplify(self):\n \n added_clumps = []\n staying_tunnels = []\n removed_clumps = set()\n \n for tunnel in self.tunnels:\n tunnel_end_distance = self.get_distance(tunnel.start, tunnel.end)\n if tunnel_end_distance - tunnel.start.distance_from_wall < 0 or \\\n tunnel_end_distance - tunnel.end.distance_from_wall < 0:\n removed_clumps.add(tunnel.start.node)\n removed_clumps.add(tunnel.end.node)\n new_node = tunnel.merge_endpoints()\n added_clumps.append(new_node)\n else:\n staying_tunnels.append(tunnel)\n #print removed_clumps\n \n new_clumps = []\n \n for clump in list(self.clumps) + added_clumps:\n if clump not in removed_clumps:\n new_clumps.append(clump)\n else:\n removed_clumps.remove(clump)\n\n if removed_clumps:\n raise Exception(\"Some removed clumps couldn't be found in the main set and I'm scared\")\n \n self.clumps = new_clumps\n self.tunnels = staying_tunnels","def coupled_decomposition(sdata, ddata, sorigin=(), dorigin=(), M=4, sub_skp=None):\n\n soriginx, soriginy = sorigin\n doriginx, doriginy = dorigin\n\n # Create membership arrays for each input image\n smembership = np.ones(sdata.shape)\n dmembership = np.ones(ddata.shape)\n\n # Project the image into a polar coordinate system centered on p_{1}\n stheta = reproject_image_into_polar(sdata, origin=(int(soriginx), int(soriginy)))\n dtheta = reproject_image_into_polar(ddata, origin=(int(doriginx), int(doriginy)))\n\n # Compute the mean profiles for each radial slice\n smean = np.empty(RADIAL_SIZE)\n dmean = np.empty(RADIAL_SIZE)\n for i, t in enumerate(THETAS):\n # The way this method words, it is possible to get nan values in some of the steps as this is discrete\n smean[i] = np.mean(sdata[(t <= stheta) & (stheta <= t + RADIAL_STEP)])\n dmean[i] = np.mean(ddata[(t <= dtheta) & (dtheta <= t + RADIAL_STEP)])\n\n # Rotate the second image around the origin and compute the correlation coeff. for each 0.5 degree rotation.\n maxp = -1\n maxidx = 0\n for j in range(RADIAL_SIZE):\n dsearch = np.concatenate((dmean[j:], dmean[:j]))\n r, p = pearsonr(smean, dsearch)\n if r >= maxp:\n maxp = r\n maxidx = j\n\n # Maximum correlation (theta) defines the angle of rotation for the destination image\n theta = THETAS[maxidx]\n\n if theta <= np.pi:\n lam = theta\n else:\n lam = 2 * np.pi - theta\n\n # Classify the sub-images based on the decomposition size (M) and theta\n breaks = np.linspace(0, 2 * np.pi, M + 1)\n for i, t in enumerate(breaks[:-1]):\n smembership[(t <= stheta) & ( stheta <= breaks[i+1])] = i\n\n for i, t in enumerate(breaks[:-1]):\n # Handle the boundary crossers\n start_theta = t + theta\n stop_theta = breaks[i + 1] + theta\n\n if stop_theta > 2 * np.pi:\n stop_theta -= 2 * np.pi\n if start_theta > 2 * np.pi:\n start_theta -= 2 * np.pi\n\n if start_theta > stop_theta:\n # Handles the case where theta is a negative rotation\n dmembership[(start_theta <= dtheta) & (dtheta <= 2 * np.pi)] = i\n dmembership[(0 <= dtheta) * dtheta <= stop_theta + lam] = i\n dmembership[(start_theta <= dtheta) & (dtheta <= stop_theta)] = i\n else:\n # Handles the standard case without boundary crossers\n dmembership[(start_theta <= dtheta) & (dtheta <= stop_theta)] = i\n\n return smembership, dmembership","def interpop_connections(mat_connections, n_mitral, n_subpop, n_mitral_per_subpop, inter_conn_rate, inter_conn_strength, homeostasy=False):\n if homeostasy:\n init_total = 1.*mat_connections.sum(axis=0)\n tr_init_total = 1.*mat_connections.sum(axis=1)\n\n res_mat = mat_connections\n n_granule = n_subpop\n subpop_start = np.zeros((n_subpop)) # which is the first non interconnected mitral from each subpop\n for mtpop in inter_conn_rate:\n assert mtpop >= 0 and mtpop < n_subpop, \\\n \"Incorrect mitral sub-population number \"+str(mtpop)+\" for inter-connectivity.\"\n for grpop in inter_conn_rate[mtpop]:\n if grpop != mtpop:\n assert grpop >= 0 and grpop < n_granule, \\\n \"Incorrect granule sub-population number \"+str(grpop)+\" for inter-connectivity.\"\n conn = inter_conn_rate[mtpop][grpop]\n assert conn >= 0 and conn <= 1, \"Connectivity must be in [0, 1].\"\n nlinks = int(n_mitral_per_subpop*conn)\n newconn = np.zeros((n_mitral_per_subpop, 1))\n for i in xrange(nlinks):\n try:\n newconn[i + subpop_start[mtpop]] = inter_conn_strength[mtpop][grpop]\n except Exception, e:\n print \"Likely, too much connections to have no overlap, rewrite the code !\"\n print \"EXCEPTION:\", e\n exit(1)\n subpop_start[mtpop] += nlinks\n start = mtpop*n_mitral_per_subpop\n stop = start + n_mitral_per_subpop\n res_mat[start:stop, grpop] = newconn[:, 0]\n \n if not(homeostasy):\n return res_mat, res_mat.transpose()\n else:\n # Connection strengthes are normalized such that each neuron (mitral or granule) receive the same total amount of excitation or inhibition \n # (i.e. the same total of synaptic conductance) as if they were no interglomerular connections\n tr_res_mat = res_mat.transpose().copy()\n tr_res_mat_norm = tr_init_total/tr_res_mat.sum(axis=0) # here the numerator is 1. because there is only one granule\n tr_res_mat = tr_res_mat*tr_res_mat_norm\n res_mat_norm = init_total/res_mat.sum(axis=0)\n res_mat = res_mat*res_mat_norm\n return res_mat, tr_res_mat","def sort_filtered_contours(self):\r\n\r\n # Get the contours again\r\n invert = 255 - self.thresh_invert\r\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\r\n\r\n # Make sure that they're within the correct range for size\r\n # If too small, it is probably noise; if too large, then should be things around the grid\r\n for i, c in enumerate(real_contours, 1):\r\n contour_area = cv2.contourArea(c)\r\n if self.min_cell_size < contour_area < self.max_cell_size:\r\n self.good_contours.append(c)\r\n\r\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\r\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\r\n\r\n # Sort the contours from top to bottom\r\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\"top-to-bottom\")\r\n\r\n # We then sort each row from left to right\r\n row = []\r\n for i, c in enumerate(half_sorted_contours, 1):\r\n row.append(c)\r\n if i % self.board_dimension == 0:\r\n (full_sorted_contours, _) = contours.sort_contours(row, method=\"left-to-right\")\r\n self.game_board_contours.append(full_sorted_contours)\r\n row = []","def plot_simplex(self, num_contours: int = 100, num_sub_div: int = 8,\n color_map: str = 'viridis', border: bool = True, ax: Axes = None) -> Axes:\n\n corners = array([[0, 0], [1, 0], [0.5, 0.75 ** 0.5]])\n triangle = Triangulation(corners[:, 0], corners[:, 1])\n mid_points = [\n (corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2\n for i in range(3)\n ]\n\n def to_barycentric(cartesian):\n \"\"\"\n Converts 2D Cartesian to barycentric coordinates.\n\n :param cartesian: A length-2 sequence containing the x and y value.\n \"\"\"\n s = [(corners[i] - mid_points[i]).dot(cartesian - mid_points[i]) / 0.75\n for i in range(3)]\n s_clipped = clip(a=s, a_min=0, a_max=1)\n return s_clipped / norm(s_clipped, ord=1)\n\n refiner = UniformTriRefiner(triangle)\n tri_mesh = refiner.refine_triangulation(subdiv=num_sub_div)\n f = [self._method(to_barycentric(xy))\n for xy in zip(tri_mesh.x, tri_mesh.y)]\n ax = ax or new_axes()\n ax.tricontourf(tri_mesh, f, num_contours, cmap=color_map)\n ax.set_aspect('equal')\n ax.set_xlim(0, 1)\n ax.set_ylim(0, 0.75 ** 0.5)\n ax.set_axis_off()\n if border:\n ax.triplot(triangle, linewidth=1)\n\n return ax","def connect_points(clipped, side1, side2, window):\n edge = side1\n while edge != side2:\n clipped.append(window.points[0][edge])\n edge = (edge - 1) % 4","def buildEdges(self):\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\n assert self.nonDoubleIntersectors()\n # print('2.1')\n for i in self.inter1:\n assert self.nonDoubleIntersectors()\n # print('test')\n assert all(all(v in self.poly1.vertices for v in f.vertices) for f in self.poly1.faces)\n if not i.isSTraced():\n self.traceSurface(i)\n # print('2.2')\n for i in self.inter2:\n if not i.isSTraced():\n self.traceSurface(i)\n for i in self.inter1:\n if not i.isITraced():\n self.traceInterior(i)\n for i in self.inter2:\n if not i.isITraced():\n self.traceInterior(i)","def build_non_planar_disconnected_test_graph_with_k5_subgraph():\n graph = build_triangle_graph()\n addition_graph = build_k5_graph()\n addition_graph2 = build_k5_graph()\n\n merge_graphs(graph, addition_graph)\n merge_graphs(graph, addition_graph2)\n\n return graph","def imposeDSBconnections(self,Nc,breakLoci):\n #TODO\n #Adapt to any Nb\n if Nc == 0:\n return\n else:\n breakLoci = np.array(breakLoci)\n breakLoci = np.vstack((breakLoci,breakLoci+1)).T.flatten() # [A1, B1] -> [A1, A2, B1, B2]\n possible_pairs = [[a,b] for a,b in product(breakLoci, np.arange(0,self.numMonomers))]\n\n k0 = 0\n k1 = 4\n \n if breakLoci[0] == 0:\n for _ in range(2):\n possible_pairs.pop(0)\n k0 += 1\n \n if breakLoci[-1] == 99:\n for _ in range(2):\n possible_pairs.pop(-1)\n k1 -= 1\n \n for i in range(k0,k1):\n for _ in range(3):\n possible_pairs.pop(self.numMonomers*i + breakLoci[i] - 1 - 3*i + k0)\n \n for _ in range(2):\n possible_pairs.pop(breakLoci[2]-3 + k0)\n for _ in range(2):\n possible_pairs.pop(self.numMonomers + breakLoci[2] - 2*3 + k0 - 2)\n selected = np.array(possible_pairs)[np.random.choice(len(possible_pairs),size=Nc,replace=False)].T\n self.connect(selected) \n self.Nc += Nc","def drawShadedContours(xlist, ylist, zmatrix, levels):\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))","def __create_connections(self):\n \"\"\"\n When adding diagonals, each node adds only diagonals to nodes below it.\n This prevents a case where two nodes add diagonals with each other, s.t. both diagonals are added.\n \"\"\"\n # top left corner:\n self.add_connection(self.get_junc((0, 0)).right, self.get_junc((0, 1)).left)\n self.add_connection(self.get_junc((0, 0)).down, self.get_junc((1, 0)).up)\n # diagonal to down right\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((0, 0)).right, self.get_junc((1, 1)).up)\n else:\n self.add_connection(self.get_junc((0, 0)).down, self.get_junc((1, 1)).left)\n # top row:\n for wi in range(1, self.width - 1):\n self.add_connection(self.get_junc((0, wi)).right, self.get_junc((0, wi + 1)).left)\n self.add_connection(self.get_junc((0, wi)).left, self.get_junc((0, wi - 1)).right)\n self.add_connection(self.get_junc((0, wi)).down, self.get_junc((1, wi)).up)\n # diagonal to down left\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((0, wi)).left, self.get_junc((1, wi - 1)).up)\n else:\n self.add_connection(self.get_junc((0, wi)).down, self.get_junc((1, wi - 1)).right)\n # diagonal to down right\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((0, wi)).right, self.get_junc((1, wi + 1)).up)\n else:\n self.add_connection(self.get_junc((0, wi)).down, self.get_junc((1, wi + 1)).left)\n # top right corner:\n self.add_connection(self.get_junc((0, -1)).left, self.get_junc((0, -2)).right)\n self.add_connection(self.get_junc((0, -1)).down, self.get_junc((1, -1)).up)\n # diagonal to down left\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((0, -1)).left, self.get_junc((1, -2)).up)\n else:\n self.add_connection(self.get_junc((0, -1)).down, self.get_junc((1, -2)).right)\n # middle rows:\n for hi in range(1, self.height - 1):\n # left node\n self.add_connection(self.get_junc((hi, 0)).right, self.get_junc((hi, 1)).left)\n self.add_connection(self.get_junc((hi, 0)).down, self.get_junc((hi + 1, 0)).up)\n self.add_connection(self.get_junc((hi, 0)).up, self.get_junc((hi - 1, 0)).down)\n # diagonal to down right\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((hi, 0)).right, self.get_junc((hi + 1, 1)).up)\n else:\n self.add_connection(self.get_junc((hi, 0)).down, self.get_junc((hi + 1, 1)).left)\n # middle nodes\n for wi in range(1, self.width - 1):\n self.add_connection(self.get_junc((hi, wi)).right, self.get_junc((hi, wi + 1)).left)\n self.add_connection(self.get_junc((hi, wi)).left, self.get_junc((hi, wi - 1)).right)\n self.add_connection(self.get_junc((hi, wi)).down, self.get_junc((hi + 1, wi)).up)\n self.add_connection(self.get_junc((hi, wi)).up, self.get_junc((hi - 1, wi)).down)\n # diagonal to down left\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((hi, wi)).left, self.get_junc((hi + 1, wi - 1)).up)\n else:\n self.add_connection(self.get_junc((hi, wi)).down, self.get_junc((hi + 1, wi - 1)).right)\n # diagonal to down right\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((hi, wi)).right, self.get_junc((hi + 1, wi + 1)).up)\n else:\n self.add_connection(self.get_junc((hi, wi)).down, self.get_junc((hi + 1, wi + 1)).left)\n # right node:\n self.add_connection(self.get_junc((hi, -1)).left, self.get_junc((hi, -2)).right)\n self.add_connection(self.get_junc((hi, -1)).down, self.get_junc((hi + 1, -1)).up)\n self.add_connection(self.get_junc((hi, -1)).up, self.get_junc((hi - 1, -1)).down)\n # diagonal to down left\n if randint(0, 1) == 0:\n self.add_connection(self.get_junc((hi, -1)).left, self.get_junc((hi + 1, -2)).up)\n else:\n self.add_connection(self.get_junc((hi, -1)).down, self.get_junc((hi + 1, -2)).right)\n # bottom left corner:\n self.add_connection(self.get_junc((-1, 0)).right, self.get_junc((-1, 1)).left)\n self.add_connection(self.get_junc((-1, 0)).up, self.get_junc((-2, 0)).down)\n # bottom row\n for wi in range(1, self.width - 1):\n self.add_connection(self.get_junc((-1, wi)).right, self.get_junc((-1, wi + 1)).left)\n self.add_connection(self.get_junc((-1, wi)).left, self.get_junc((-1, wi - 1)).right)\n self.add_connection(self.get_junc((-1, wi)).up, self.get_junc((-2, wi)).down)\n # bottom right corner:\n self.add_connection(self.get_junc((-1, -1)).left, self.get_junc((-1, -2)).right)\n self.add_connection(self.get_junc((-1, -1)).up, self.get_junc((-2, -1)).down)","def solve_part2(start):\n inputs = load_inputs(False)\n all_matches = []\n tiles = inputs.keys()\n for elem in tiles:\n matches = defaultdict(list)\n for elem2 in tiles:\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\n l = matches[elem]\n l.append(elem2)\n if matches[elem]:\n all_matches.append(matches[elem])\n\n # start frmo an aribtrary corner\n # find a match, rotate me so that the match is along the right side\n # fill in properly oriented match\n # repeat, for row = 1+, consider top-match and left-match\n\n # for eery rotations / orientation, look fot the pattern","def listOfOverlappingTTPairs():\n listOfHalfModules = listOfTTHalfModules()\n ttmap = TTModulesMap_instance\n pairs = []\n regions = {'A':1, 'B':2, 'C':3}\n print \"Overlapping TT half modules:\"\n for hm1 in listOfHalfModules:\n for hm2 in listOfHalfModules:\n # they must be different\n if hm1 == hm2: continue\n # they must be both on top or both on bottom\n if locateTTHalfModule(hm1)[3] != locateTTHalfModule(hm2)[3]: continue\n # they must be on the same layer\n if locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0]: continue\n # avoid duplicates\n if (hm1, hm2) in pairs: continue\n if (hm2, hm1) in pairs: continue\n # they must be contiguous:\n if (locateTTHalfModule(hm1)[1] == locateTTHalfModule(hm2)[1]):\n if (abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) == 1):\n pairs.append( (hm1, hm2) )\n else:\n num1 = locateTTHalfModule(hm1)[2]\n num2 = locateTTHalfModule(hm2)[2]\n max1 = ttmap.numberOfModules[locateTTHalfModule(hm1)[0]]['Region'+locateTTHalfModule(hm1)[1]] - 1\n max2 = ttmap.numberOfModules[locateTTHalfModule(hm2)[0]]['Region'+locateTTHalfModule(hm2)[1]] - 1\n nreg1 = regions[locateTTHalfModule(hm1)[1]]\n nreg2 = regions[locateTTHalfModule(hm2)[1]]\n if ( (num1==max1 and num2==0 and nreg2-nreg1==1) or (num2==max2 and num1==0 and nreg1-nreg2==1) ):\n pairs.append( (hm1, hm2) )\n print '\\t', hm1, hm2\n ## - same region\n #if ((abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) != 1)\n # and (locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])): continue\n ## - or neighbouring region\n #elif not ((locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])\n # and ( ( (ttmap.numberOfModules[locateTTHalfModule(hm1)[0]] == locateTTHalfModule(hm1)[2]+1 )\n # and (locateTTHalfModule(hm2)[2] == 0) )\n # or ( (ttmap.numberOfModules[locateTTHalfModule(hm2)[0]] == locateTTHalfModule(hm2)[2]+1 )\n # and (locateTTHalfModule(hm1)[2] == 0) ) ) ): continue\n ## append to list of pairs\n #pairs.append( (hm1, hm2) )\n print\n return pairs","def test_construct_subcircuit_layers(self):\r\n dev = qml.device(\"default.qubit\", wires=3)\r\n\r\n def circuit(params):\r\n # section 1\r\n qml.RX(params[0], wires=0)\r\n # section 2\r\n qml.RY(params[1], wires=0)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n # section 3\r\n qml.RX(params[2], wires=0)\r\n qml.RY(params[3], wires=1)\r\n qml.RZ(params[4], wires=2)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n # section 4\r\n qml.RX(params[5], wires=0)\r\n qml.RY(params[6], wires=1)\r\n qml.RZ(params[7], wires=2)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n return qml.expval(qml.PauliX(0)), qml.expval(qml.PauliX(1)), qml.expval(qml.PauliX(2))\r\n\r\n circuit = qml.QNode(circuit, dev)\r\n\r\n params = np.ones([8])\r\n tapes = circuit.metric_tensor(params, only_construct=True)\r\n\r\n # this circuit should split into 4 independent\r\n # sections or layers when constructing subcircuits\r\n assert len(tapes) == 4\r\n\r\n # first layer subcircuit\r\n assert len(tapes[0].operations) == 1\r\n assert isinstance(tapes[0].operations[0], qml.Hadamard) # PauliX decomp\r\n\r\n # second layer subcircuit\r\n assert len(tapes[1].operations) == 4\r\n assert isinstance(tapes[1].operations[0], qml.RX)\r\n # PauliY decomp\r\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\r\n assert isinstance(tapes[1].operations[2], qml.S)\r\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\r\n\r\n # # third layer subcircuit\r\n assert len(tapes[2].operations) == 8\r\n assert isinstance(tapes[2].operations[0], qml.RX)\r\n assert isinstance(tapes[2].operations[1], qml.RY)\r\n assert isinstance(tapes[2].operations[2], qml.CNOT)\r\n assert isinstance(tapes[2].operations[3], qml.CNOT)\r\n # PauliX decomp\r\n assert isinstance(tapes[2].operations[4], qml.Hadamard)\r\n # PauliY decomp\r\n assert isinstance(tapes[2].operations[5], qml.PauliZ)\r\n assert isinstance(tapes[2].operations[6], qml.S)\r\n assert isinstance(tapes[2].operations[7], qml.Hadamard)\r\n\r\n # # fourth layer subcircuit\r\n assert len(tapes[3].operations) == 13\r\n assert isinstance(tapes[3].operations[0], qml.RX)\r\n assert isinstance(tapes[3].operations[1], qml.RY)\r\n assert isinstance(tapes[3].operations[2], qml.CNOT)\r\n assert isinstance(tapes[3].operations[3], qml.CNOT)\r\n assert isinstance(tapes[3].operations[4], qml.RX)\r\n assert isinstance(tapes[3].operations[5], qml.RY)\r\n assert isinstance(tapes[3].operations[6], qml.RZ)\r\n assert isinstance(tapes[3].operations[7], qml.CNOT)\r\n assert isinstance(tapes[3].operations[8], qml.CNOT)\r\n # PauliX decomp\r\n assert isinstance(tapes[3].operations[9], qml.Hadamard)\r\n # PauliY decomp\r\n assert isinstance(tapes[3].operations[10], qml.PauliZ)\r\n assert isinstance(tapes[3].operations[11], qml.S)\r\n assert isinstance(tapes[3].operations[12], qml.Hadamard)","def get_contour_features(mask,selectcell=\"centered\"):\r\n \r\n #binarize image (everything above 0 becomes 1)\r\n mask = np.clip(mask,a_min=0,a_max=1)\r\n\r\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\r\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\r\n contours = list(contours)\r\n \r\n #in case there is no contour found, add a dummy contour\r\n if len(contours)==0:\r\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\r\n\r\n #Sort contours, longest first\r\n contours.sort(key=len,reverse=True)\r\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\r\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\r\n\r\n mu_origs = [cv2.moments(contour) for contour in contours]\r\n mu_hulls = [cv2.moments(hull) for hull in hulls]\r\n\r\n area_origs = [mu_orig[\"m00\"] for mu_orig in mu_origs]\r\n area_hulls = [mu_hull[\"m00\"] for mu_hull in mu_hulls]\r\n\r\n #drop events where area is zero\r\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \r\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\r\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\r\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\r\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\r\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\r\n \r\n \r\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\r\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\r\n\r\n \r\n if selectcell == \"smooth\":\r\n #compute the area ratio (roughness of contour)\r\n area_ratio = np.array(area_hulls)/np.array(area_origs)\r\n #get the contour with minimum roughness (smooth contour)\r\n sorter = np.argsort(area_ratio) #smallest first\r\n\r\n if selectcell == \"centered\":\r\n #select contour that is closest to the center of the image. \r\n #In iPAC, cells are usually in the center.\r\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\r\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\r\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\r\n sorter = np.argsort(distances) #smallest first\r\n \r\n #sort values with respect to chosen metric (area_ratio or distance)\r\n contours = [contours[s] for s in sorter]\r\n hulls = [hulls[s] for s in sorter]\r\n pos_x = [pos_x[s] for s in sorter]\r\n pos_y = [pos_y[s] for s in sorter]\r\n mu_origs = [mu_origs[s] for s in sorter]\r\n area_origs = [area_origs[s] for s in sorter]\r\n area_hulls = [area_hulls[s] for s in sorter]\r\n \r\n # draw mask of the chosen contour\r\n mask = np.zeros_like(mask)\r\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\r\n\r\n hull = hulls[0]#[0:n_contours]\r\n pos_x = pos_x[0]\r\n pos_y = pos_y[0] \r\n mu_orig = mu_origs[0]#[0:n_contours]\r\n area_orig = area_origs[0]#[0:n_contours]\r\n area_hull = area_hulls[0]#[0:n_contours]\r\n \r\n if area_orig>0:\r\n area_ratio = area_hull/area_orig\r\n else:\r\n area_ratio = np.nan\r\n\r\n arc = cv2.arcLength(hull, True) \r\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\"m00\"]) / arc\r\n\r\n\r\n dic = {\"mask\":mask,\"pos_x\":pos_x,\"pos_y\":pos_y,\"area_orig\":area_orig,\"area_hull\":area_hull,\\\r\n \"area_ratio\":area_ratio,\"circularity\":circularity}\r\n return dic","def discrete_coons_patch(ab, bc, dc, ad):\n if not ab:\n ab = [ad[0]] * len(dc)\n if not bc:\n bc = [ab[-1]] * len(ad)\n if not dc:\n dc = [bc[-1]] * len(ab)\n if not ad:\n ad = [dc[0]] * len(bc)\n\n n = len(ab)\n m = len(bc)\n\n n_norm = normalize_values(range(n))\n m_norm = normalize_values(range(m))\n\n array = [[0] * m for i in range(n)]\n for i, ki in enumerate(n_norm):\n for j, kj in enumerate(m_norm):\n # first function: linear interpolation of first two opposite curves\n lin_interp_ab_dc = add_vectors(scale_vector(ab[i], (1 - kj)), scale_vector(dc[i], kj))\n # second function: linear interpolation of other two opposite curves\n lin_interp_bc_ad = add_vectors(scale_vector(ad[j], (1 - ki)), scale_vector(bc[j], ki))\n # third function: linear interpolation of four corners resulting a hypar\n a = scale_vector(ab[0], (1 - ki) * (1 - kj))\n b = scale_vector(bc[0], ki * (1 - kj))\n c = scale_vector(dc[-1], ki * kj)\n d = scale_vector(ad[-1] , (1 - ki) * kj)\n lin_interp_a_b_c_d = sum_vectors([a, b, c, d])\n # coons patch = first + second - third functions\n array[i][j] = subtract_vectors(add_vectors(lin_interp_ab_dc, lin_interp_bc_ad), lin_interp_a_b_c_d)\n\n # create vertex list\n vertices = []\n for i in range(n):\n vertices += array[i]\n\n # create face vertex list\n face_vertices = []\n for i in range(n - 1):\n for j in range(m - 1):\n face_vertices.append([i * m + j , i * m + j + 1 , (i + 1) * m + j + 1, (i + 1) * m + j])\n return vertices, face_vertices","def compare_transects(run1, run2, hours=[12,], extent=None, ztop=1000,\n columntitles=['coupled','uncoupled'],\n subsubdir=None,\n third_transect=False):\n ltoffset=fio.run_info[run1]['UTC_offset']\n if extent is None:\n extent = constants.extents[run1.split('_')[0]]\n nrows=3+third_transect\n # transects = extent centre +- frac of extent width/height\n y0,x0 = (extent[2]+extent[3])/2.0, (extent[0]+extent[1])/2.0\n # do middle point +- 1/3 of distance to extent edge\n dx = (extent[1]-extent[0]) / 3.0\n dy = (extent[3]-extent[2]) / 3.0\n # transects: [[[lat,lon],[lat,lon]],...]\n transects = [[[y0+dy,x0-dx], [y0+dy, x0+dx]],\n [[y0,x0-dx], [y0, x0+dx]],\n ]\n tcolors = ['yellow','blue',]\n if third_transect:\n transects.append([[y0-dy,x0-dx], [y0-dy, x0+dx]])\n tcolors.append('magenta')\n \n \n dtimes=fio.run_info[run1]['filedates'][np.array(hours)]\n \n ## for each hour\n for dti, dt in enumerate(dtimes):\n ## read hour of data for both runs\n cubes1 = fio.read_model_run(run1, fdtime=[dt], extent=extent, \n add_topog=True, add_winds=True,\n add_z=True, add_theta=True)\n \n u1,v1,w1,z1 = cubes1.extract([\"u\",\"v\",\"upward_air_velocity\",\"z_th\"])\n ctimes=utils.dates_from_iris(w1)\n zd1 = z1.data.data\n theta1, = cubes1.extract(\"potential_temperature\")\n topog1=cubes1.extract(\"surface_altitude\")[0].data\n \n # read fire outputs\n ff1,sh1,u101,v101 = fio.read_fire(model_run=run1,\n dtimes=ctimes, \n extent=extent,\n sensibleheat=True,\n wind=True)\n \n cubes2 = fio.read_model_run(run2, fdtime=[dt], extent=extent, \n add_topog=True, add_winds=True,\n add_z=True, add_theta=True)\n u2,v2,w2,z2 = cubes2.extract([\"u\",\"v\",\"upward_air_velocity\",\"z_th\"])\n zd2 = z2.data.data\n theta2, = cubes2.extract(\"potential_temperature\")\n topog2=cubes2.extract(\"surface_altitude\")[0].data\n # read fire outputs\n ff2,sh2,u102,v102 = fio.read_fire(model_run=run2,\n dtimes=ctimes, \n extent=extent,\n sensibleheat=True,\n wind=True)\n \n \n \n for cti,ct in enumerate(ctimes):\n \n ## FIGURE BEGIN:\n fig = plt.figure(figsize=[13,14])\n ## looking at two separate runs\n for runi, [sh,ff,u10,v10,u,v,w,zd,theta,topog] in enumerate(zip([sh1,sh2],[ff1,ff2],[u101,u102],[v101,v102],[u1,u2],[v1,v2],[w1,w2],[zd1,zd2],[theta1,theta2],[topog1,topog2])):\n # read datacubes\n\n lats = ff.coord('latitude').points\n lons = ff.coord('longitude').points\n \n shd = sh[cti].data.data\n LT = ct + timedelta(hours=ltoffset)\n \n ffd = ff[cti].data.data\n u10d = u10[cti].data.data\n v10d = v10[cti].data.data\n \n \n #plt.subplot(4,2,1+runi) # top row\n _,ax = emberstorm.topdown_emberstorm(\n fig=fig, subplot_row_col_n=(nrows,2,1+runi),\n extent=extent, lats=lats, lons=lons,\n ff=ffd, sh=shd, u10=u10d, v10=v10d,\n topog=topog,\n annotate=False,\n sh_kwargs={'colorbar':False}\n )\n ax.set_aspect('equal')\n if runi==1:\n plt.yticks([],[])\n plt.title(columntitles[runi])\n for transect, tcolor in zip(transects,tcolors):\n ## Add dashed line to show where transect will be\n start,end = transect\n # outline the dashed line\n line_effects=[patheffects.Stroke(linewidth=5, foreground='darkgrey'), patheffects.Normal()]\n plt.plot([start[1],end[1]],[start[0],end[0], ], \n linestyle='--',\n color=tcolor,\n linewidth=3, \n path_effects=line_effects,\n #alpha=0.9,\n )\n \n ## Plot title\n plt.suptitle(LT.strftime('%b %d, %H%M (LT)'),fontsize=28)\n \n # Transect plots\n for trani,transect in enumerate(transects):\n ax=plt.subplot(nrows,2,3+runi+2*trani)\n \n trets = emberstorm.transect_emberstorm(\n u[cti].data.data,\n v[cti].data.data,\n w[cti].data.data,\n zd, lats, lons, transect,\n topog=topog,\n sh=shd,\n theta=theta[cti].data.data,\n ztop=ztop,\n theta_contourargs={'levels':[297,300,303,306,309]},\n wind_contourargs={'colorbar':False},\n )\n if runi==1:\n plt.yticks([],[])\n \n # match splines to transect lines\n plotting.set_spine_color(ax,tcolors[trani])\n # finally add desired annotations\n plotting.annotate_max_winds(trets['s'])\n \n \n ## add wind speed colorbar\n cbar_ax = fig.add_axes([0.92, 0.4, 0.02, 0.2]) # X Y Width Height\n cmap = matplotlib.cm.get_cmap(name=plotting._cmaps_['windspeed'])\n #cmap.set_over('1.0')\n #norm = matplotlib.colors.Normalize(vmin=0, vmax=22.5)\n norm = matplotlib.colors.BoundaryNorm(np.arange(0,22.51,2.5), cmap.N)\n \n cb1 = matplotlib.colorbar.ColorbarBase(cbar_ax, cmap=cmap,\n norm=norm,\n extend='max',\n orientation='vertical')\n cb1.set_label('ms$^{-1}$')\n \n \n ## SAVE FIGURE\n subdir='transects'\n if subsubdir is not None:\n subdir += '/'+subsubdir\n plt.tight_layout(rect=[0,0.03,0.92,0.975]) #(left, bottom, right, top)\n fio.save_fig(run2,_sn_,ct,subdir=subdir,plt=plt)","def cfdProcessElementTopology(self):\r\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \r\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\r\n\r\n ## (list of lists) list of face indices forming each element\r\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\r\n \r\n #populates self.elementNeighbours\r\n for iFace in range(self.numberOfInteriorFaces):\r\n own=self.owners[iFace]\r\n nei=self.neighbours[iFace]\r\n \r\n #adds indices of neighbour cells\r\n self.elementNeighbours[own].append(nei)\r\n self.elementNeighbours[nei].append(own)\r\n \r\n #adds interior faces\r\n self.elementFaces[own].append(iFace)\r\n self.elementFaces[nei].append(iFace)\r\n \r\n #adds boundary faces ('patches')\r\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\r\n own=self.owners[iFace]\r\n self.elementFaces[own].append(iFace)\r\n \r\n ## List of lists containing points forming each element\r\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n \r\n for faceIndex in self.elementFaces[iElement]:\r\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\r\n \r\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\r\n \r\n ## Upper coefficient indices (owners)\r\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n ## Lower coefficient indices (owners)\r\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\r\n \r\n for iElement in range(self.numberOfElements):\r\n ## Element number from 1 to numberOfElements + 1\r\n iNb=1\r\n for faceIndex in self.elementFaces[iElement]:\r\n \r\n #skip if it is a boundary face\r\n if faceIndex > self.numberOfInteriorFaces-1:\r\n continue\r\n \r\n own = self.owners[faceIndex]\r\n nei = self.neighbours[faceIndex]\r\n \r\n if iElement == own:\r\n self.upperAnbCoeffIndex[faceIndex] = iNb\r\n elif iElement == nei:\r\n self.lowerAnbCoeffIndex[faceIndex] = iNb\r\n \r\n iNb = iNb +1","def monolayer_4band():\n a = 0.222\n ax = 0.438\n ay = 0.332\n theta = 96.79 * (pi / 180)\n phi = 103.69 * (pi / 180)\n\n lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])\n\n h = a * sin(phi - pi / 2)\n s = 0.5 * ax - a * cos(theta / 2)\n lat.add_sublattices(\n ('A', [0, 0, h], 0),\n ('B', [s, 0, 0], 0),\n ('C', [ax/2, ay/2, 0], 0),\n ('D', [ax/2 + s, ay/2, h], 0)\n )\n\n lat.register_hopping_energies({\n 't1': -1.22,\n 't2': 3.665,\n 't3': -0.205,\n 't4': -0.105,\n 't5': -0.055\n })\n\n lat.add_hoppings(\n # t1\n ([-1, 0], 'A', 'D', 't1'),\n ([-1, -1], 'A', 'D', 't1'),\n ([ 0, 0], 'B', 'C', 't1'),\n ([ 0, -1], 'B', 'C', 't1'),\n # t2\n ([ 0, 0], 'A', 'B', 't2'),\n ([ 0, 0], 'C', 'D', 't2'),\n # t3\n ([ 0, 0], 'A', 'D', 't3'),\n ([ 0, -1], 'A', 'D', 't3'),\n ([ 1, 1], 'C', 'B', 't3'),\n ([ 1, 0], 'C', 'B', 't3'),\n # t4\n ([ 0, 0], 'A', 'C', 't4'),\n ([ 0, -1], 'A', 'C', 't4'),\n ([-1, 0], 'A', 'C', 't4'),\n ([-1, -1], 'A', 'C', 't4'),\n ([ 0, 0], 'B', 'D', 't4'),\n ([ 0, -1], 'B', 'D', 't4'),\n ([-1, 0], 'B', 'D', 't4'),\n ([-1, -1], 'B', 'D', 't4'),\n # t5\n ([-1, 0], 'A', 'B', 't5'),\n ([ 0, 1], 'A', 'B', 't5'),\n ([ 0, -1], 'A', 'B', 't5'),\n ([-1, 0], 'C', 'D', 't5'),\n ([ 0, 1], 'C', 'D', 't5'),\n ([ 0, -1], 'C', 'D', 't5'),\n )\n\n return lat","def connected((e,r)):\n \n # Deal with the middle case so we don't divide by zero\n if r==0: return [(1,1),(2,1),(3,1),(4,1),(5,1),(0,1)]\n # If the input is impossible, return nothing to prune the branch (shouldn't\n # happen)\n if e>=6*r: return []\n connected=[]\n mult=e//r\n rem=e % r\n #Going sideways\n toAdd=((6*r-1,r) if e==0 else (e-1,r))\n connected.append(toAdd)\n toAdd=((0,r) if e==6*r-1 else (e+1,r))\n connected.append(toAdd)\n #Going inward\n toAdd=( (0,r-1)if mult==5 and rem==r-1 else (mult*(r-1)+rem,r-1) )\n connected.append(toAdd)\n if rem!=0:\n connected.append((mult*(r-1)+rem-1,r-1))\n\n #Going outward\n if r<nLayers-1:\n connected.append((mult*(r+1)+rem,r+1))\n connected.append((mult*(r+1)+rem+1,r+1))\n if rem==0: # only case where negatives could result\n if mult>0: connected.append( (mult*(r+1)-1,r+1))\n else: connected.append( (6*(r+1)-1,r+1))\n \n return connected","def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\n # get activation for each seperated vc\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\n max_ch_index = max_ch_index.view(-1, L) # n, L\n\n all_activation_vcs = []\n\n for i in range(len(integrate_activation_vc)):\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\n all_activation_vcs.append(integrate_activation_vc_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n print(f\"unique_vc_i {unique_vc_i.shape}\")\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\n activate_vc_i[index_vc_i, :] = 0.\n all_activation_vcs.append(activate_vc_i)\n \n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\n \n # decompose each mask \n all_masks = []\n for i in range(len(sim_map_max)):\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\n all_masks.append(sim_map_max_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\n vc_sim_map_max_i[index_vc_i] = 0.\n all_masks.append(vc_sim_map_max_i)\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\n\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\"\n\n return all_activation_vcs, all_masks","def registration(im1, im2, num = 10, opt = 'py', outputPath = 'None'):\n\n # determin which one is the right side of the breast\n b_size = 5\n n_row, n_col = im1.shape\n side = 0\n if np.sum(im1[0:b_size,0:b_size]) < np.sum(im1[0:b_size,n_col-b_size:n_col]):\n side = 1 \n\n # flip the right side image\n if side == 1:\n im1 = np.fliplr(im1)\n else:\n im2 = np.fliplr(im2) \n\n # find edges of both images\n edge1 = findEdge(im1)\n edge2 = findEdge(im2)\n\n # tune edges of both side\n edge1 = tuneEdge(edge1,im1.shape)\n edge2 = tuneEdge(edge2,im2.shape)\n\n # samping from both side\n points1 = contour_sampling(edge1, num)\n points2 = contour_sampling(edge2, num)\n\n # for debugging .........................\n sam_im1 = np.zeros(im1.shape,np.float32)\n for point in points1:\n sam_im1[point[0],point[1]] = 1\n\n sam_im2 = np.zeros(im2.shape,np.float32)\n for point in points2:\n sam_im2[point[0],point[1]] = 1\n \n selem = disk(15)\n dilated1 = ndimage.convolve(sam_im1, selem, mode='constant', cval=0)\n dilated2 = ndimage.convolve(sam_im2, selem, mode='constant', cval=0)\n\n points1 = np.asarray(points1)\n points2 = np.asarray(points2)\n \n # Thin Plate Spline interpolation\n dst = np.zeros(im1.shape)\n # im1 as source\n if opt == 'py': \n tps = TPSpline.TPSpline()\n tps.setCorrespondences(points1, points2)\n dst = tps.warpImage(im1)\n return dst\n\n if opt == 'c':\n print \"Please run the interpolation with C++ exe file!\"\n print \"./TPSpline /home/yanbin/Tomosynthesis/libs/TPSpline/test/ps.txt /home/yanbin/Tomosynthesis/libs/TPSpline/test/pd.txt /home/yanbin/Tomosynthesis/libs/TPSpline/test/5016_test.tif /home/yanbin/Tomosynthesis/libs/TPSpline/test/dst.tif\"\n np.savetxt(outputPath + 'ps.txt', points1, '%d', delimiter=' ') # X is an array\n np.savetxt(outputPath + 'pd.txt', points2, '%d', delimiter=' ') # X is an array\n tiffLib.imsave(outputPath + 'im1.tif',im1)\n return None","def get_contour(atom_list):\n initial = [atom for atom in atom_list if ((0 < len(identify_bonds(atom, atom_list)) < 3) and (check_connected(atom, identify_bonds(atom, atom_list)) == False))]\n \n extra_1 = []\n for atom in atom_list:\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\n for i in neighbours:\n neighbours2 = [bond[0] for bond in identify_bonds(i, atom_list)]\n for j in neighbours2:\n if j in initial:\n extra_1.append(atom)\n\n extra_2 = []\n for atom in atom_list:\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\n check = 0\n for i in neighbours:\n if i in initial:\n check += 1\n if ((check == 2) and (atom not in initial)):\n extra_2.append(atom) \n return (initial + extra_1 + extra_2)","def subj_corr_comparison(subj1, subj2, data_dir, save_dir, opacity = 0.6, save_fig=True):\n\n\tfig = plt.figure(figsize=(15,9))\n\tax = fig.subplots()\n\tplt.plot([0.0, 0.16], [0.0, 0.16], 'black', label='unity')\n\tplot_color = '#2278B5'\n\tcorrs = []\n\twith h5py.File('%s/%s/%s_STRF_by_binned_pitches_MT.hf5'% (data_dir, subj1, subj1), 'r') as fh:\n\t\tsubj1_corrs = fh['corrs_mt_norm'][:]\n\t\tsubj1_cc_max = fh['/cc_max_mt'][:]\n\t\tsubj1_corrs=corrs/cc_max\n\t\tsubj1_wts = fh['wts_mt'][:]\n\t\tsubj1_pvals = fh['pvals_mt'][:]\n\twith h5py.File('%s/%s/%s_STRF_by_binned_pitches_MT.hf5'%(data_dir, subj2, subj2), 'r') as fh:\n\t\tsubj2_corrs = fh['corrs_mt'][:]\n\t\tsubj2_cc_max = fh['/cc_max_mt'][:]\n\t\tsubj2_corrs=corrs/cc_max\n\t\tsubj2_wts = fh['wts_mt'][:]\n\t\tsubj2_pval = fh['pvals_mt'][:]\n\n\tcorrs.append([subj2_corrs, subj1_corrs])\n\tpoints = np.hstack(corrs).T\n\n\thull1=ConvexHull(np.vstack((points[:,0] , points[:,1])).T)\n\thullv1 = hull1.vertices.copy()\n\thullv1 = np.append(hullv1, hullv1[0])\n\tprint(hullv1)\n\tplt.fill(points[hullv1,0], points[hullv1,1], facecolor=plot_color, alpha=opacity, zorder=2) #envs\n\n\tplt.plot(subj2_corrs[np.where (subj2_pval[0] > 0.05)], np.take(subj1_corrs, np.asarray(np.where (subj2_pval[0] > 0.05)))[0], '.', color='#CDC1C5', label='non-sig corrs')\n\tplt.plot(subj2_corrs[np.where (subj2_pval[0] < 0.05)], np.take(subj1_corrs, np.asarray(np.where (subj2_pval[0] < 0.05))[0]), '.' , color='#996666', label='sig corrs')\n\t#plt.plot(MT_corrs_0020, MT_corrs_0002, '.', color='#996666') #significant \n\tplt.legend()\n\n\tplt.xlabel('%s corr values (r)' %(subj2))\n\tplt.ylabel('%s corr values (r)' %(subj1))\n\tplt.axis('square')\n\n\tif save_fig:\n\t\tplt.savefig('%s/%s_%s_scatter_comparison.pdf' %(save_dir, subj1, subj2))\n\n\t#run Wilcoxon\n\t[z_val, p_val] = wilcoxon(subj1_corrs, subj2_corrs)\n\tprint(z_val)\n\tprint(p_val)\n\n\n\t#% performance improvement \n\tsubject_list = [subj1, subj2] \n\tavg_corrs = []\n\tcorrs_std = []\n\n\tavg_corrs.append(subj1_corrs.mean())\n\tavg_corrs.append(subj2_corrs.mean())\n\n\t#append std. error for error bars\n\tcorrs_std.append(subj1_corrs.std()/np.sqrt(len(subj1_corrs)))\n\tcorrs_std.append(subj2_corrs.std()/np.sqrt(len(subj2_corrs)))\n\n\tn_groups = 2\n\tplt.figure(figsize=(8,4))\n\tbar_width = 0.5\n\tindex = np.arange(n_groups)\n\n\tplt.bar(index, avg_corrs, bar_width, yerr=corrs_std, color='#996666', alpha=0.6)\n\tplt.xticks(np.arange(len(subject_list)), subject_list, rotation=90)\n\tplt.ylabel('Correlation Values')\n\tplt.title('Avg. correlation values (MT0002 vs MT0020)')\n\n\tif save_fig:\n\t\tplt.savefig('%s/%s_%s_barplot_comparison.pdf' %(save_dir, subj1, subj2))","def computesWingConnexions(self):\n logger.warning(\"!!! WARINING !!!!\")\n logger.warning(\"BE CERTAIN THAT CPACS FILE HAS THE HORIZONTAL TAIL\")\n logger.warning(\"DEFINED BEFORE THE VERTICAL TAIL!!!!\")\n if self.nWings <= 1:\n logger.info(\"No wing connexions needed\")\n elif self.nWings > 1 and self.nFuselage < 1:\n logger.error(\"Multiple wings with no fuselage! Mesh can not be computed\")\n sys.exit()\n else:\n ws_connextionsPoints = self.nWings + self.nFuselage - 1\n # if self.nFuselage > 0:\n # ws_connextionsPoints = self.nWings\n # else:\n # ws_connextionsPoints = self.nWings -1\n\n # ws: wings\n # d: distance\n # L: left, R: right, c: center\n connectedNodes = np.zeros((ws_connextionsPoints,5))\n for i in range(ws_connextionsPoints):\n \"\"\"\n for each wing there is 3 points that need to be taken into\n account:\n 1) Left tip position[0]\n 2) center [np.floor(nNodes/2))]\n WARNING: keep in mind that symmetric wings always have \n an odd number of points!\n 3) right tip position[-1]\n \"\"\"\n if self.nFuselage > 0:\n wingIndex = i+1\n else:\n wingIndex = i\n # logger.debug(\"Wing index = \"+str(wingIndex))\n # N = len(self.aircraftNodesPoints[i])\n currentWingNpoints = len(self.aircraftNodesPoints[wingIndex])\n if currentWingNpoints > 2:\n c = int(np.floor(len(self.aircraftNodesPoints[wingIndex])/2))\n else:\n c = 0\n # logger.debug(\"c = \"+str(c))\n ws_identifiers = np.empty((ws_connextionsPoints,5))\n\n for j in range(ws_connextionsPoints+1):\n logger.debug(\"wingIndex,j = \"+str(wingIndex)+\" \"+str(j))\n if wingIndex != j:\n # c: stands for current\n logger.debug(\"True with wingIndex,j = \"+str(wingIndex)+\" \"+str(j))\n # Computes the distances between all point\n dist_l = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][0], axis=1)\n if currentWingNpoints > 2:\n dist_c = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][c], axis=1)\n else:\n dist_c = dist_l\n dist_r = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][-1],axis=1)\n\n # Gets the index of the minimal distance between all point\n index_l = np.argmin(dist_l)\n if currentWingNpoints > 2:\n index_c = np.argmin(dist_c)\n else:\n index_c = index_l\n index_r = np.argmin(dist_r)\n indexes = np.array([index_l, index_c, index_r])\n\n # gets the minimal distance for each wing part\n minDist_l = dist_l[index_l]\n if currentWingNpoints > 2:\n minDist_c = dist_c[index_c]\n else:\n minDist_c = minDist_l\n minDist_r = dist_r[index_r]\n minDist = np.array([minDist_l,minDist_c,minDist_r])\n\n k = np.argmin(minDist)\n minimalDistance = minDist[k]\n m = indexes[k]\n r = len(self.aircraftNodesPoints[wingIndex])\n tab = np.array([0,c,r])\n k = tab[k]\n\n # minimalDistance: distance between both of these points\n identifier = np.array([wingIndex,j,k,m,minimalDistance])\n # logger.debug(\"Identifier \\n\"+str(identifier))\n if j < wingIndex:\n ws_identifiers[j] = identifier\n else:\n ws_identifiers[j-1] = identifier\n \n index2 = np.argmin(ws_identifiers[:,4])\n old = np.array([ws_identifiers[index2,2],\n ws_identifiers[index2,3],\n ws_identifiers[index2,0],\n ws_identifiers[index2,1],\n ws_identifiers[index2,4]])\n if old in connectedNodes and i > 1:\n logger.warning(\"Found a matching connexion\")\n logger.debug(old)\n logger.debug(ws_identifiers)\n ws_identifiers = np.delete(ws_identifiers,index2,0)\n logger.debug(ws_identifiers)\n index2 = np.argmin(ws_identifiers[:,4])\n connectedNodes[i] = ws_identifiers[index2]\n logger.debug(\"connected Nodes: \\n\"+str(connectedNodes[i]))\n # logger.debug(connectedNodes)\n \n self.aircraftConnectedNodes.append(connectedNodes)\n self.rigidNodesAdder()\n # sys.exit()","def clip(self, clip, s_entry, c_entry):\n\n # detect clip mode\n unionmode = not s_entry and not c_entry\n intersectionmode = s_entry and c_entry\n differencemode = not s_entry and c_entry\n\n # prep by removing repeat of startpoint at end\n first = self.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n first = clip.first\n last = first.prev\n if last.x == first.x and last.y == first.y:\n first.prev = last.prev\n last.prev.next = first\n\n # TODO: maybe also remove repeat points anywhere?\n # ...\n \n # phase one - find intersections\n # ------------------------------\n anyintersection = False\n s_intsecs = []\n c_intsecs = []\n for s in self.iter(): # for each vertex Si of subject polygon do\n for c in clip.iter(): # for each vertex Cj of clip polygon do\n try:\n #print \"find isect %s - %s and %s - %s\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\n c, clip.next(c.__next__))\n \n iS = Vertex(i, alphaS, intersect=True, entry=False)\n iC = Vertex(i, alphaC, intersect=True, entry=False)\n\n iS.neighbour = iC\n iC.neighbour = iS\n \n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\n \n anyintersection = True\n \n except TypeError:\n pass # this simply means intersect() returned None\n\n # insert intersections into originals\n for iS,a,s,s_next in reversed(s_intsecs):\n if a == 0:\n self.replace(s, iS)\n elif a == 1:\n self.replace(s_next, iS)\n else:\n self.insert(iS, s, s_next)\n for iC,a,c,c_next in reversed(c_intsecs):\n if a == 0:\n self.replace(c, iC)\n elif a == 1:\n self.replace(c_next, iC)\n else:\n clip.insert(iC, c, c_next)\n\n #print \"testing if insert was done correctly\"\n for s in self.iter():\n #print s\n pass\n #print \"and\"\n for c in clip.iter():\n #print c\n pass\n \n\n # phase one and a half - no intersections between subject and clip, so correctly return results\n # --------------------\n def specialcase_insidetest():\n resultpolys = []\n if unionmode: # union\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so just return subject shell\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so just return clip shell\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so return both\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif intersectionmode: # intersection\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\n clipped = Polygon()\n for c in clip.iter():\n clipped.add(Vertex(c))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n else:\n #clip polygon is entirely outside subject, so no intersection to return\n pass\n elif differencemode: # difference\n if clip.first.isInside(self):\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n hole = Polygon()\n for c in clip.iter():\n hole.add(Vertex(c))\n polytuple = (clipped, [hole])\n resultpolys.append(polytuple)\n elif self.first.isInside(clip):\n # subject polygon is entirely inside clip, so there is no difference\n pass\n else:\n #clip polygon is entirely outside subject, so difference is simply the subject\n clipped = Polygon()\n for s in self.iter():\n clipped.add(Vertex(s))\n polytuple = (clipped, [])\n resultpolys.append(polytuple)\n # no need to continue so just return result\n return resultpolys\n \n if not anyintersection: \n return specialcase_insidetest()\n\n\n\n\n\n\n\n # phase two - identify entry/exit points\n # --------------------------------------\n\n # From K&K\n \n def mark_flags(poly, c, c_entry):\n \"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\"\n #print \"intersection\"\n #print \"\\t\",c\n # intersection is degenerate, is the start/endpoint of a line\n # so maybe delete intersection flag based on prev/next locations\n prevloc = testLocation(c.prev, poly)\n nextloc = testLocation(c.__next__, poly)\n if prevloc == \"on\" or nextloc == \"on\":\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\n prevloc = testLocation(prevmid, poly)\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\n nextloc = testLocation(nextmid, poly)\n if prevloc == \"in\" or nextloc == \"in\":\n poly.anyinside = True\n #print \"\\t %s -> degenintsec -> %s\" %(prevloc,nextloc)\n if prevloc == \"out\":\n if nextloc == \"out\":\n #just touching\n c.entry = \"en/ex\" if c_entry else \"ex/en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif nextloc == \"on\":\n c.entry = \"en\" if c_entry else \"ex\"\n elif prevloc == \"in\":\n #union and difference should never go inside the other polygon\n #so this should only happen for intersectmode...\n if nextloc == \"in\":\n #just touching\n c.entry = \"ex/en\" if c_entry else \"en/ex\"\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"on\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif prevloc == \"on\":\n if nextloc == \"on\":\n c.entry = None\n elif nextloc == \"out\":\n c.entry = \"ex\" if c_entry else \"en\"\n elif nextloc == \"in\":\n c.entry = \"en\" if c_entry else \"ex\"\n\n self.anyinside = False\n\n # set clip\n prevsingle = None\n for c in clip.iter():\n if c.intersect:\n mark_flags(self, c, c_entry)\n # set couple\n if c.entry in (\"ex\",\"en\"):\n if prevsingle and c.entry == prevsingle.entry:\n c.couple = prevsingle\n prevsingle.couple = c\n prevsingle = c\n # set crosschange\n # some modifications based on implementation in qt clipper source code\n #if c.entry == \"en/ex\" == c.neighbour.entry or c.entry == \"ex/en\" == c.neighbour.entry:\n if False: #c.entry == \"en/ex\" or c.entry == \"ex/en\":\n print(\"Maybe crosschange...\")\n # tri1\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\n dir1 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n # tri2\n #a,b,c = c.neighbour.prev, c.prev, c.next\n a,b,c = c.__next__, c.prev, c.neighbour.prev\n dir2 = 0.5 * (a.x * (b.y-c.y) +\n b.x * (c.y-a.y) +\n c.x * (a.y-b.y))\n print(dir1,dir2)\n #if dir1 < 0 != dir2 < 0: # different orientation\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\n print(\"CROSSCHANGE!!!\")\n c.cross_change = True\n c.neighbour.cross_change = True # not sure if should set neighbour too\n\n # maybe early abort\n if not self.anyinside and intersectionmode:\n return []\n\n # what about perfect overlap???\n # ...\n\n if False: #DEBUG:\n print(\"view clip entries\")\n for c in clip.iter():\n print(c, c.entry)\n\n # find first isect where both neighbours have valid flag\n for c in clip.iter():\n if c.entry:\n s = c.neighbour\n mark_flags(clip, s, s_entry)\n if s.entry:\n first_c = c\n first_s = s\n # print 777,s.entry\n break\n\n else:\n return specialcase_insidetest()\n #raise Exception(\"weird special case, no neighbours that both have flag left\")\n \n # autoset subj, if neighbour of first is different, then set all as opposite\n # TODO: how deal with s_entry in case of different modes...?\n print(\"view first\")\n print(first_c, first_c.entry)\n print(first_s, first_s.entry)\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\n for c in clip.iter():\n if c.entry:\n if c.entry == \"en\": c.neighbour.entry = \"ex\"\n elif c.entry == \"ex\": c.neighbour.entry = \"en\"\n elif c.entry == \"en/ex\": c.neighbour.entry = \"ex/en\"\n elif c.entry == \"ex/en\": c.neighbour.entry = \"en/ex\"\n \n # else set all same\n else:\n for c in clip.iter():\n if c.entry:\n c.neighbour.entry = c.entry\n\n # set couple for subj (not sure if needed)\n prevsingle = None\n for s in self.iter():\n if s.entry:\n if s.entry in (\"ex\",\"en\"):\n if prevsingle and s.entry == prevsingle.entry:\n s.couple = prevsingle\n prevsingle.couple = s\n prevsingle = s\n\n if False: #DEBUG: \n print(\"view subj entries\")\n for s in self.iter():\n print(s, s.entry)\n\n\n\n\n\n # phase three - construct a list of clipped polygons\n # --------------------------------------------------\n\n ######\n # Defs\n def next_unprocessed(vert):\n origvert = vert\n while vert:\n if vert.entry and not (vert.checked or vert.neighbour.checked):\n #print \"vert, found next unproc\", vert, vert.checked, vert.neighbour.checked\n if vert.couple:\n # rule 1\n if vert.couple.entry and vert.entry:\n # rule 2\n if vert.couple.entry == \"en\" and vert.entry == \"en\":\n return vert.couple\n elif vert.couple.entry == \"ex\" and vert.entry == \"ex\":\n return vert\n # rule 3\n else:\n return vert\n \n vert = vert.__next__\n \n if vert == origvert:\n # if returned to first, return None\n return None\n\n def DeleteFlag1(cur, stat):\n if cur.entry == \"en/ex\":\n cur.entry = None\n if cur.cross_change:\n if stat == \"D3\":\n return \"D3\"\n else:\n return \"D4\"\n if stat == \"D3\":\n return \"D4\"\n else:\n return \"D3\"\n if cur.entry == \"ex/en\":\n if stat == \"D3\":\n cur.entry = \"en\"\n return \"D2\"\n else:\n cur.entry = \"ex\"\n return \"D1\"\n if cur.entry == \"en\":\n cur.entry = None\n return \"D1\"\n if cur.entry == \"ex\":\n cur.entry = None\n return \"D2\"\n\n def DeleteFlag2(cur, prev, stat):\n if cur.entry == \"en/ex\":\n if stat == \"D1\":\n cur.entry = \"ex\"\n else:\n cur.entry = \"en\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex/en\":\n if stat == \"D1\":\n cur.entry = \"en\"\n else:\n cur.entry = \"ex\"\n if cur.cross_change:\n if stat == \"D1\":\n return \"D4\"\n else:\n return \"D3\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"en\":\n cur.entry = None\n if stat == \"D1\" and cur.couple and prev.couple == cur:\n return \"D1\"\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n if cur.entry == \"ex\":\n cur.entry = None\n if stat != \"D1\" and cur.couple and prev.couple == cur:\n return \"D2\"\n else:\n if stat == \"D1\":\n return \"D3\"\n else:\n return \"D4\"\n\n def proceed(cur, stat):\n cur.checked = True\n if stat == \"D1\":\n clipped.add(Vertex(cur))\n return cur.__next__\n elif stat == \"D2\":\n clipped.add(Vertex(cur))\n return cur.prev\n else:\n return cur.neighbour\n\n ####\n resultpolys = []\n\n self.first.checked = True\n cur = prev = start = next_unprocessed(self.first)\n\n while cur:\n # each new polygon\n print(\"new poly\")\n\n stat = DeleteFlag1(cur, \"D3\")\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n clipped = Polygon()\n cur = proceed(cur, stat)\n\n # collect vertexes\n while cur != start:\n if DEBUG: print(\"v\", cur, cur.entry, stat)\n if cur.entry:\n if stat == \"D1\" or stat == \"D2\":\n stat = DeleteFlag2(cur, prev, stat)\n else:\n stat = DeleteFlag1(cur, stat)\n prev = cur\n cur = proceed(cur, stat)\n\n # return to first vertex\n clipped.add(Vertex(clipped.first))\n\n print(clipped)\n\n resultpolys.append((clipped,[]))\n cur = prev = start = next_unprocessed(self.first)\n\n\n\n # finally, sort into exteriors and holes\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\n for otherext,otherholes in resultpolys:\n if polyext == otherext:\n continue # don't compare to self\n if polyext.first.isInside(otherext):\n otherholes.append(polyext) #poly is within other so make into a hole\n del resultpolys[pindex] #and delete poly from being an independent poly\n return resultpolys","def _select_masks_to_boundaries(self, select_masks):\n\n def _merge(node_covers, select_idx):\n \"\"\"\n node_covers [[s1, e1], [s2, e2], ..., [sn, en]]\n \"\"\"\n new_node_covers = []\n for i in range(len(node_covers) - 1):\n if i == select_idx:\n merge_node_boundary = [node_covers[select_idx][0], node_covers[select_idx + 1][1]]\n new_node_covers.append(merge_node_boundary)\n elif i < select_idx:\n new_node_covers.append(node_covers[i])\n else:\n new_node_covers.append(node_covers[i + 1])\n return new_node_covers, merge_node_boundary\n batch_size = select_masks[0].size()[0]\n max_length = select_masks[0].size()[1] + 1\n combine_matrix = torch.rand(batch_size, max_length, 2).long()\n for j in range(max_length):\n combine_matrix[:, j, :] = j\n results = []\n for batch_idx in range(batch_size):\n node_covers = combine_matrix[batch_idx, :, :].numpy().tolist()\n result = []\n for node_idx in range(max_length - 2):\n select = select_masks[node_idx][batch_idx, :]\n select_idx = torch.nonzero(select).data[0][0]\n node_covers, merge_boundary = _merge(node_covers, select_idx)\n result.append(merge_boundary)\n results.append(result)\n results = torch.LongTensor(results)\n return results","def merge_mesh(x1, ngroups1, conn1, mat_ids1, x2, ngroups2, conn2, mat_ids2,\n cmap):\n n1 = x1.shape[0]\n n2 = x2.shape[0]\n\n err = nm.sum(nm.sum(nm.abs(x1[cmap[:,0],:-1] - x2[cmap[:,1],:-1])))\n if abs(err) > (10.0 * eps):\n raise ValueError('nonmatching meshes! (error: %e)' % err)\n\n mask = nm.ones((n2,), dtype=nm.int32)\n mask[cmap[:,1]] = 0\n remap = nm.cumsum(mask) + n1 - 1\n remap[cmap[:,1]] = cmap[:,0]\n\n i2 = nm.setdiff1d(nm.arange( n2, dtype=nm.int32), cmap[:,1])\n xx = nm.r_[x1, x2[i2]]\n ngroups = nm.r_[ngroups1, ngroups2[i2]]\n\n conn = nm.vstack((conn1, remap[conn2]))\n\n mat_ids = None\n if (mat_ids1 is not None) and (mat_ids2 is not None):\n mat_ids = nm.concatenate((mat_ids1, mat_ids2))\n\n return xx, ngroups, conn, mat_ids","def build_contacting(masks, r=1):\n source_nodes = []\n target_nodes = []\n for i in range(1, masks.max()+1):\n neigh = find_neighbors(masks, i, r=r)\n source_nodes.append([i]*(neigh.size))\n target_nodes.append(neigh)\n # flatten arrays of arrays\n source_nodes = np.fromiter(itertools.chain.from_iterable(source_nodes), int).reshape(-1,1)\n target_nodes = np.fromiter(itertools.chain.from_iterable(target_nodes), int).reshape(-1,1)\n # remove duplicate pairs\n pairs = np.hstack((source_nodes, target_nodes))\n pairs = remove_duplicate_pairs(pairs)\n return pairs","def find_original_contours(self):\r\n\r\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\r\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\r\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\r\n int(self.cell_size), 5)\r\n self.thresh_orig = 255 - self.thresh_invert\r\n\r\n # Find the contours of the image. Each contour should correspond to a cell\r\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\r\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\r\n for block in orig_contours:\r\n area = cv2.contourArea(block)\r\n\r\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\r\n if area < self.min_cell_size:\r\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)","def intrapop_connections(n_mitral, n_granule, n_subpop, n_mitral_per_subpop):\n resmat = np.zeros((n_mitral, n_granule))\n for i_subpop in xrange(n_subpop):\n start = i_subpop*n_mitral_per_subpop\n stop = start + n_mitral_per_subpop\n resmat[start:stop, i_subpop] = 1.\n return resmat","def get_bundle_corner(\n ports1: List[Port],\n ports2: List[Port],\n route_filter: Callable[..., Route] = get_route_from_waypoints,\n separation: float = 5.0,\n path_length_match_loops: int = None,\n path_length_match_extra_length: float = 0.0,\n path_length_match_modify_segment_i: int = -2,\n **kwargs,\n) -> List[Route]:\n if \"straight\" in kwargs.keys():\n _ = kwargs.pop(\"straight\")\n\n routes = _get_bundle_corner_waypoints(\n ports1,\n ports2,\n routing_func=generate_manhattan_waypoints,\n separation=separation,\n **kwargs,\n )\n if path_length_match_loops:\n routes = [np.array(route) for route in routes]\n routes = path_length_matched_points(\n routes,\n extra_length=path_length_match_extra_length,\n nb_loops=path_length_match_loops,\n modify_segment_i=path_length_match_modify_segment_i,\n **kwargs,\n )\n\n return [route_filter(r, **kwargs) for r in routes]","def __fcc_transition_diagonals(self) -> cq.cq.Workplane:\n corner_points = self.unit_cell_size * np.array(\n [(0, 0),\n (1, 0),\n (1, 0),\n (1, 1),\n (1, 1),\n (0, 1)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_fcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": self.unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": 0,\n \"angle_y\": 45},\n {\"unit_cell_size\": self.unit_cell_size * 0.5,\n \"radius\": self.strut_radius,\n \"angle_x\": 0,\n \"angle_y\": - 45},\n {\"unit_cell_size\": self.unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": -45,\n \"angle_y\": 0},\n {\"unit_cell_size\": self.unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": 45,\n \"angle_y\": 0},\n {\"unit_cell_size\": self.unit_cell_size * 0.5,\n \"radius\": self.strut_radius,\n \"angle_x\": 0,\n \"angle_y\": - 45},\n {\"unit_cell_size\": self.unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": 0,\n \"angle_y\": 45}\n ],\n useLocalCoords = True\n )\n )\n return result","def segment_neighborhood(self, complexes, reactions):\n\t\t\t\t\n\t\t# First we initialize the graph variables that will be used for\n\t\t# Tarjan's algorithm\n\t\t\n\t\tself._tarjan_index = 0\n\t\tself._tarjan_stack = []\n\t\tself._SCC_stack = []\n\n\t\t# Set up for Tarjan's algorithm\n\t\tfor node in complexes:\n\t\t\tnode._outward_edges = []\n\t\t\tnode._full_outward_edges = []\n\t\t\tnode._index = -1\n\t\tfor reaction in reactions:\n\t\t\tfor product in reaction.products:\n\t\t\t\tproduct._outward_edges = []\n\t\t\t\tproduct._full_outward_edges = []\n\t\t\t\tproduct._index = -1\n\t\t\t\t\n\t\t# Detect which products are actually in the neighborhood\t\n\t\tfor reaction in reactions:\n\t\t\tfor product in reaction.products:\n\t\t\t\tproduct_in_N = False\n\t\t\t\t\n\t\t\t\tfor complex in complexes:\n\t\t\t\t\tif (complex == product):\n\t\t\t\t\t\tproduct_in_N = True\n\t\t\t\t\t\tbreak\n\t\t\t\t\n\t\t\t\t# If this product is in the neighborhood, we have an edge\n\t\t\t\tif product_in_N:\n\t\t\t\t\t# We know all these reactions are unimolecular\n\t\t\t\t\treaction.reactants[0]._outward_edges.append(product)\n\t\t\t\treaction.reactants[0]._full_outward_edges += (reaction.products)\n\n\t\t\t\t\t\n\t\t\tnode._lowlink = -1\t\t\t\n\t\t\t\n\t\t# We now perform Tarjan's algorithm, marking nodes as appropriate\n\t\tfor node in complexes:\n\t\t\tif node._index == -1:\n\t\t\t\tself.tarjans(node)\n\t\t\n\t\t# Now check to see which of the SCCs are resting states\n\t\tresting_states = []\n\t\tresting_state_complexes = []\n\t\ttransient_state_complexes = []\n\t\tfor scc in self._SCC_stack:\n\t\t\tscc_products = []\n\t\t\tis_resting_state = True\n\t\t\t\n\t\t\tfor node in scc:\n\t\t\t\tfor product in node._full_outward_edges:\n\t\t\t\t\tscc_products.append(product)\n\t\t\t\n\t\t\tfor product in scc_products:\n\t\t\t\tproduct_in_scc = False\n\t\t\t\tfor complex in scc:\n\t\t\t\t\tif product == complex:\n\t\t\t\t\t\tproduct_in_scc = True\n\t\t\t\t\t\tbreak\n\t\t\t\t\n\t\t\t\t# If the product is not in the SCC, then there is a fast edge\n\t\t\t\t# leading out of the SCC, so this is not a resting state\n\t\t\t\tif not product_in_scc:\n\t\t\t\t\tis_resting_state = False\n\t\t\t\t\tbreak\n\t\t\t\n\t\t\tif is_resting_state:\n\t\t\t\tresting_state_complexes += (scc)\n\t\t\t\tresting_state = RestingState(self.get_auto_name(), scc[:])\n\t\t\t\tresting_states.append(resting_state)\n\t\t\t\t\n\t\t\telse:\n\t\t\t\ttransient_state_complexes += (scc)\n\t\tresting_states.sort()\n\t\tresting_state_complexes.sort()\n\t\ttransient_state_complexes.sort()\n\t\treturn {\n\t\t\t\t'resting_states': resting_states, \n\t\t\t 'resting_state_complexes': resting_state_complexes,\n\t\t\t\t'transient_state_complexes': transient_state_complexes\n\t\t\t\t}","def fix_double_nodes(coor, ngroups, conns):\n n_nod, dim = coor.shape\n cmap = find_map(coor, nm.zeros((0,dim)), allow_double=True)\n if cmap.size:\n output('double nodes in input mesh!')\n output('trying to fix...')\n\n while cmap.size:\n # Just like in Variable.equation_mapping()...\n ii = nm.argsort(cmap[:,1])\n scmap = cmap[ii]\n\n eq = nm.arange(n_nod)\n eq[scmap[:,1]] = -1\n eqi = eq[eq >= 0]\n eq[eqi] = nm.arange(eqi.shape[0])\n remap = eq.copy()\n remap[scmap[:,1]] = eq[scmap[:,0]]\n output(coor.shape)\n coor = coor[eqi]\n ngroups = ngroups[eqi]\n output(coor.shape)\n ccs = []\n for conn in conns:\n ccs.append(remap[conn])\n conns = ccs\n cmap = find_map(coor, nm.zeros((0,dim)), allow_double=True)\n output('...done')\n return coor, ngroups, conns","def new_decomposition(self):\n from sage.combinat.binary_tree import BinaryTree\n t_low = self.lower_binary_tree().to_tilting()\n t_up = self.upper_binary_tree().to_tilting()\n common = [p for p in t_low if p in t_up]\n\n def extract_tree(x, y, tilt, common):\n \"\"\"\n Extract a tree with root at position xy (recursive).\n \"\"\"\n left_tree = None\n for k in range(y - 1, x, -1):\n if (x, k) in tilt:\n if (x, k) not in common:\n left_tree = extract_tree(x, k, tilt, common)\n break\n right_tree = None\n for k in range(x + 1, y):\n if (k, y) in tilt:\n if (k, y) not in common:\n right_tree = extract_tree(k, y, tilt, common)\n break\n return BinaryTree([left_tree, right_tree])\n\n TIP = self.parent()\n return [TIP.from_binary_trees(extract_tree(cx, cy, t_low, common),\n extract_tree(cx, cy, t_up, common))\n for cx, cy in common]","def Compare2dMasksFrom3dMasks(OrigSegRoi, NewSegRoi, OrigDicomDir, NewDicomDir): \n \n from DicomTools import GetDicomSOPuids\n from SegTools import GetPFFGStoSliceInds\n import matplotlib.pyplot as plt\n \n # Get the DICOM SOP UIDs:\n OrigSOPuids = GetDicomSOPuids(DicomDir=OrigDicomDir)\n NewSOPuids = GetDicomSOPuids(DicomDir=NewDicomDir)\n \n # Get the Per-frameFunctionalGroupsSequence-to-slice indices:\n OrigPFFGStoSliceInds = GetPFFGStoSliceInds(OrigSegRoi, OrigSOPuids)\n NewPFFGStoSliceInds = GetPFFGStoSliceInds(NewSegRoi, NewSOPuids)\n \n # Combined indices from OrigPFFGStoSliceInds and NewPFFGStoSliceInds:\n AllInds = OrigPFFGStoSliceInds + NewPFFGStoSliceInds\n \n # Remove duplicates:\n AllInds = list(set(AllInds))\n \n \n # Get the 3D SEG masks:\n Orig3dMask = OrigSegRoi.pixel_array\n New3dMask = NewSegRoi.pixel_array\n \n OrigShape = Orig3dMask.shape\n NewShape = New3dMask.shape\n \n print(f'Segments exist in OrigSegRoi on slices {OrigPFFGStoSliceInds}')\n print(f'Shape of Orig3dMask = {OrigShape}')\n print(f'\\nSegments exist in NewSegRoi on slices {NewPFFGStoSliceInds}')\n print(f'Shape of New3dMask = {NewShape}\\n')\n \n # Initialise the 3D cropped SEG masks:\n Orig3dMaskCropped = []\n New3dMaskCropped = []\n \n for i in range(OrigShape[0]):\n cropped = CropNonZerosIn2dMask(Orig3dMask[i])\n \n Orig3dMaskCropped.append(cropped)\n \n for i in range(NewShape[0]):\n cropped = CropNonZerosIn2dMask(New3dMask[i])\n \n New3dMaskCropped.append(cropped)\n \n \n Nrows = len(AllInds)\n \n Ncols = 2\n \n n = 1 # initialised sub-plot number\n \n fig, ax = plt.subplots(Nrows, Ncols, figsize=(5*Ncols, 6*Nrows))\n \n for i in range(len(AllInds)):\n SliceNum = AllInds[i]\n \n # Does slice SliceNum have a segment in OrigSegRoi or NewSegRoi?\n if SliceNum in OrigPFFGStoSliceInds:\n OrigFrameNum = OrigPFFGStoSliceInds.index(SliceNum)\n \n ax = plt.subplot(Nrows, Ncols, n, aspect='equal')\n ax.imshow(Orig3dMaskCropped[OrigFrameNum])\n ax.set_xlabel('Pixels'); ax.set_ylabel('Pixels')\n ax.set_title(f'Orig slice {SliceNum}')\n \n n += 1 # increment sub-plot number\n \n if SliceNum in NewPFFGStoSliceInds:\n NewFrameNum = NewPFFGStoSliceInds.index(SliceNum)\n \n ax = plt.subplot(Nrows, Ncols, n, aspect='equal')\n ax.imshow(New3dMaskCropped[NewFrameNum])\n ax.set_xlabel('Pixels'); ax.set_ylabel('Pixels')\n ax.set_title(f'New slice {SliceNum}')\n \n n += 1 # increment sub-plot number\n \n return","def double_crossover(self, original1, original2):\n point1=self.r.uniform(0.1,0.3)\n point2=self.r.uniform(0.6,0.8)\n len1=len(original1)\n len2=len(original2)\n cut11=int(point1*len1)\n cut12=int(point2*len1)\n cut21=int(point1*len2)\n cut22=int(point2*len2)\n child1=original1[:cut11]+original2[cut21:cut22]+original1[cut12:]\n child2=original2[:cut21]+original1[cut11:cut12]+original2[cut22:]\n return child1, child2","def group_connected(triggers):\n groups = []\n ungrouped = set((x, y, difficulty) for (x, y), difficulty in triggers.items())\n while ungrouped:\n x, y, difficulty = ungrouped.pop()\n pos = x, y\n locs = [pos]\n queue = [pos]\n while queue:\n pos = queue.pop()\n for x, y in HexGrid.neighbours(pos):\n if (x, y, difficulty) in ungrouped:\n ungrouped.discard((x, y, difficulty))\n c = x, y\n locs.append(c)\n queue.append(c)\n groups.append(TriggerArea(locs, difficulty))\n\n groups_by_loc = {}\n for g in groups:\n for l in g.locs:\n groups_by_loc[l] = g\n return groups, groups_by_loc","def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\n\n device += 1\n\n if len(np.shape(img)) == 3:\n iy, ix, iz = np.shape(img)\n else:\n iy, ix, = np.shape(img)\n\n # get the break groups\n\n if nrow == 1:\n rbreaks = [0, iy]\n else:\n rstep = np.rint(iy / nrow)\n rstep1 = np.int(rstep)\n rbreaks = range(0, iy, rstep1)\n if ncol == 1:\n cbreaks = [0, ix]\n else:\n cstep = np.rint(ix / ncol)\n cstep1 = np.int(cstep)\n cbreaks = range(0, ix, cstep1)\n\n # categorize what bin the center of mass of each contour\n\n def digitize(a, step):\n if isinstance(step, int) == True:\n i = step\n else:\n i = len(step)\n for x in range(0, i):\n if x == 0:\n if a >= 0 and a < step[x + 1]:\n return x + 1\n elif a >= step[x - 1] and a < step[x]:\n return x\n elif a > step[x - 1] and a > np.max(step):\n return i\n\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\n coord = []\n for i in range(0, len(roi_objects)):\n m = cv2.moments(roi_objects[i])\n if m['m00'] == 0:\n pass\n else:\n cx = int(m['m10'] / m['m00'])\n cy = int(m['m01'] / m['m00'])\n # colbin = np.digitize(cx, cbreaks)\n # rowbin = np.digitize(cy, rbreaks)\n colbin = digitize(cx, cbreaks)\n rowbin = digitize(cy, rbreaks)\n a = (cx, cy, colbin, rowbin, i)\n coord.append(a)\n coord1 = np.array(coord, dtype=dtype)\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\n\n # get the list of unique coordinates and group the contours with the same bin coordinates\n\n groups = []\n for i, y in enumerate(coord2):\n col = y[3]\n row = y[2]\n location = str(row) + ',' + str(col)\n groups.append(location)\n\n unigroup = np.unique(groups)\n coordgroups = []\n\n for i, y in enumerate(unigroup):\n col = int(y[0])\n row = int(y[2])\n for a, b in enumerate(coord2):\n if b[2] == col and b[3] == row:\n grp = i\n contour = b[4]\n coordgroups.append((grp, contour))\n else:\n pass\n\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\n\n contours = roi_objects\n grouped_contour_indexes = coordlist\n\n # Debug image is rainbow printed contours\n\n if debug == 'print':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n print_image(img_copy, (str(device) + '_clusters.png'))\n\n elif debug == 'plot':\n if len(np.shape(img)) == 3:\n img_copy = np.copy(img)\n else:\n iy, ix = np.shape(img)\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\n\n rand_color = color_palette(len(coordlist))\n for i, x in enumerate(coordlist):\n for a in x:\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\n plot_image(img_copy)\n\n return device, grouped_contour_indexes, contours","def innerProd(linearCombo1, linearCombo2):\n innerProd = 0\n # TODO: I'm starting with simple sets on both sides, not sum of sets, \n # with coefficient 1. We need to fix this later\n # TODO: find way to represent dashed vs undashed arrows\n # For now, assume both are already sums (sets) of dashed subdiagrams\n\n # copy linear combinations to make it easier to alter them as needed\n linearComboCopy1 = deepcopy(linearCombo1)\n linearComboCopy2 = deepcopy(linearCombo2)\n print len(linearComboCopy2[0][1])\n\n # get list of subdiagrams, get coefficients\n for coeffAndSubdiagrams1 in linearComboCopy1:\n subdiagramSet1 = coeffAndSubdiagrams1[1]\n coeff1 = coeffAndSubdiagrams1[0]\n subdiagramsToRemove1 = []\n\n for coeffAndSubdiagrams2 in linearComboCopy2:\n subdiagramSet2 = coeffAndSubdiagrams2[1]\n coeff2 = coeffAndSubdiagrams2[0]\n subdiagramsToRemove2 = []\n\n # look for equivalent pairs of dashed subdiagrams in both lists\n for subdiagram1 in subdiagramSet1:\n for subdiagram2 in subdiagramSet2: \n # for equivalent pairs of dashed subdiagrams, increment innerProd by \n # product of coefficients and remove the subdiagrams to avoid \n # over-counting diagrams\n if equiv(subdiagram1, subdiagram2):\n innerProd += coeff1 * coeff2\n subdiagramsToRemove1.append(subdiagram1)\n subdiagramsToRemove2.append(subdiagram2)\n print \" \", innerProd\n # remove the used subdiagrams\n # print \"sub 2\\t\" + str(subdiagramSet2)\n # print \" 2 \" + str(subdiagramsToRemove2)\n # print \" 1 \" + str(subdiagramsToRemove1)\n for removal2 in subdiagramsToRemove2:\n # print \" remove \" + str(removal2)\n subdiagramSet2.remove(removal2)\n subdiagramsToRemove2 = []\n # for removal1 in subdiagramsToRemove1:\n # subdiagramSet1.remove(removal1) \n return innerProd","def remove_adjacent_grid(self, pg1, pg2, adj_grids):\n\n if pg1.size()>pg2.size():\n bigger = pg1\n smaller = pg2\n else:\n bigger = pg2\n smaller = pg1\n \n for adj in adj_grids:\n \n\n # If the adjacent grids are a subset of the secondary grids (i.e. not necessary)\n # remove them from each\n if adj in bigger.secondary_grids:\n debug.info(3,\"Removing {} from bigger secondary {}\".format(adj, bigger))\n bigger.grids.remove(adj)\n bigger.secondary_grids.remove(adj)\n self.blocked_grids.add(adj)\n elif adj in smaller.secondary_grids:\n debug.info(3,\"Removing {} from smaller secondary {}\".format(adj, smaller))\n smaller.grids.remove(adj)\n smaller.secondary_grids.remove(adj)\n self.blocked_grids.add(adj)\n else:\n # If we couldn't remove from a secondary grid, we must remove from the primary\n # grid of at least one pin\n if adj in bigger.grids:\n debug.info(3,\"Removing {} from bigger primary {}\".format(adj, bigger))\n bigger.grids.remove(adj)\n elif adj in smaller.grids:\n debug.info(3,\"Removing {} from smaller primary {}\".format(adj, smaller))\n smaller.grids.remove(adj)","def box_ciou(boxes1, boxes2):\n area1 = box_area(boxes1)\n area2 = box_area(boxes2)\n\n lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2]\n rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2]\n\n wh = (rb - lt).clamp(min=0) # [N,M,2]\n inter = wh[:, :, 0] * wh[:, :, 1] # [N,M]\n\n # Calculate the diagonal length of the smallest bbox covering the 2 boxes\n clt=torch.min(boxes1[:, None, :2], boxes2[:, :2])\n crb=torch.max(boxes1[:, None, 2:], boxes2[:, 2:])\n outer_diag=((crb-clt)**2).sum(dim=2)\n # Calculate the euclidean distance between central points of boxes1 and boxes2\n center_x1=(boxes1[:, None, 0] + boxes1[:, None, 2])/2\n center_y1=(boxes1[:, None, 1] + boxes1[:, None, 3])/2\n center_x2=(boxes2[:, None, 0] + boxes2[:, None, 2])/2\n center_y2=(boxes2[:, None, 1] + boxes2[:, None, 3])/2\n inner_diag=(center_x1-center_x2.t())**2 + (center_y1-center_y2.t())**2\n union = area1[:, None] + area2 - inter\n # Aspect ratio parameter\n w1 = boxes1[:, 2] - boxes1[:, 0]\n h1 = boxes1[:, 3] - boxes1[:, 1]\n w2 = boxes2[:, 2] - boxes2[:, 0]\n h2 = boxes2[:, 3] - boxes2[:, 1]\n v = (4 / (math.pi**2)) * torch.square((torch.atan(w2/h2) - torch.atan(w1/h1)))\n # Trade-off parameter\n alpha = v / (1- inter/union + v)\n # Calculate ciou\n cious = inter/union - (inner_diag/outer_diag + alpha*v)\n cious = torch.clamp(cious, min=-1.0, max = 1.0)\n return cious","def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\n orderOfSCsByValueByFrame = [\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\n ]\n return scListByFrame, orderOfSCsByValueByFrame","def sweep_CPPN(genotype, E1, subp_1, subp_2, norm_in, canvas):\n\n\t# get value from widget field\n\tinnov_num = E1.get()\n\n\t# find index of desired connection\n\tindex = -1\n\tfor con_ind in range(len(genotype.connections)):\n\t\tif(genotype.connections[con_ind].getInnovationNumber() == innov_num):\n\t\t\tindex = con_ind\n\told_weight = genotype.connections[con_ind].getWeight()\n\n\tsweep_weight = 10\n\twhile(sweep_weight > -10):\n\t\tgenotype.connections[con_ind].setWeight(sweep_weight)\n\t\t# clear both subplots so new graphs can be placed into the GUI\n\t\tsubp_1.clear()\n\t\tsubp_2.clear()\n\n\t\t# create graphs again and put graphs onto them\n\t\toutputs = []\n\t\tfor ins in norm_in:\n\t\t\toutputs.append(genotype.getOutput(ins)[0])\n\t\toutputs_np = np.array(outputs, copy=True)\n\t\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\n\n\t\tgraph_genotype_GUI(genotype, subp_2)\n\n\t\tcanvas.show()\n\t\tcanvas.get_tk_widget().pack()\n\t\tsweep_weight -= .5\n\t\ttime.sleep(TIME_DELAY)\n\n\t# reset the graphs to their old state with the original weight\n\tgenotype.connections[con_ind].setWeight(old_weight)\n\t# clear both subplots so new graphs can be placed into the GUI\n\tsubp_1.clear()\n\tsubp_2.clear()\n\n\t# create graphs again and put graphs onto them\n\toutputs = []\n\tfor ins in norm_in:\n\t\toutputs.append(genotype.getOutput(ins)[0])\n\toutputs_np = np.array(outputs, copy=True)\n\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\n\n\tgraph_genotype_GUI(genotype, subp_2)\n\n\tcanvas.show()\n\tcanvas.get_tk_widget().pack()","def _build_adjacency_matrix_2(self):\n\n from scipy import sparse as sparse\n \n down_neighbour = np.empty(self.tri.npoints)\n down_neighbour1 = np.empty(self.tri.npoints)\n\n for node in range (0,self.tri.npoints):\n down_neighbour[node] = self.neighbour_array_lo_hi[node][0]\n down_neighbour1[node] = self.neighbour_array_lo_hi[node][1]\n\n # Build a matrix of downhill-ness - one entry per node ! \n \n size = self.tri.npoints\n row_array = np.empty(size)\n col_array = np.empty(size)\n down_array = np.ones(size)\n\n # Catch cases where node is local low point (i.e. it is its own low neighbour)\n for row in range(0, self.tri.npoints): \n row_array[row] = row\n col_array[row] = down_neighbour1[row]\n if row == down_neighbour[row]:\n down_array[row] = 0.0 \n if row == down_neighbour1[row]:\n col_array[row] = down_neighbour[row]\n\n\n downMCOO = sparse.coo_matrix( (down_array, (row_array, col_array)), shape=(size,size) ).T \n self.adjacency2 = downMCOO.tocsr() \n\n # Catch pathological cases - sometimes if there is a flat spot on the boundary, then \n # the filling method above will produce a non-square matrix. This is caused by\n # repetition of values in the COO list which are summed on conversion.\n\n if downMCOO.shape[0] != downMCOO.shape[1]:\n # This approach works but is a lot slower\n\n print \"\"\"\n Warning: the downhill matrices require a slow build method. This is probably\n Because there are degeneracies in the slope - particularly at the boundaries\n A small random perturbation is usually enough to fix this problem\n \"\"\"\n downMat = sparse.lil_matrix((size, size))\n\n for row in range(0, self.tri.npoints): \n downMat[down_neighbour[row],row] = 1.0\n\n for row in range(0, self.tri.npoints): \n if row == down_neighbour[row] or row == down_neighbour1[row]:\n downMat[row,row] = 0.0\n \n self.adjacency2 = downMat.T.tocsr() \n\n return","def mark_contours(contour_arr, img, symmetry, _plot=False):\n marg, flag = 7, 0\n # fig, ax = plt.subplots()\n # ax.imshow(img, cmap=\"gray\")\n sub_images = [] # init array for pictures\n for contour in contour_arr:\n\n lower_dim = contour[:, 0]\n x, y = lower_dim[:, 0], lower_dim[:, 1]\n min_x, min_y, max_x, max_y = min(x), min(y), max(x), max(y)\n\n # remove small noise\n if (max_x - min_x) * (max_y - min_y) < MIN_IMG_SIZE:\n continue\n # avoid index error\n if min_x - marg < 0 or min_y - marg < 0 or max_y + marg > img.shape[0] or max_x + marg > img.shape[1]:\n marg = 0\n # crop only half cause image is symmetric:\n # TODO: address different types of symmetry as input from user\n if symmetry == HORIZONTAL:\n if max_x <= img.shape[1] // 2:\n sub_images.append(img[min_y:max_y, min_x:max_x])\n flag = 1\n else: # symmetry is around the X-axis\n if max_y <= img.shape[0] // 2:\n sub_images.append(img[min_y:max_y, min_x:max_x])\n flag = 1\n if _plot and flag:\n ax.plot([min_x - marg, max_x + marg, max_x + marg, min_x - marg, min_x - marg],\n [min_y - marg, min_y - marg, max_y + marg, max_y + marg, min_y - marg], c='r', linewidth=0.4)\n flag = 0\n if _plot:\n plt.savefig(\"found_subshapes2.jpg\")\n # plt.show()\n return sub_images","def subdivideMesh(IKLE,MESHX,MESHY): \n # ~~> Singling out edges\n from matplotlib.tri import Triangulation\n edges = Triangulation(MESHX,MESHY,IKLE).get_cpp_triangulation().get_edges()\n \n # ~~> Memory allocation for new MESH\n IELEM = len(IKLE); IPOIN = len(MESHX); IEDGE = len(edges)\n JKLE = np.zeros((IELEM*4,3),dtype=np.int) # you subdivide every elements by 4\n MESHJ = np.zeros((IEDGE,2),dtype=np.int) # you add one point on every edges\n \n # ~~> Lookup tables for node numbering on common edges\n pa,pb = edges.T\n k1b,k1a = np.sort(np.take(IKLE,[0,1],axis=1)).T\n indx1 = np.searchsorted(pa,k1a)\n jndx1 = np.searchsorted(pa,k1a,side='right')\n k2b,k2a = np.sort(np.take(IKLE,[1,2],axis=1)).T\n indx2 = np.searchsorted(pa,k2a)\n jndx2 = np.searchsorted(pa,k2a,side='right')\n k3b,k3a = np.sort(np.take(IKLE,[2,0],axis=1)).T\n indx3 = np.searchsorted(pa,k3a)\n jndx3 = np.searchsorted(pa,k3a,side='right')\n \n # ~~> Building one triangle at a time /!\\ Please get this loop parallelised\n j = 0\n for i in range(IELEM):\n k1 = indx1[i]+np.searchsorted(pb[indx1[i]:jndx1[i]],k1b[i])\n k2 = indx2[i]+np.searchsorted(pb[indx2[i]:jndx2[i]],k2b[i])\n k3 = indx3[i]+np.searchsorted(pb[indx3[i]:jndx3[i]],k3b[i])\n # ~~> New connectivity JKLE\n JKLE[j] = [IKLE[i][0],IPOIN+k1,IPOIN+k3]\n JKLE[j+1] = [IKLE[i][1],IPOIN+k2,IPOIN+k1]\n JKLE[j+2] = [IKLE[i][2],IPOIN+k3,IPOIN+k2]\n JKLE[j+3] = [IPOIN+k1,IPOIN+k2,IPOIN+k3]\n # ~~> New interpolation references for values and coordinates\n MESHJ[k1] = [IKLE[i][0],IKLE[i][1]]\n MESHJ[k2] = [IKLE[i][1],IKLE[i][2]]\n MESHJ[k3] = [IKLE[i][2],IKLE[i][0]]\n j += 4\n\n # ~~> Reset IPOBO while you are at it\n MESHX = np.resize(MESHX,IPOIN+IEDGE)\n MESHY = np.resize(MESHY,IPOIN+IEDGE)\n MESHX[IPOIN:] = np.sum(MESHX[MESHJ],axis=1)/2.\n MESHY[IPOIN:] = np.sum(MESHY[MESHJ],axis=1)/2.\n neighbours = Triangulation(MESHX,MESHY,JKLE).get_cpp_triangulation().get_neighbors()\n JPOBO = np.zeros(IPOIN+IEDGE,np.int)\n for n in range(IELEM*4):\n s1,s2,s3 = neighbours[n]\n e1,e2,e3 = JKLE[n]\n if s1 < 0:\n JPOBO[e1] = e1+1\n JPOBO[e2] = e2+1\n if s2 < 0:\n JPOBO[e2] = e2+1\n JPOBO[e3] = e3+1\n if s3 < 0:\n JPOBO[e3] = e3+1\n JPOBO[e1] = e1+1\n\n return JKLE,MESHX,MESHY,JPOBO,MESHJ","def get_groups(board: numpy.ndarray, player: int) -> List[Group]:\n # Generate couples\n # Array of (p1, p2, x) where x = -1 if p1 == p2, 0 if p1 and p2 are close and 1 if they are close\n couples = []\n size = board.shape[0]\n for i in range(1, size - 1):\n for j in range(1, size - 1):\n if board[i, j] == player:\n l0 = [(i + x, j + y) for x, y in NEIGHBORS_1]\n l1 = [(i + x, j + y) for x, y in NEIGHBORS_2]\n for p in l0 + l1 + [(i, j)]:\n corner = all([x in [0, size - 1] for x in p])\n if 0 <= p[0] < size and 0 <= p[1] < size and board[p] == player and not corner:\n if p == (i, j):\n couples.append(((i, j), p, -1))\n elif p in l0:\n couples.append(((i, j), p, 0))\n else:\n p1, p2 = get_common_neighbours((i, j), p)\n if player not in [board[p1], board[p2]] and (board[p1] == -1 and board[p2] == -1):\n couples.append(((i, j), p, 1))\n\n # Group couples\n groups = [[k] for k in couples]\n\n def fusion(f_groups):\n for group1 in f_groups:\n for group2 in f_groups:\n if group1 != group2:\n for c1 in group1:\n for c2 in group2:\n if c1[0] == c2[0] or c1[0] == c2[1] or c1[1] == c2[0] or c1[1] == c2[1]:\n group1.extend(group2)\n f_groups.remove(group2)\n return True\n return False\n\n while fusion(groups):\n pass\n\n return groups","def assign(self, points, gt_bboxes, gt_contours, sizes):\n num_gts, num_points = gt_contours.shape[0], points.shape[0]\n\n if num_points == 0 or num_gts == 0:\n # stores the assigned gt heatmap of each point\n assigned_gt_ct = points.new_ones((num_points,), dtype=torch.long)\n # stores the assigned gt dist (to this point) of each point\n assigned_gt_offsets = points.new_zeros((num_points, 2), dtype=torch.float32)\n pos_inds = torch.nonzero(assigned_gt_ct == 0, as_tuple=False).squeeze(-1).unique()\n neg_inds = torch.nonzero(assigned_gt_ct > 0, as_tuple=False).squeeze(-1).unique()\n\n return assigned_gt_ct, assigned_gt_offsets, pos_inds, neg_inds\n\n points_range = torch.arange(num_points)\n points_xy = points[:, :2]\n points_stride = points[:, 2]\n points_lvl = torch.log2(points_stride).int() # [3...,4...,5...,6...,7...]\n lvl_min, lvl_max = points_lvl.min(), points_lvl.max()\n\n # stores the assigned gt heatmap of each point\n assigned_gt_ct = points.new_ones((num_points,), dtype=torch.long)\n # stores the assigned gt dist (to this point) of each point\n assigned_gt_offsets = points.new_zeros((num_points, 2), dtype=torch.float32)\n\n lvls = torch.arange(lvl_min, lvl_max + 1, dtype=points_lvl.dtype, device=points_lvl.device)\n for gt_lvl in lvls:\n lvl_size = sizes[gt_lvl - 3]\n\n lvl_idx = gt_lvl == points_lvl\n points_index = points_range[lvl_idx]\n\n # generate contours\n downscale_factor = torch.pow(2, gt_lvl)\n\n f_lvl_contours_pts_x = (gt_contours[:, 0] / downscale_factor).clamp_(max=lvl_size[1] - 1)\n lvl_contours_pts_x = torch.round(f_lvl_contours_pts_x)\n f_lvl_contours_pts_y = (gt_contours[:, 1] / downscale_factor).clamp_(max=lvl_size[0] - 1)\n lvl_contours_pts_y = torch.round(f_lvl_contours_pts_y)\n lvl_indices = (lvl_contours_pts_x + lvl_contours_pts_y * lvl_size[1]).to(torch.long)\n\n points_index = points_index[lvl_indices]\n\n assigned_gt_offsets[points_index, 0] = f_lvl_contours_pts_x - lvl_contours_pts_x\n assigned_gt_offsets[points_index, 1] = f_lvl_contours_pts_y - lvl_contours_pts_y\n\n assigned_gt_ct[points_index] = 0\n\n pos_inds = torch.nonzero(assigned_gt_ct == 0, as_tuple=False).squeeze(-1).unique()\n neg_inds = torch.nonzero(assigned_gt_ct > 0, as_tuple=False).squeeze(-1).unique()\n\n return assigned_gt_ct, assigned_gt_offsets, pos_inds, neg_inds","def single_crossover(self, original1, original2):\n point=self.r.uniform(0.1,0.6)\n cut1=int(point*len(original1))\n cut2=int(point*len(original2))\n child1=original1[:cut1]+original2[cut2:]\n child2=original2[:cut2]+original1[cut1:]\n return child1, child2","def plot_links_2d_intra(epo1: mne.Epochs, epo2: mne.Epochs,\n C1: np.ndarray, C2: np.ndarray,\n threshold: str='auto', steps: int=2):\n\n # extract sensor infos and transform loc to fit with headmodel\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\n loc1 = transform_2d_intra(loc1, traX=-0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\n\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\n loc2 = transform_2d_intra(loc2, traX=0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\n\n ctr1 = np.nanmean(loc1, 0)\n ctr2 = np.nanmean(loc2, 0)\n \n # Calculate vmin and vmax for colormap as min and max [C1, C2]\n Cmax1=np.nanmax(C1[:])\n Cmax2=np.nanmax(C2[:])\n Cmax=[]\n Cmax=[Cmax1, Cmax2]\n vmax=np.nanmax(Cmax)\n Cmin1=np.nanmin(C1[:])\n Cmin2=np.nanmin(C2[:])\n Cmin=[]\n Cmin=[Cmin1, Cmin2]\n vmin=np.min(Cmin)\n\n # Calculate automatic threshold\n if threshold == 'auto':\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\n else:\n threshold = threshold\n \n\n # Define colormap for both participant\n cmap_p = matplotlib.cm.get_cmap('Reds')\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\n\n # plot links\n for e1 in range(len(loc1)):\n x1 = loc1[e1, 0]\n y1 = loc1[e1, 1]\n for e2 in range(len(loc1)):\n x2 = loc1[e2, 0]\n y2 = loc1[e2, 1]\n if C1[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n plt.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n plt.plot([xn, xnn], [yn, ynn],\n '-', color=color_p, linewidth=weight)\n if C1[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C1[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n plt.plot([loc1[e1, 0], loc1[e2, 0]],\n [loc1[e1, 1], loc1[e2, 1]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\n b**3 * y2)\n plt.plot([xn, xnn], [yn, ynn],\n '-', color=color_n, linewidth=weight)\n\n for e1 in range(len(loc2)):\n x1 = loc2[e1, 0]\n y1 = loc2[e1, 1]\n for e2 in range(len(loc2)):\n x2 = loc2[e2, 0]\n y2 = loc2[e2, 1]\n if C2[e1, e2] >= threshold:\n color_p = cmap_p(norm_p(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n plt.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n '-', color=color_p, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n plt.plot([xn, xnn], [yn, ynn],\n '-', color=color_p, linewidth=weight)\n if C2[e1, e2] <= -threshold:\n color_n = cmap_n(norm_n(C2[e1, e2]))\n if steps <= 2:\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n plt.plot([loc2[e1, 0], loc2[e2, 0]],\n [loc2[e1, 1], loc2[e2, 1]],\n '-', color=color_n, linewidth=weight)\n else:\n alphas = np.linspace(0, 1, steps)\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\n for idx in range(len(alphas)-1):\n a = alphas[idx]\n b = alphas[idx+1]\n xn = ((1-a)**3 * x1 +\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\n a**3 * x2)\n xnn = ((1-b)**3 * x1 +\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\n b**3 * x2)\n yn = ((1-a)**3 * y1 +\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\n a**3 * y2)\n ynn = ((1-b)**3 * y1 +\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\n b**3 * y2)\n plt.plot([xn, xnn], [yn, ynn],\n '-', color=color_n, linewidth=weight)","def test_1_1_2D_cube_init(self): # TODO: REMOVE FUNC AFTER SPLIT\n check = [(0, 0), (1, 1), (1, 0), (0, 1), (0.5, 0.5)]\n\n nn_checks = {(0.5, 0.5): [(0, 1), (1, 0), (0, 0), (1, 1)],\n (0, 1): [(0, 0), (1, 1), (0.5, 0.5)]}\n\n init_triangulation(2, 0, check, nn_checks)","def cross_junctions(I, bounds, Wpts):\n #--- FILL ME IN ---\n\n Ipts = np.zeros((2, 48))\n\n#parameters\n alpha = 0.15 #typically 0.04 to 0.06\n threshold = 1500 #default 2000\n sigma = 2\n ws = 12 #window size for saddle point\n\n#building Harris Detecter\n I = I/255.0\n gradx, grady = np.gradient(I)\n IxIx = gaussian_filter(gradx*gradx,sigma)\n IxIy = gaussian_filter(gradx*grady,sigma)\n IyIy = gaussian_filter(grady*grady,sigma)\n print(I.shape)\n\n #get harris score\n cand_score = []\n cand_index = []\n cand = []\n s_cand = []\n\n for j in range(len(I)):\n for i in range(len(I[0])):\n a11 = IxIx[j][i]\n a12 = IxIy[j][i]\n a21 = a12\n a22 = IyIy[j][i]\n A = np.array([[a11, a12],[a21, a22]])\n ev0, ev1 = np.linalg.eigvals(A)\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\n cand_score.append(-h_score)\n cand_index.append([i, j])\n\n #get the coordinates of the top 5000 scores\n sorted_ind = np.argsort(cand_score)\n sorted_score = np.sort(cand_score).tolist()\n\n for ind in sorted_ind[:threshold]:\n cand.append(cand_index[ind])\n s_cand = sorted_score[:threshold]\n\n\n#clustering\n #using homography to project candidate points to a up-front view\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\n H = dlt_homography(bounds, new_bbox)\n cand = np.array(cand).T\n cand = np.vstack((cand, np.ones(cand.shape[1])))\n Ho_cand = np.matmul(H,cand).T\n for pt in Ho_cand:\n pt[0] = pt[0]/pt[2]\n pt[1] = pt[1]/pt[2]\n Ho_cand = Ho_cand[:,:2]\n Ho_cand = Ho_cand.tolist()\n\n #get rid of points that are not in the boundry\n temp_Ho_cand = []\n temp_s_cand = []\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\n continue\n else:\n temp_Ho_cand.append(pt)\n temp_s_cand.append(s_cand[i])\n Ho_cand = np.array(temp_Ho_cand)\n s_cand = temp_s_cand\n #divide candidates into clusters\n assignment = []\n assignment_score = []\n\n #first put in the point that has the highest score\n assignment.append([Ho_cand[0]])\n assignment_score.append([s_cand[0]])\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n if min(dist) > 6:\n assignment.append([pt])\n assignment_score.append([s_cand[i]])\n\n assignment = np.array(assignment)\n\n #assign points to clusters\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\n continue\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n index = np.argsort(dist)[-1]\n np.append(assignment[index], pt)\n assignment_score[index].append(s_cand[i])\n\n #get centroids for each cluster\n Ho_centroids = []\n for i in range(len(assignment)):\n cl = assignment[i]\n cl = np.array(cl)\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\n assignment_score[i] = sum(assignment_score[i])\n\n print(len(assignment_score))\n\n Ho_centroids = np.array(Ho_centroids)\n #get rid of edge points\n\n xmin = np.amin(Ho_centroids.T[0])\n xmax = np.amax(Ho_centroids.T[0]) \n ymin = np.amin(Ho_centroids.T[1])\n ymax = np.amax(Ho_centroids.T[1])\n\n final_cand = []\n final_score = []\n for i in range(len(Ho_centroids)):\n pt = Ho_centroids[i]\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\n continue\n else:\n final_cand.append(pt)\n final_score.append(assignment_score[i])\n print(\"Number of corner found: \")\n print(len(final_cand))\n\n #get rid of fake corners\n if (len(final_cand)>48):\n ultimate_cand =[]\n for ind in np.argsort(final_score)[:48]:\n ultimate_cand.append(final_cand[ind])\n final_cand = ultimate_cand\n print(\"real corners count:\", len(ultimate_cand))\n\n\n #sort the points\n final_cand = np.array(final_cand)\n y_sort_ind = np.argsort(final_cand.T[1])\n final_cand = final_cand.tolist()\n rows = []\n for i in range(6):\n row = []\n for ind in y_sort_ind[i*8:(i+1)*8]:\n row.append(final_cand[ind])\n rows.append(row)\n\n ordered = []\n for row in rows:\n r = []\n x_sort_ind = np.argsort(np.array(row).T[0])\n for ind in x_sort_ind:\n r.append(row[ind])\n ordered.append(r)\n\n final_cand = []\n for row in ordered:\n for pt in row:\n final_cand.append(pt)\n \n\n\n #get coordinates of the centroids in the original frame\n Ho_centroids = np.array(final_cand)\n\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\n centroids = np.matmul(np.linalg.inv(H), centroids).T\n for pt in centroids:\n pt[0] = int(pt[0]/pt[2])\n pt[1] = int(pt[1]/pt[2])\n centroids = centroids[:,:2]\n\n#finding saddle points around the centroids\n saddle_points = []\n for pt in centroids:\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\n saddle = saddle_point(img)\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\n saddle_points.append(saddle)\n\n saddle_points = np.array(saddle_points)\n #------------------\n print(saddle_points.T)\n return saddle_points.T","def plot_contour_overlay(I1, I2, contour_level, minval, maxval):\n if I1.shape != I2.shape:\n raise ValueError(\"I1 and I2 must have the same shape\")\n if not skimage_imported:\n raise ImportError(\"skimage not found\")\n \n contours = find_contours(gaussian_filter(I1, 1), contour_level)\n \n fig = figure()\n ax = fig.gca()\n \n I2 = I2.copy()\n I2[I2 < minval] = nan\n I2[I2 > maxval] = maxval\n \n im = ax.imshow(I2, vmin=minval, vmax=maxval, cmap=cm.gray)\n for ct in contours:\n ax.plot(ct[:, 1], ct[:, 0], linewidth=2.0, linestyle=\"-\", color='r')\n \n fig.colorbar(im)\n \n ax.set_xlim(0, size(I1, 1))\n ax.set_ylim(size(I1, 0), 0)\n ax.set_xticks([])\n ax.set_yticks([])\n \n return fig","def intersectConics(E1, E2):\n\n P = np.array([])\n r1 = matrix_rank(E1)\n r2 = matrix_rank(E2)\n \n if(r1==3 and r2==3):\n P = completeIntersection(E1,E2) \n else:\n if (r2 < 3): #E2 is degenerate\n defE = E2\n fullE = E1\n else:\n defE = E1 #E1 is degenerate\n fullE = E2\n m, l = decomposeDegenerateConic(defE)\n P1 = intersectConicLine(fullE,m)\n P2 = intersectConicLine(fullE,l)\n P = np.array([P1, P2])\n points_x = []\n points_y = []\n for i in range(2):\n P1 = P[i]\n if(P1.size!=0):\n for j in range(P1.shape[0]):\n points_x.append(P1[j,0]/P1[j,2])\n points_y.append(P1[j,1]/P1[j,2])\n return points_x, points_y","def test_split_outer_multipolygon_way_2():\n data = cache_query(ways=[15001, 15002], deps=True)\n assert data['ways']['15001']['relations'].keys() == ['15001']\n assert data['ways']['15002']['relations'].keys() == ['15001']\n\n assert query_row(db_conf, 'osm_landusages', 15001) == None\n park_15001 = query_row(db_conf, 'osm_landusages', -15001)\n assert park_15001['type'] == 'park'\n assert_almost_equal(park_15001['geometry'].area, 9816216452, -1)\n assert query_row(db_conf, 'osm_roads', 15002)['type'] == 'residential'","def clusters_connected( self):\n def check_connected( k, vertices, edges):\n dads = {}\n for p in vertices:\n dads[p] = p\n\n def Find( c):\n while c != dads[c]:\n c = dads[c]\n return c\n\n def Union( p, q):\n dads[Find(p)] = Find(q)\n\n for p,q in edges:\n Union( p, q)\n\n stuff = set([ Find(p) for (k,p) in dads.items()])\n assert len(stuff) == 1, \"More than one partition\"\n\n vertices = collections.defaultdict( list)\n for p in itertools.product( range(self.n), repeat=2):\n vertices[self.raster[p]].append( p)\n\n def X():\n for x in range(self.n-1):\n for y in range(self.n):\n yield (x,y),(x+1,y)\n\n def Y():\n for x in range(self.n):\n for y in range(self.n-1):\n yield (x,y),(x,y+1)\n\n connections = collections.defaultdict( list)\n for (p,q) in itertools.chain( X(), Y()):\n if self.raster[p] == self.raster[q]:\n connections[self.raster[p]].append( ( p, q))\n\n for (k,v) in vertices.items():\n check_connected( k, v, connections[k])","def ISOMAPEmbbeding(TurosR=10,Torusr=4,Classes=[3,5,7],nei=[5,10,20], DataSet = {'Turos', 'Digits'}):\n\n S, dig = CreateDS_Torus_Digits(TurosR=TurosR,Torusr=Torusr,Classes=[3,5,7])\n ### ------ Isomap ------###\n nei = nei\n\n if 'Turos' in DataSet:\n # Ploting Torus Isomapping\n fig = plt.figure(figsize=(30, 10))\n for i, j in enumerate(nei):\n Torus_isomap = Isomap(S, 2, j)\n neighbors = j\n method = 'Torus ISOMAP'\n ax = fig.add_subplot(1, len(nei), i + 1)\n scatter = ax.scatter(Torus_isomap[:, 0], Torus_isomap[:, 1], c=S[:, 0:1], cmap=plt.cm.Spectral)\n # legend = ax.legend(*scatter.legend_elements(), loc=\"lower left\", title=\"Classes\")\n # ax.add_artist(legend)\n # ax.legend()\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\n # making_plot(Torus_isomap, pallete=S[:, 0:1], neighbors=j, method='Torus ISOMAP') #An option to plot single graphs\n plt.savefig('Torus ISOMAP embbeding for {} neighbour'.format(nei))\n\n if 'Digits' in DataSet:\n # Plotting Digits Isomapping\n for Argclass, Specificcalss in enumerate(dig):\n fig = plt.figure(figsize=(30, 10))\n for i, j in enumerate(nei):\n neighbors = j\n Digit_isomap = Isomap(Specificcalss[0], 2, j)\n method = 'Digit ISOMAP'\n ax = fig.add_subplot(1, len(nei), i + 1)\n scatter = ax.scatter(Digit_isomap[:, 0], Digit_isomap[:, 1], c=Specificcalss[1], cmap=plt.cm.Spectral)\n legend = ax.legend(*scatter.legend_elements(), loc=\"lower left\", title=\"Classes\")\n ax.add_artist(legend)\n ax.legend()\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\n # making_plot(Digit_isomap, Specificcalss[1], neighbors=j, method='Digit ISOMAP') #An option to plot single graphs\n plt.savefig('Digits up to {} - ISOMAP embbeding for {} neighbour'.format(Classes[Argclass], nei))","def test_rebulding_zpf_boundary_sets_regions():\n\n compsets_298 = CompsetPair([\n BinaryCompset('P1', 298.15, 'B', 0.5, [0.5, 0.5]),\n BinaryCompset('P2', 298.15, 'B', 0.8, [0.2, 0.8]),\n ])\n\n compsets_310 = CompsetPair([\n BinaryCompset('P1', 310, 'B', 0.5, [0.5, 0.5]),\n BinaryCompset('P2', 310, 'B', 0.8, [0.2, 0.8]),\n ])\n\n compsets_300_diff_phases = CompsetPair([\n BinaryCompset('P2', 300, 'B', 0.5, [0.5, 0.5]),\n BinaryCompset('P3', 300, 'B', 0.8, [0.2, 0.8]),\n ])\n\n zpfbs = ZPFBoundarySets(['A', 'B'], v.X('B'))\n\n # Initial compsets\n zpfbs.add_compsets(compsets_298)\n assert len(zpfbs.all_compsets) == 1\n assert len(zpfbs.two_phase_regions) == 1\n\n # Compsets added create a new region because phases changed\n zpfbs.add_compsets(compsets_300_diff_phases)\n assert len(zpfbs.all_compsets) == 2\n assert len(zpfbs.two_phase_regions) == 2\n\n # Compsets added create a new region because phases the temperature is out of tolerance\n zpfbs.add_compsets(compsets_310)\n assert len(zpfbs.all_compsets) == 3\n assert len(zpfbs.two_phase_regions) == 3\n\n # Rebuild the regions with a larger tolerance should create two regions with one and two compsets.\n zpfbs.rebuild_two_phase_regions(Ttol=20)\n assert len(zpfbs.all_compsets) == 3\n assert len(zpfbs.two_phase_regions) == 2\n assert sorted([len(tpr.compsets) for tpr in zpfbs.two_phase_regions]) == [1, 2]","def __bcc_top_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def test_two_layer_equi_group1(self):\n print('Test equivariance for a chiral net with two layers')\n batch_size = 2\n time_size = 5\n num_joints = 3\n in_dim = 2\n out_dim = 3\n neg_dim_in = 1\n neg_dim_out = 1\n sym_groupings = ([1, 1, 1], [1, 1, 1])\n\n # Generate chiral pairs.\n x, x_chiral = self._get_input_pairs(batch_size, time_size, num_joints,\n in_dim, neg_dim_in, sym_groupings)\n\n # Reshape to joints and dim to a column vector.\n x = x.view(x.shape[0], -1, x.shape[-1])\n x_chiral = x_chiral.view(x.shape[0], -1, x.shape[-1])\n\n chiral_conv1 = ChiralConv1d(in_dim*num_joints, out_dim*num_joints,\n kernel_size=3,\n sym_groupings=sym_groupings,\n neg_dim_in=neg_dim_in,\n neg_dim_out=neg_dim_out)\n\n chiral_conv2 = ChiralConv1d(out_dim*num_joints, out_dim*num_joints,\n kernel_size=3,\n sym_groupings=sym_groupings,\n neg_dim_in=neg_dim_in,\n neg_dim_out=neg_dim_out)\n\n # Build a simple two layer network.\n y = chiral_conv2(torch.tanh(chiral_conv1(x)))\n y_chiral = chiral_conv2(torch.tanh(chiral_conv1(x_chiral)))\n\n # Reshape back to joints, dim representation.\n y = y.view(y.shape[0], num_joints, -1, y.shape[-1])\n y_chiral = y_chiral.view(y.shape[0], num_joints, -1, y.shape[-1])\n\n # Compare output.\n self._checks_chiral_equivariant(y, y_chiral, num_joints, out_dim,\n neg_dim_out, sym_groupings[1])","def make_maps_of_2x1_pix_coordinates (sp) : \n x_rhs = np.arange(sp.colsh)*sp.pixs + sp.pixw - sp.pixsh\n x_rhs[0] = sp.pixwh # set x-coordinate of the wide pixel \n x_arr = np.hstack([-x_rhs[::-1],x_rhs])\n\n y_arr = np.arange(sp.rows) * sp.pixs\n y_arr -= y_arr[-1]/2 # move origin to the center of array\n\n sp.x_map2x1, sp.y_map2x1 = np.meshgrid(x_arr, y_arr)","def unique_combos(self, background_strains, foreground_strains):\n elem_intervals = self.make_elementary_intervals(\n [self.sample_dict[sn][0] for sn in background_strains + foreground_strains])\n background = self.build_pairwise_matrix(background_strains, elem_intervals)\n foreground = self.build_pairwise_matrix(foreground_strains, elem_intervals)\n output = []\n uniquities = np.logical_and(foreground == len(foreground_strains), np.logical_not(background))\n for combo in xrange(subspecies.NUM_SUBSPECIES**2):\n combo_uniquities = np.where(uniquities[combo])\n combo_color = subspecies.to_color(combo, ordinal=True)\n for i, j in zip(combo_uniquities[0], combo_uniquities[1]):\n output.append([\n # proximal interval start, end\n elem_intervals[i - 1],\n elem_intervals[i],\n # distal interval start, end\n elem_intervals[j - 1],\n elem_intervals[j],\n combo_color\n ])\n return output","def add_boundaries(self):\n\n bound_conns=[]\n bound_coords=[]\n bound_vert_index=[]\n throat_vert_index=[]\n #Find boundary extent\n [x_min,x_max,y_min,y_max,z_min,z_max]=vo.vertex_dimension(self,self.pores(),parm='minmax')\n min_point = np.around(np.array([x_min,y_min,z_min]),10)\n max_point = np.around(np.array([x_max,y_max,z_max]),10)\n Np = self.num_pores()\n Nt = self.num_throats()\n new_throat_count = 0\n # ridge_dict contains a dictionary where the key is a set of 2 neighbouring pores and the value is the vertex indices\n # that form the throat or ridge between them\n for p,v in self._vor.ridge_dict.items():\n # if the vertex with index -1 is contained in list then the ridge is unbounded - ignore these\n if np.all(np.asarray(v) >=0):\n #boundary throats will be those connecting one pore inside the original set and one out\n if (p[0] in range(Np) and p[1] not in range(Np)) or\\\n (p[0] not in range(Np) and p[1] in range(Np)):\n # the dictionary key is not in numerical order so find the pore index inside\n if p[0] in range(Np):\n my_pore=p[0]\n else:\n my_pore=p[1]\n my_pore_coord = self[\"pore.coords\"][my_pore]\n new_pore_coord = my_pore_coord.copy()\n #rounding necessary here to identify the plane as Voronoi can have 1e-17 and smaller errors\n throat_verts = np.around(self._vor.vertices[v],10)\n #find which plane we are aligned with (if any) and align new_pore with throat plane\n if len(np.unique(throat_verts[:,0])) == 1:\n new_pore_coord[0]=np.unique(throat_verts[:,0])\n elif len(np.unique(throat_verts[:,1])) == 1:\n new_pore_coord[1]=np.unique(throat_verts[:,1])\n elif len(np.unique(throat_verts[:,2])) == 1:\n new_pore_coord[2]=np.unique(throat_verts[:,2])\n else:\n new_pore_coord = throat_verts.mean()\n bound_coords.append(new_pore_coord)\n bound_conns.append(np.array([my_pore,new_throat_count+Np]))\n bound_vert_index.append(dict(zip(v,throat_verts)))\n throat_vert_index.append(dict(zip(v,throat_verts)))\n new_throat_count += 1\n\n #Add new pores and connections\n self.extend(pore_coords=bound_coords, throat_conns=bound_conns)\n #Record new number of pores\n Mp = self.num_pores()\n Mt = self.num_throats()\n new_pore_ids = np.arange(Np,Mp)\n new_throat_ids = np.arange(Nt,Mt)\n #Identify which boundary the pore sits on\n front = self.pores()[self['pore.coords'][:,0]==min_point[0]]\n back = self.pores()[self['pore.coords'][:,0]==max_point[0]]\n left = self.pores()[self['pore.coords'][:,1]==min_point[1]]\n right = self.pores()[self['pore.coords'][:,1]==max_point[1]]\n bottom = self.pores()[self['pore.coords'][:,2]==min_point[2]]\n top = self.pores()[self['pore.coords'][:,2]==max_point[2]]\n #Assign labels\n self['pore.boundary'] = False\n self['pore.boundary'][new_pore_ids] = True\n self['pore.right_boundary'] = False\n self['pore.left_boundary'] = False\n self['pore.front_boundary'] = False\n self['pore.back_boundary'] = False\n self['pore.top_boundary'] = False\n self['pore.bottom_boundary'] = False\n self['pore.right_boundary'][right] = True\n self['pore.left_boundary'][left] = True\n self['pore.front_boundary'][front] = True\n self['pore.back_boundary'][back] = True\n self['pore.top_boundary'][top] = True\n self['pore.bottom_boundary'][bottom] = True\n #Save the throat verts\n self[\"pore.vert_index\"][new_pore_ids] = bound_vert_index\n self[\"throat.vert_index\"][new_throat_ids] = throat_vert_index","def test_broken_multipolygon_ways():\n # outer way does not merge (17002 has one node)\n assert query_row(db_conf, 'osm_landusages', -17001) == None\n assert query_row(db_conf, 'osm_roads', 17001)['type'] == 'residential'\n assert query_row(db_conf, 'osm_roads', 17002) == None\n\n # outer way does not merge (17102 has no nodes)\n assert query_row(db_conf, 'osm_landusages', -17101) == None\n assert query_row(db_conf, 'osm_roads', 17101)['type'] == 'residential'\n assert query_row(db_conf, 'osm_roads', 17102) == None","def candidate_map(self):\n candidates = [[set(range(1, 10)) for _dummy in range(9)] for _dummy in range(9)]\n vertex_value_unknown = [[True for _dummy in range(9)] for _dummy in range(9)]\n for (line, row) in [(ln, rw) for ln in range(9) for rw in range(9)]:\n if self.grid[line][row] in range(1, 10):\n candidates[line][row] = set([self.grid[line][row]])\n vertex_value_unknown[line][row] = False\n for i in range(9):\n if i != row:\n candidates[line][i].discard(self.grid[line][row])\n if i != line:\n candidates[i][row].discard(self.grid[line][row])\n if line - line%3 + i//3 != line or row - row%3 + i%3 != row:\n candidates[line - line%3 + i//3][row - row%3 + i%3].discard(self.grid[line][row])\n # Further reduce candidate map\n reduce_cadidate_map_further = True\n while reduce_cadidate_map_further:\n reduce_cadidate_map_further = False\n total_number_of_candidates = sum([len(candidates[ln][rw]) for ln in range(9) for rw in range(9)])\n for number in range(1, 10):\n for i in range(9):\n # Check for single possible vertex for *number* in candidate map line *i*\n seen_in_j = []\n for j in range(9):\n if number in candidates[i][j]:\n seen_in_j.append(j)\n if len(seen_in_j) == 1 and vertex_value_unknown[i][seen_in_j[0]]:\n candidates[i][seen_in_j[0]] = set([number])\n vertex_value_unknown[i][seen_in_j[0]] = False\n # Discard other candidates for *number* in corresponding row and subsquare\n for j in range(9):\n if j != i:\n candidates[j][seen_in_j[0]].discard(number)\n if i - i%3 + j//3 != i:\n candidates[i - i%3 + j//3][seen_in_j[0] - seen_in_j[0]%3 + j%3].discard(number)\n # otherwise add check wheter all candidates for *number* are in the same subsquare\n elif 1 < len(seen_in_j) < 4:\n subsquares = set()\n for j in seen_in_j:\n subsquares.add(3*(i//3) + j//3)\n if len(subsquares) == 1:\n subsquare = subsquares.pop()\n for j in range(9):\n if 3*(subsquare//3) + j//3 != i:\n candidates[3*(subsquare//3) + j//3][3*(subsquare%3) + j%3].discard(number)\n # Check for single possible vertex for *number* in candidate map row *i*\n seen_in_j = []\n for j in range(9):\n if number in candidates[j][i]:\n seen_in_j.append(j)\n if len(seen_in_j) == 1 and vertex_value_unknown[seen_in_j[0]][i]:\n candidates[seen_in_j[0]][i] = set([number])\n vertex_value_unknown[seen_in_j[0]][i] = False\n # Discard other candidates for *number* in corresponding line and subsquare\n for j in range(9):\n if j != i:\n candidates[seen_in_j[0]][j].discard(number)\n if i - i%3 + j%3 != i:\n candidates[seen_in_j[0] - seen_in_j[0]%3 + j//3][i - i%3 + j%3].discard(number)\n # otherwise add check wheter all candidates for *number* are in the same subsquare\n elif 1 < len(seen_in_j) < 4:\n subsquares = set()\n for j in seen_in_j:\n subsquares.add(3*(j//3) + i//3)\n if len(subsquares) == 1:\n subsquare = subsquares.pop()\n for j in range(9):\n if 3*(subsquare%3) + j%3 != i:\n candidates[3*(subsquare//3) + j//3][3*(subsquare%3) + j%3].discard(number)\n # Check for single possible vertex for *number* in candidate map subsquare *i*\n seen_in_j = []\n for j in range(9):\n if number in candidates[3*(i//3) + j//3][3*(i%3) + j%3]:\n seen_in_j.append(j)\n if len(seen_in_j) == 1 and vertex_value_unknown[3*(i//3) + seen_in_j[0]//3][3*(i%3) + seen_in_j[0]%3]:\n candidates[3*(i//3) + seen_in_j[0]//3][3*(i%3) + seen_in_j[0]%3] = set([number])\n vertex_value_unknown[3*(i//3) + seen_in_j[0]//3][3*(i%3) + seen_in_j[0]%3] = False\n # Discard other candidates for *number* in corresponding line and row\n for j in range(9):\n if j not in [3*(i%3), 3*(i%3) + 1, 3*(i%3) + 2]:\n candidates[3*(i//3) + seen_in_j[0]//3][j].discard(number)\n if j not in [3*(i//3), 3*(i//3) + 1, 3*(i//3) + 2]:\n candidates[j][3*(i%3) + seen_in_j[0]%3].discard(number)\n # otherwise add check wheter all candidates for *number* are in the same line/row\n elif 1 < len(seen_in_j) < 4:\n lines = set()\n rows = set()\n for j in seen_in_j:\n lines.add(3*(i//3) + j//3)\n rows.add(3*(i%3) + j%3)\n if len(lines) == 1:\n line = lines.pop()\n for row in [rw for rw in range(9) if rw not in [3*(i%3), 3*(i%3) + 1, 3*(i%3) + 2]]:\n candidates[line][row].discard(number)\n elif len(rows) == 1:\n row = rows.pop()\n for line in [ln for ln in range(9) if ln not in [3*(i//3), 3*(i//3) + 1, 3*(i//3) + 2]]:\n candidates[line][row].discard(number)\n if sum([len(candidates[ln][rw]) for ln in range(9) for rw in range(9)]) < total_number_of_candidates:\n reduce_cadidate_map_further = True\n return candidates","def getContours(image, copyImage):\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\n for contour in contours:\n area = cv.contourArea(contour)\n \n if area > 500.0:\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\n perimeter = cv.arcLength(contour, True)\n \n # Approximates to the nearest polygon\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\n objectCoordinates = len(approx)\n\n # Returns the x, y and height width of the polygon\n x, y, w, h = cv.boundingRect(approx)\n\n if objectCoordinates == 3:\n objectShape = \"Triangle\"\n elif objectCoordinates == 4:\n ratio = w / float(h)\n if ratio >= 0.95 and ratio <= 1.05:\n objectShape = \"Square\"\n else: objectShape = \"Rectangle\"\n else: objectShape = \"Circle\" \n\n \n\n # Draw rectangles around the images\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))","def testMergeCollectionsCCCParentWithDuplicates(self):\n # Now we have the same color decisions in both node and node2\n self.node.color_decisions = self.node2.color_decisions\n\n merged = self.node.merge_collections([self.node2])\n\n self.assertEqual(\n self.node.desc + self.node2.desc,\n merged.desc\n )\n self.assertEqual(\n self.node.input_desc,\n merged.input_desc\n )\n self.assertEqual(\n self.node.viewing_desc,\n merged.viewing_desc\n )\n # We'll just check the length\n self.assertEqual(\n len(set(self.node.all_children + self.node2.all_children)),\n len(merged.all_children)\n )\n self.assertEqual(\n self.node.type,\n merged.type\n )","def triangulationWarping(src, srcTri, dstTri, size, epsilon=0.1):\n dst_tri = dstTri\n src_tri = srcTri\n\n # coordinates of the bounding rectangle\n x, y, w, h = cv2.boundingRect(np.float32([dst_tri]))\n\n # obtain the height and width of the rectangle\n rect_left = x\n rect_right = x + w\n rect_top = y\n rect_bottom = y + h\n\n # obtaining the destination matrix\n matrix_dst = np.linalg.inv([[dst_tri[0][0], dst_tri[1][0], dst_tri[2][0]],\n [dst_tri[0][1], dst_tri[1][1], dst_tri[2][1]],\n [1, 1, 1]])\n\n grid = np.mgrid[rect_left:rect_right, rect_top:rect_bottom].reshape(2, -1)\n # grid 2xN\n grid = np.vstack((grid, np.ones((1, grid.shape[1]))))\n # grid 3xN\n barycentric_coords = np.dot(matrix_dst, grid)\n\n dst_tri = []\n b = np.all(barycentric_coords > -epsilon, axis=0)\n a = np.all(barycentric_coords < 1 + epsilon, axis=0)\n for i in range(len(a)):\n dst_tri.append(a[i] and b[i])\n dst_y = []\n dst_x = []\n for i in range(len(dst_tri)):\n if dst_tri[i]:\n dst_y.append(i % h)\n dst_x.append(i / h)\n\n barycentric_coords = barycentric_coords[:, np.all(-epsilon < barycentric_coords, axis=0)]\n barycentric_coords = barycentric_coords[:, np.all(barycentric_coords < 1 + epsilon, axis=0)]\n\n src_matrix = np.matrix([[src_tri[0][0], src_tri[1][0], src_tri[2][0]],\n [src_tri[0][1], src_tri[1][1], src_tri[2][1]],\n [1, 1, 1]])\n\n # matrix multiplication of source matrix and barycentric coordinates\n pts = np.matmul(src_matrix, barycentric_coords)\n\n # converting values to homogenous coordinates\n xA = pts[0, :] / pts[2, :]\n yA = pts[1, :] / pts[2, :]\n\n dst = np.zeros((size[1], size[0], 3), np.uint8)\n\n # copy back the value of the pixel at (xA,yA) to the target location.\n # Using scipy.interpolate.interp2d to perform this operation.\n i = 0\n for x, y in zip(xA.flat, yA.flat):\n y_values = np.linspace(0, src.shape[0], num=src.shape[0], endpoint=False)\n x_values = np.linspace(0, src.shape[1], num=src.shape[1], endpoint=False)\n\n g = src[:, :, 1]\n fg = interp2d(x_values, y_values, g, kind='cubic')\n green = fg(x, y)[0]\n\n b = src[:, :, 0]\n fb = interp2d(x_values, y_values, b, kind='cubic')\n blue = fb(x, y)[0]\n\n r = src[:, :, 2]\n fr = interp2d(x_values, y_values, r, kind='cubic')\n red = fr(x, y)[0]\n\n try:\n dst[dst_y[i], dst_x[i]] = (blue, green, red)\n except:\n pass\n i = i + 1\n\n return dst","def test_recomb(self):\n sol1, sol2 = [0,0,0,0],[1,1,1,1]\n hot_regions = [0,0,0,1] ##NOTE: sum(hot_regions) shouls always be 1\n rec_events = 1\n sol = list(d.recombine(sol1,sol2,rec_events,hot_regions))\n print(f\"recomb sol: {sol}\")\n self.assertTrue( (sol == [0,0,0,1]) or (sol == [1,1,1,0]) )","def create_cont_constraint_mat_separable(H,v1s,v2s,nSides,nConstraints,nC,\n dim_domain,dim_range,tess):\n if dim_domain != 2:\n raise ValueError\n if dim_range not in [1,2]:\n raise ValueError\n nHomoCoo=dim_domain+1 \n length_Avee = dim_range*nHomoCoo\n L1 = np.zeros((nConstraints/2,nC*nHomoCoo))\n\n \n\n nPtsInSide = 2 # Since, in 2D, the side is always a line joining 2 pts.\n# if nSides != nConstraints/(nPtsInSide*dim_domain):\n# raise ValueError(nSides,nConstraints)\n \n if nSides != nConstraints/(nPtsInSide*dim_range):\n print \" print nSides , nConstraints/(nPtsInSide*dim_range):\"\n print nSides , nConstraints/(nPtsInSide*dim_range)\n ipshell('stop')\n raise ValueError( nSides , (nConstraints,nPtsInSide,dim_range))\n\n \n if nSides != H.shape[0]:\n raise ValueError(nSides,H.shape)\n\n\n# M = nPtsInSide*dim_range\n M = nPtsInSide\n if dim_range == 1:\n raise NotImplementedError\n for i in range(nSides): \n v1 = v1s[i]\n v2 = v2s[i]\n \n h = H[i]\n a,b = h.nonzero()[0] # idx for the relevant As \n # s stands for start\n # e stands for end \n s1 = a*length_Avee \n e1 = s1+nHomoCoo \n s2 = b*length_Avee\n e2 = s2+nHomoCoo \n \n # Constraint 1: \n L[i*M,s1:e1]= v1 \n L[i*M,s2:e2]= -v1 \n # Constraint 2: \n L[i*M+1,s1:e1]= v2 \n L[i*M+1,s2:e2]= -v2 \n \n \n elif dim_range==2:\n for i in range(nSides): \n v1 = v1s[i]\n v2 = v2s[i]\n\n if np.allclose(v1,v2):\n raise ValueError(v1,v2)\n\n\n \n \n \n h = H[i]\n a,b = h.nonzero()[0] # idx for the relevant As \n \n\n # L1 is acting on columns of the following form:\n # [ a_1 b_1 c_1 d_1 a_2 b_2 c_2 d_2 ... a_Nc b_Nc c_Nc d_Nc] \n # s stands for start\n # e stands for end \n s1 = a*nHomoCoo\n e1 = s1+nHomoCoo \n s2 = b*nHomoCoo\n e2 = s2+nHomoCoo \n \n \n try: \n # Constraint 1: \n row = np.zeros(L1.shape[1])\n row[s1:e1]=v1\n row[s2:e2]=-v1 \n # x component \n L1[i*M]=row \n except:\n ipshell('fail')\n raise \n\n # Constraint 2: \n row = np.zeros(L1.shape[1])\n row[s1:e1]=v2\n row[s2:e2]=-v2 \n # x component \n L1[i*M+1]=row\n \n\n \n \n \n \n \n else:\n raise ValueError(dim_range)\n\n \n return L1","def snap_connect_nodes(\n self,\n two_nodes,\n subsections=None,\n spacing=None,\n boundary_id=-1,\n ):\n two_nodes = np.asarray(two_nodes)\n if two_nodes.shape[0] != 2:\n raise ValueError(\"`two_nodes` takes two nodes only.\")\n\n # Abuse KDT since it is fast enough for this.\n kdt = KDTree(self.nodes_)\n _, nn_ind = kdt.query(two_nodes) # there are two indices\n logging.debug(\n \"Segment - Snapping and connecting [{ni}] nodes: {n}.\".format(\n ni=nn_ind,\n n=self.nodes[nn_ind]\n )\n )\n\n self.connect_nodes(\n nn_ind,\n reference_nodes=False,\n subsections=subsections,\n spacing=spacing,\n boundary_id=boundary_id,\n )","def build_contacting_nn(masks, r=1, k=3):\n \n pairs = build_contacting(masks, r=r)\n # reencode the coordinates to match node positions with their respective areas\n coords = mask_val_coord(masks)\n coords, pairs = refactor_coords_pairs(coords, pairs)\n \n pairs = link_solitaries(coords, pairs)\n \n return coords, pairs"],"string":"[\n \"def multiple_intersections():\\n levels = np.array([966., 937.2, 925., 904.6, 872.6, 853., 850., 836., 821., 811.6, 782.3,\\n 754.2, 726.9, 700., 648.9, 624.6, 601.1, 595., 587., 576., 555.7,\\n 534.2, 524., 500., 473.3, 400., 384.5, 358., 343., 308.3, 300., 276.,\\n 273., 268.5, 250., 244.2, 233., 200.]) * units.mbar\\n temperatures = np.array([18.2, 16.8, 16.2, 15.1, 13.3, 12.2, 12.4, 14., 14.4,\\n 13.7, 11.4, 9.1, 6.8, 4.4, -1.4, -4.4, -7.3, -8.1,\\n -7.9, -7.7, -8.7, -9.8, -10.3, -13.5, -17.1, -28.1, -30.7,\\n -35.3, -37.1, -43.5, -45.1, -49.9, -50.4, -51.1, -54.1, -55.,\\n -56.7, -57.5]) * units.degC\\n dewpoints = np.array([16.9, 15.9, 15.5, 14.2, 12.1, 10.8, 8.6, 0., -3.6, -4.4,\\n -6.9, -9.5, -12., -14.6, -15.8, -16.4, -16.9, -17.1, -27.9, -42.7,\\n -44.1, -45.6, -46.3, -45.5, -47.1, -52.1, -50.4, -47.3, -57.1,\\n -57.9, -58.1, -60.9, -61.4, -62.1, -65.1, -65.6,\\n -66.7, -70.5]) * units.degC\\n return levels, temperatures, dewpoints\",\n \"def sub_graph_merging(self):\",\n \"def undrawGrid(draw,points,coeff2,newColorArray):\\r\\n ## This is the merge function.\\r\\n ## If two neighboring regions are considered to be the same color by the comparison function then this function replaces the black line between them by a line of their color (making it invisible).\\r\\n for j in range(0,coeff2-1):\\r\\n if comparisonFunction(newColorArray[0][j],newColorArray[0][j+1]):\\r\\n draw.line((points*0, points*(j+1), points*(0+1)-3, points*(j+1)), fill=newColorArray[0][j], width=lineWidth)\\r\\n\\r\\n for i in range(0,coeff2-1):\\r\\n if comparisonFunction(newColorArray[i][0],newColorArray[i+1][0]):\\r\\n draw.line((points*(i+1), points*0, points*(i+1), points*1-3), fill=newColorArray[i][0], width=lineWidth)\\r\\n\\r\\n for i in range(1,coeff2):\\r\\n for j in range(1,coeff2):\\r\\n if comparisonFunction(newColorArray[i][j],newColorArray[i][j-1]):\\r\\n draw.line((points*i+3, points*j, points*(i+1)-3, points*j), fill=newColorArray[i][j], width=lineWidth)\\r\\n\\r\\n if comparisonFunction(newColorArray[i][j],newColorArray[i-1][j]):\\r\\n draw.line((points*i, points*j+3, points*i, points*(j+1)-3), fill=newColorArray[i][j], width=lineWidth)\",\n \"def GetMatchedSubContourLists(\\n scListRef,\\n scList,\\n allValsByFrame,\\n orderOfSCsByValue,\\n splitLength=1,\\n fixedNumInteriorPoints=None,\\n):\\n ## NOT DONE! MERGE LATER??\\n return simplifiedSCListRef, simplifiedSCList\",\n \"def addGrids(self, grid, label):\\n self.grid = grid\\n self.label = label\\n self.H = len(grid)\\n self.W = len(grid[0])\\n self.visited = [[False] * self.W for _ in range(self.H)]\\n self.clusters = [self._resort_size(r, c) for r, c in product(range(self.H), range(self.W)) if self.grid[r][c] != 0 and not self.visited[r][c]]\\n self.subsets = []\\n\\n assert len(self.V) == len(self.neighbours.keys())\\n\\n if len(self.V) == 0 or not any(self.neighbours.values()):\\n for addresstamp in self.clusters:\\n footprint = Footprint(self.source, label, addresstamp)\\n self.source += 1\\n self.neighbours[footprint.uid] = []\\n for v in self.V:\\n if v.is_overlappedFootprint(footprint):\\n self.E.append((v, footprint))\\n self.neighbours.get(v.uid).append(footprint.uid)\\n self.neighbours.get(footprint.uid).append(v.uid)\\n self.resorts[v] = Resort([footprint])\\n self.V.append(footprint)\\n return\\n\\n connected_footprints = []\\n for sub in self.recursive_findDenseZones(self.neighbours):\\n self.subsets.append(sub)\\n connected_footprints.extend(sub.getFootprintId())\\n for addresstamp in self.clusters:\\n footprint = Footprint(self.source, label, addresstamp)\\n self.source += 1\\n self.neighbours[footprint.uid] = []\\n if len(addresstamp) == 1:\\n self.V.append(footprint)\\n continue\\n new_sub = 1\\n for sub in self.subsets:\\n if sub.check_collision(footprint):\\n new_sub = 0\\n new_resort = 1\\n for key, resort in sub.resorts.items():\\n if resort.getLastFootprint().is_overlappedFootprint(footprint):\\n new_resort = 0\\n for n in resort.footprints:\\n self.E.append((n, footprint))\\n self.neighbours.get(n.uid).append(footprint.uid)\\n self.neighbours.get(footprint.uid).append(n.uid)\\n sub.resorts[key].addFootprint(footprint)\\n self.resorts[key].addFootprint(footprint)\\n break\\n if new_resort:\\n sub.resorts[footprint] = Resort([footprint])\\n self.resorts[footprint] = Resort([footprint])\\n break\\n if new_sub:\\n min_distance = sqrt(self.H**2 + self.W**2)\\n closest = None\\n for key, resort in self.resorts.items():\\n if footprint.distance_from_resort(resort) < min_distance:\\n min_distance = footprint.distance_from_resort(resort)\\n closest = key\\n assert closest\\n for n in self.resorts[closest].footprints:\\n self.E.append((n, footprint))\\n self.neighbours.get(n.uid).append(footprint.uid)\\n self.neighbours.get(footprint.uid).append(n.uid)\\n self.V.append(footprint)\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def compute_contour_binary_masks(\\n contour1: np.ndarray,\\n contour2: np.ndarray,\\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\\n) -> typing.Tuple[np.ndarray, np.ndarray]:\\n points = np.concatenate([contour1, contour2], axis=0)\\n offset = points.min(axis=0)\\n points, contour1, contour2 = [v - offset for v in [points, contour1, contour2]]\\n scale = min(max_size / points.max(axis=0).min(), 1)\\n if scale < 1:\\n points, contour1, contour2 = [v * scale for v in [points, contour1, contour2]]\\n w, h = points.max(axis=0).astype(\\\"int32\\\")\\n im1, im2 = [\\n cv2.drawContours(\\n np.zeros((h, w), dtype=\\\"uint8\\\"),\\n contours=(box[np.newaxis]).round().astype(\\\"int32\\\"),\\n color=255,\\n thickness=-1,\\n contourIdx=0,\\n )\\n > 0\\n for box in [contour1, contour2]\\n ]\\n return im1, im2\",\n \"def voronoi_sub_mask_1d_index_to_pixeliztion_1d_index_from_grids_and_geometry(\\n grid,\\n mask_1d_index_to_nearest_pixelization_1d_index,\\n sub_mask_1d_index_to_mask_1d_index,\\n pixel_centres,\\n pixel_neighbors,\\n pixel_neighbors_size,\\n):\\n\\n sub_mask_1d_index_to_pixeliztion_1d_index = np.zeros((grid.shape[0]))\\n\\n for sub_mask_1d_index in range(grid.shape[0]):\\n\\n nearest_pixelization_1d_index = mask_1d_index_to_nearest_pixelization_1d_index[\\n sub_mask_1d_index_to_mask_1d_index[sub_mask_1d_index]\\n ]\\n\\n while True:\\n\\n nearest_pixelization_pixel_center = pixel_centres[\\n nearest_pixelization_1d_index\\n ]\\n\\n sub_pixel_to_nearest_pixelization_distance = (\\n (grid[sub_mask_1d_index, 0] - nearest_pixelization_pixel_center[0]) ** 2\\n + (grid[sub_mask_1d_index, 1] - nearest_pixelization_pixel_center[1])\\n ** 2\\n )\\n\\n closest_separation_from_pixelization_to_neighbor = 1.0e8\\n\\n for neighbor_pixelization_1d_index in range(\\n pixel_neighbors_size[nearest_pixelization_1d_index]\\n ):\\n\\n neighbor = pixel_neighbors[\\n nearest_pixelization_1d_index, neighbor_pixelization_1d_index\\n ]\\n\\n separation_from_neighbor = (\\n grid[sub_mask_1d_index, 0] - pixel_centres[neighbor, 0]\\n ) ** 2 + (grid[sub_mask_1d_index, 1] - pixel_centres[neighbor, 1]) ** 2\\n\\n if (\\n separation_from_neighbor\\n < closest_separation_from_pixelization_to_neighbor\\n ):\\n closest_separation_from_pixelization_to_neighbor = (\\n separation_from_neighbor\\n )\\n closest_neighbor_pixelization_1d_index = (\\n neighbor_pixelization_1d_index\\n )\\n\\n neighboring_pixelization_1d_index = pixel_neighbors[\\n nearest_pixelization_1d_index, closest_neighbor_pixelization_1d_index\\n ]\\n sub_pixel_to_neighboring_pixelization_distance = (\\n closest_separation_from_pixelization_to_neighbor\\n )\\n\\n if (\\n sub_pixel_to_nearest_pixelization_distance\\n <= sub_pixel_to_neighboring_pixelization_distance\\n ):\\n sub_mask_1d_index_to_pixeliztion_1d_index[\\n sub_mask_1d_index\\n ] = nearest_pixelization_1d_index\\n break\\n else:\\n nearest_pixelization_1d_index = neighboring_pixelization_1d_index\\n\\n return sub_mask_1d_index_to_pixeliztion_1d_index\",\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def test_1_2_2D_cube_splits(self):\\n check = [(0, 0), (1, 1), (1, 0), (0, 1), (0.5, 0.5), (0.0, 0.5),\\n (0.5, 0.0),\\n (0.25, 0.25), (1.0, 0.5), (0.5, 1.0), (0.75, 0.75),\\n (0.75, 0.25),\\n (0.25, 0.75), (0.5, 0.25), (0.25, 0.5), (0.375, 0.375),\\n (0.0, 0.25),\\n (0.25, 0.0), (0.125, 0.125), (0.125, 0.375), (0.375, 0.125),\\n (0.5, 0.75), (0.75, 0.5), (0.625, 0.625), (1.0, 0.75),\\n (0.75, 1.0),\\n (0.875, 0.875), (0.875, 0.625), (0.625, 0.875), (0.625, 0.375),\\n (1.0, 0.25), (0.75, 0.0), (0.875, 0.125), (0.875, 0.375),\\n (0.625, 0.125), (0.375, 0.625), (0.0, 0.75), (0.25, 1.0),\\n (0.125, 0.875), (0.125, 0.625), (0.375, 0.875)]\\n\\n nn_checks = {(0, 0): [(0.25, 0.0), (0.0, 0.25), (0.125, 0.125)],\\n (0.625, 0.375): [(0.5, 0.5), (0.75, 0.25), (0.75, 0.5),\\n (0.5, 0.25)],\\n (0, 1): [(0.25, 1.0), (0.125, 0.875),(0.0, 0.75)],\\n (0.625, 0.125): [(0.5, 0.0), (0.75, 0.25), (0.75, 0.0),\\n (0.5, 0.25)]}\\n\\n\\n init_triangulation(2, 2, check, nn_checks)\",\n \"def tracklet_fast(g1: nx.graph, g2: nx.graph, seg_img1: np.ndarray, seg_img2: np.ndarray, maxtrackid: int, time: int, \\n linelist: list, tracksavedir: str, cellcenter1: np.ndarray, cellcenter2: np.ndarray) \\\\\\n -> (int, list):\\n f1 = {}\\n f2 = {}\\n dict_associate = {}\\n loc1 = g1.degree(weight=\\\"weight\\\")\\n loc2 = g2.degree(weight=\\\"weight\\\")\\n new_seg_img2 = np.zeros(seg_img2.shape)\\n\\n for ele1 in loc1:\\n cell = ele1[0]\\n f1[cell] = [cellcenter1[cell], ele1[1]]\\n\\n for ele2 in loc2:\\n cell = ele2[0]\\n f2[cell] = [cellcenter2[cell], ele2[1]]\\n\\n for cell in f2.keys():\\n tmp_center = f2[cell][0]\\n min_distance = seg_img2.shape[0]**2 + seg_img2.shape[1]**2 + seg_img2.shape[2]**2\\n\\n for ref_cell in f1.keys():\\n ref_tmp_center = f1[ref_cell][0]\\n distance = (tmp_center[0]-ref_tmp_center[0])**2 + (tmp_center[1] -\\n ref_tmp_center[1])**2 + (tmp_center[2]-ref_tmp_center[2])**2\\n if distance < min_distance:\\n dict_associate[cell] = ref_cell\\n min_distance = distance\\n\\n inverse_dict_ass = {}\\n\\n for cell in dict_associate:\\n if dict_associate[cell] in inverse_dict_ass:\\n inverse_dict_ass[dict_associate[cell]].append(cell)\\n else:\\n inverse_dict_ass[dict_associate[cell]] = [cell]\\n\\n maxtrackid = max(maxtrackid, max(inverse_dict_ass.keys()))\\n\\n for cell in inverse_dict_ass.keys():\\n if len(inverse_dict_ass[cell]) > 1:\\n for cellin2 in inverse_dict_ass[cell]:\\n maxtrackid = maxtrackid + 1\\n new_seg_img2[seg_img2 == cellin2] = maxtrackid\\n string = '{} {} {} {}'.format(maxtrackid, time+1, time+1, cell)\\n linelist.append(string)\\n else:\\n cellin2 = inverse_dict_ass[cell][0]\\n new_seg_img2[seg_img2 == cellin2] = cell\\n i = 0\\n\\n for line in linelist:\\n i = i+1\\n if i == cell:\\n list_tmp = line.split()\\n new_string = '{} {} {} {}'.format(list_tmp[0], list_tmp[1], time+1, list_tmp[3])\\n linelist[i-1] = new_string\\n\\n with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:\\n thread1 = executor.submit(save_img_as_tiff, seg_img1, time, tracksavedir)\\n thread2 = executor.submit(save_img_as_tiff, new_seg_img2, time+1, tracksavedir)\\n\\n return maxtrackid, linelist\",\n \"def test_1_1_2D_rec_init(self): # TODO: REMOVE FUNC AFTER SPLIT\\n check = [(-1.0, -2.0), (7.0, 6.0), (7.0, -2.0), (-1.0, 6.0), (3.0, 2.0)]\\n nn_checks = {(-1.0, -2.0): [(7, -2), (3.0, 2.0), (-1, 6)],\\n (7.0, 6.0): [(7, -2), (3.0, 2.0), (-1, 6)],\\n (7.0, -2.0): [(7, 6), (3.0, 2.0), (-1, -2)]}\\n init_triangulation(2, 0, check, nn_checks, bounds=[(-1, 7), (-2, 6)])\",\n \"def prepareConjMap(self):\\n\\n # Convert nullbits count into binary\\n self.nullbits = [int(x) for x in np.binary_repr(\\n self.nullbits).zfill(self.gridSize)]\\n\\n # Add nullbits count at the start of conjMap\\n self.conjMap = self.nullbits + self.conjMap\\n\\n # Add trash bits to conjMap at appropriate intervals\\n tmparr = []\\n while self.conjMap:\\n self.conjMap = self.tb + self.conjMap\\n b = self.conjMap[:self.gridSize * self.gridSize]\\n self.conjMap = self.conjMap[len(b):]\\n while len(b) < self.gridSize*self.gridSize:\\n b.append(0)\\n b = np.array(b).reshape((self.gridSize, self.gridSize))\\n tmparr.append(b)\\n\\n self.conjMap = np.array(tmparr)\",\n \"def merge_nodes(self,n0,n1):\\n # -- Sanity checks - does not yet allow for collapsing edges.\\n\\n # if they share any cells, would update the cells, but for now\\n # just signal failure.\\n n0_cells=list(self.node_to_cells(n0))\\n n1_cells=list(self.node_to_cells(n1))\\n cell_to_edge_cache={}\\n\\n for c in n1_cells:\\n if c in n0_cells:\\n print(\\\"cell %d common to both nodes\\\"%c)\\n raise GridException(\\\"Not ready for merging nodes in the same cell\\\")\\n # otherwise record and fix up below\\n\\n # while we're looping, cache the edges as they will\\n # be mutated along the way.\\n cell_to_edge_cache[c]=self.cell_to_edges(c).copy()\\n\\n # do they share an edge, but not already fixed in the above stanza?\\n j=self.nodes_to_edge(n0,n1)\\n if j is not None:\\n raise GridException(\\\"Not ready for merging endpoints of an edge\\\")\\n\\n edge_map={} # index of superceded edge => superceding edge\\n\\n # Update edges of n1 to point to n0\\n # if that would cause a duplicate edge, then the n1 version is deleted\\n n1_edges=list(self.node_to_edges(n1)) # make copy since we'll mutate it\\n for j in n1_edges:\\n if self.edges['nodes'][j,0]==n1:\\n nj=0\\n elif self.edges['nodes'][j,1]==n1:\\n nj=1\\n else:\\n assert False # sanity check\\n newnodes=self.edges[j]['nodes'].copy()\\n newnodes[nj]=n0\\n # it's possible that this is an edge which already exists\\n jother=self.nodes_to_edge(*newnodes)\\n if jother is not None:\\n # want to keep jother, delete j. but is there info on\\n # cells which should be brought over?\\n edge_map[j]=jother\\n # wait to delete j until after cells have been moved to jother.\\n else:\\n self.log.debug(\\\"Modifying edge j=%d\\\"%j)\\n self.modify_edge(j,nodes=newnodes)\\n\\n # -- Transition any cells. \\n for c in n1_cells:\\n # update the node list:\\n cnodes=self.cell_to_nodes(c).copy()\\n nc=list(cnodes).index(n1)\\n cnodes[nc]=n0\\n\\n # Dangerous to use cell_to_edges, since it may\\n # have to consult the edge topology, which is disrupted\\n # in the above code. \\n # cell_to_edges: first checks cells['edges'], may \\n # go to cell_to_nodes(c): that's safe.\\n # and nodes_to_edge\\n # -> node_to_edges, which in turn may consult self.edges['nodes']\\n\\n #cedges=self.cell_to_edges(c).copy()\\n cedges=cell_to_edge_cache[c]\\n\\n for ji,j in enumerate(cedges):\\n if j in edge_map:\\n # is there were edges['cells'] should be updated?\\n\\n # sever the edge=>cell pointer, to p\\n # could just set to [-1,-1], but this keeps things very explicit\\n # for debugging\\n j_cells=list(self.edges['cells'][j])\\n j_cells_side=j_cells.index(c)\\n j_cells[ j_cells_side ] = -1\\n self.modify_edge(j,cells=j_cells)\\n\\n # and modify the receiving edge, too\\n jo=edge_map[j]\\n jo_cells=list(self.edges['cells'][jo])\\n # which side of jo? a bit tedious...\\n if list(self.edges['nodes'][j]).index(n1) == list(self.edges['nodes'][jo]).index(n0):\\n # same orientation\\n jo_cells_side=j_cells_side\\n elif list( self.edges['nodes'][j]).index(n1) == 1-list(self.edges['nodes'][jo]).index(n0):\\n jo_cells_side=1-j_cells_side\\n else:\\n raise Exception(\\\"Failed in some tedium\\\")\\n assert jo_cells[jo_cells_side]<0\\n jo_cells[jo_cells_side]=c\\n self.modify_edge(edge_map[j],cells=jo_cells)\\n # yikes. any chance that worked?\\n\\n cedges[ji]=edge_map[j]\\n\\n # maybe this is where we'd update cells['edges'] too?\\n self.modify_cell(c,nodes=cnodes,edges=cedges)\\n\\n for dead_edge in edge_map:\\n self.delete_edge(dead_edge)\\n\\n self.delete_node(n1)\",\n \"def get_overlapping_conn(conn1: NDArray,\\n conn2: NDArray) -> Tuple[NDArray, NDArray]:\\n\\n conn_union = np.empty((0, 3), dtype=np.int32)\\n\\n # Get unique components\\n if np.ma.is_masked(conn1):\\n concomp1 = np.unique(conn1).compressed()\\n else:\\n concomp1 = np.unique(conn1)\\n\\n if np.ma.is_masked(conn2):\\n concomp2 = np.unique(conn2).compressed()\\n else:\\n concomp2 = np.unique(conn2)\\n\\n # Loop through them and connect size and number of overlapping data\\n for ix2 in concomp2:\\n for ix1 in concomp1:\\n # Skip 0 component combination with other components\\n if not ix1 == 0 and not ix2 == 0:\\n idx = np.where((conn1 == ix1) & (conn2 == ix2))[0]\\n if np.count_nonzero(idx) > 0:\\n carray = np.array([ix2, ix1, np.count_nonzero(idx)],\\n dtype=np.int32, ndmin=2)\\n\\n conn_union = np.concatenate((conn_union, carray), axis=0)\\n\\n # Get 0 components in both frames\\n elif ix1 == 0 and ix2 == 0:\\n idx = np.where((conn1 == ix2) & (conn2 == ix1))[0]\\n if np.count_nonzero(idx) > 0:\\n carray = np.array([ix2, ix1, np.count_nonzero(idx)],\\n dtype=np.int32, ndmin=2)\\n\\n conn_union = np.concatenate((conn_union, carray), axis=0)\\n\\n # Find components to correct in Frame 2\\n conn_pairs = np.empty((0, 3), dtype=np.int32)\\n\\n for k in np.unique(conn_union[:, 0]):\\n ik = conn_union[:, 0] == k\\n # find number of times components is referenced\\n count = np.sum(conn_union[:, 0] == k)\\n\\n if count > 1:\\n max_points = np.max(conn_union[ik][:, 2])\\n # Select the one with the most points\\n ik = np.where((conn_union[:, 0] == k) &\\n (conn_union[:, 2] == max_points))[0]\\n # Select first if there are more pairs with same num of points\\n ik = np.array(ik[0], ndmin=1) if ik.shape[0] > 1 else ik\\n\\n conn_pairs = np.concatenate((conn_pairs, conn_union[ik]), axis=0)\\n\\n return conn_pairs\",\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 test():\\n test_map1 = np.array([\\n [1, 1, 1, 1, 1, 1, 1, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1]])\\n x_spacing1 = 0.13\\n y_spacing1 = 0.2\\n start1 = np.array([[0.3], [0.3], [0]])\\n goal1 = np.array([[0.6], [1], [0]])\\n path1 = dijkstras(test_map1,x_spacing1,y_spacing1,start1,goal1)\\n true_path1 = np.array([\\n [ 0.3 , 0.3 ],\\n [ 0.325, 0.3 ],\\n [ 0.325, 0.5 ],\\n [ 0.325, 0.7 ],\\n [ 0.455, 0.7 ],\\n [ 0.455, 0.9 ],\\n [ 0.585, 0.9 ],\\n [ 0.600, 1.0 ]\\n ])\\n if np.array_equal(path1,true_path1):\\n print(\\\"Path 1 passes\\\")\\n\\n test_map2 = np.array([\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [1, 1, 1, 1, 1, 1, 1, 1],\\n [1, 0, 0, 1, 1, 0, 0, 1],\\n [1, 0, 0, 1, 1, 0, 0, 1],\\n [1, 0, 0, 1, 1, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 0, 0, 0, 0, 0, 0, 1],\\n [1, 1, 1, 1, 1, 1, 1, 1]])\\n start2 = np.array([[0.5], [1.0], [1.5707963267948966]])\\n goal2 = np.array([[1.1], [0.9], [-1.5707963267948966]])\\n x_spacing2 = 0.2\\n y_spacing2 = 0.2\\n path2 = dijkstras(test_map2,x_spacing2,y_spacing2,start2,goal2)\\n true_path2 = np.array([[ 0.5, 1.0],\\n [ 0.5, 1.1],\\n [ 0.5, 1.3],\\n [ 0.5, 1.5],\\n [ 0.7, 1.5],\\n [ 0.9, 1.5],\\n [ 1.1, 1.5],\\n [ 1.1, 1.3],\\n [ 1.1, 1.1],\\n [ 1.1, 0.9]])\\n if np.array_equal(path2,true_path2):\\n print(\\\"Path 2 passes\\\")\",\n \"def mergeRoundaboutChunks(segments):\\n \\n roundabouts = segments[segments.tag.apply(lambda x : ('junction' in x and(x['junction'] in ['circular','roundabout'] )))]\\n roundabouts=roundabouts.nodes.apply(lambda x : pd.Series((x[0],x[-1]),index=['in','out']))\\n roundabouts=roundabouts[roundabouts['in']!=roundabouts['out']]\\n incopmleteRoundabouts = roundabouts[~roundabouts['in'].isin(roundabouts['out'])].index.values\\n while(len(incopmleteRoundabouts)!=0):\\n roundabouts.drop(incopmleteRoundabouts,inplace=True)\\n incopmleteRoundabouts = roundabouts[~roundabouts['in'].isin(roundabouts['out'])].index.values\\n\\n\\n def getRoundaboutFromChunks(startSeg,chunks):\\n \\\"\\\"\\\"\\n connect roundabout chunks\\n \\\"\\\"\\\"\\n \\n sequence=[startSeg]\\n nextIndex=startSeg\\n while len(sequence)<=1 or sequence[0]!=sequence[-1]:\\n outValue = chunks.loc[nextIndex]['out']\\n nextIndex = chunks[chunks['in']==outValue].index[0]\\n sequence.append(nextIndex)\\n return sequence[:-1]\\n\\n sequences=roundabouts.index.map(lambda x : getRoundaboutFromChunks(x,roundabouts))\\n\\n sequences=pd.Series(sequences)\\n\\n sequences = sequences.groupby(lambda x : sorted(sequences.loc[x])[0]).first()\\n\\n sequences=sequences.apply(lambda x : np.concatenate([ segments.nodes.loc[seg] for seg in x]).tolist())\\n \\n segments.drop(roundabouts.loc[~roundabouts.index.isin(sequences.index)].index,inplace=True)\\n for idx in sequences.index:\\n segments.at[idx,'nodes']=sequences.loc[idx]\",\n \"def create_jointsmap(uv_coord, size):\\r\\n\\r\\n\\t# define connections and colors of the bones\\r\\n\\t# print(coords_hw[-1]) # this is center ( the 22nd point)\\r\\n\\tcanvas = np.zeros((size, size, 3))\\r\\n\\tbones = [\\r\\n\\t\\t((1, 2), THUMB_COLOR1),\\r\\n\\t\\t((2, 3), THUMB_COLOR2),\\r\\n\\t\\t((3, 4), THUMB_COLOR3),\\r\\n\\r\\n\\t\\t((5, 6), INDEX_COLOR1),\\r\\n\\t\\t((6, 7), INDEX_COLOR2),\\r\\n\\t\\t((7, 8), INDEX_COLOR3),\\r\\n\\r\\n\\t\\t((9, 10), MIDDLE_COLOR1),\\r\\n\\t\\t((10, 11), MIDDLE_COLOR2),\\r\\n\\t\\t((11, 12), MIDDLE_COLOR3),\\r\\n\\r\\n\\t\\t((13, 14), RING_COLOR1),\\r\\n\\t\\t((14, 15), RING_COLOR2),\\r\\n\\t\\t((15, 16), RING_COLOR3),\\r\\n\\r\\n\\t\\t((17, 18), PINKY_COLOR1),\\r\\n\\t\\t((18, 19), PINKY_COLOR2),\\r\\n\\t\\t((19, 20), PINKY_COLOR3)]\\r\\n\\tpalm = []\\r\\n\\tfor connection, _ in [((0, 1), []),\\r\\n\\t\\t\\t\\t\\t\\t ((1, 5), []),\\r\\n\\t\\t\\t\\t\\t\\t ((5, 9), []),\\r\\n\\t\\t\\t\\t\\t\\t ((9, 13), []),\\r\\n\\t\\t\\t\\t\\t\\t ((13, 17), []),\\r\\n\\t\\t\\t\\t\\t\\t ((17, 0), []), ]:\\r\\n\\t\\tcoord1 = uv_coord[connection[0]]\\r\\n\\t\\tpalm.append([int(coord1[0]), int(coord1[1])])\\r\\n\\t# palm.append([int((coord1[0]-.5)* W_scale+ W_offset ), int(-(coord1[1]- .5)* H_scale+ H_offset)])\\r\\n\\t# print(palm)\\r\\n\\tcv2.fillConvexPoly(canvas, np.array([palm], dtype=np.int32), PALM_COLOR)\\r\\n\\tfor connection, color in bones:\\r\\n\\t\\tcoord1 = uv_coord[connection[0]]\\r\\n\\t\\tcoord2 = uv_coord[connection[1]]\\r\\n\\t\\tcoords = np.stack([coord1, coord2])\\r\\n\\t\\t# 0.5, 0.5 is the center\\r\\n\\t\\tx = coords[:, 0]\\r\\n\\t\\ty = coords[:, 1]\\r\\n\\t\\tmX = x.mean()\\r\\n\\t\\tmY = y.mean()\\r\\n\\t\\tlength = ((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** 0.5\\r\\n\\t\\tangle = np.math.degrees(np.math.atan2(y[0] - y[1], x[0] - x[1]))\\r\\n\\t\\tpolygon = cv2.ellipse2Poly((int(mX), int(mY)), (int(length / 2), 16), int(angle), 0, 360, 1)\\r\\n\\t\\tcv2.fillConvexPoly(canvas, polygon, color)\\r\\n\\treturn canvas\",\n \"def handle_diagonals_crossing_connections(self, conn: Connection):\\n if not self.is_connection_diagonal(conn):\\n return False\\n j1 = self.get_junc_from_node(conn.me)\\n j2 = self.get_junc_from_node(conn.other)\\n # check if top-left to bottom-right diagonal of top-right to bottom-left diagonal\\n indices_diff = (j1.indices.row - j2.indices.row, j1.indices.col - j2.indices.col)\\n if indices_diff[0] == indices_diff[1]:\\n # top-left to bottom-right\\n top_left = j1 if indices_diff[0] == -1 else j2 # else diff is 1\\n top_right = self.get_junc((top_left.indices.row, top_left.indices.col + 1))\\n bottom_left = self.get_junc((top_left.indices.row + 1, top_left.indices.col))\\n if self.are_juncs_connected(top_right, bottom_left):\\n # print(conn, top_right, bottom_left, sep=\\\"\\\\n\\\")\\n # we should remove the connection.\\n if bottom_left.right.node_id in top_right.down.get_connections_ids():\\n top_right.down.remove_connection_by_id(bottom_left.right.node_id)\\n if bottom_left.up.node_id in top_right.left.get_connections_ids():\\n top_right.left.remove_connection_by_id(bottom_left.up.node_id)\\n else:\\n # top-right to bottom-left\\n top_right = j1 if indices_diff[0] == -1 else j2 # else diff is 1\\n top_left = self.get_junc((top_right.indices.row, top_right.indices.col - 1))\\n bottom_right = self.get_junc((top_right.indices.row + 1, top_right.indices.col))\\n if self.are_juncs_connected(top_left, bottom_right):\\n # print(conn, top_left, bottom_right, sep=\\\"\\\\n\\\")\\n # we should remove the connection.\\n if bottom_right.left.node_id in top_left.down.get_connections_ids():\\n top_left.down.remove_connection_by_id(bottom_right.left.node_id)\\n if bottom_right.up.node_id in top_left.right.get_connections_ids():\\n top_left.right.remove_connection_by_id(bottom_right.up.node_id)\",\n \"def stitch_unw2frames(unw_data1: NDArray, conn_data1: NDArray, rdict1: dict,\\n unw_data2: NDArray, conn_data2: NDArray, rdict2: dict,\\n correction_method: Optional[str] = 'cycle2pi',\\n range_correction: Optional[bool] = False,\\n verbose: Optional[bool] = False) -> \\\\\\n Tuple[NDArray, NDArray, dict]:\\n\\n # Adjust connected Component in Frame 2 to start\\n # with last component number in Frame-1\\n\\n conn_data2 = conn_data2 + np.nanmax(conn_data1)\\n conn_data2[conn_data2 == np.nanmax(conn_data1)] = 0.0\\n\\n # GET FRAME OVERLAP\\n box_1, box_2 = frame_overlap(\\n rdict1['SNWE'], rdict2['SNWE'],\\n [rdict1['LAT_SPACING'], rdict1['LON_SPACING']],\\n [rdict2['LAT_SPACING'], rdict2['LON_SPACING']])\\n\\n # LOOP OVER COMPONENTS WITHIN THE OVERLAP\\n # Get connected component pairs\\n if verbose:\\n print('\\\\nGetting overlapping components')\\n\\n # Forward correction\\n conn_pairs = get_overlapping_conn(conn_data1[box_1],\\n conn_data2[box_2])\\n\\n for pair in conn_pairs:\\n diff, cycles2pi, range_corr = _integer_2pi_cycles(\\n unw_data1[box_1],\\n conn_data1[box_1],\\n np.float32(pair[1]),\\n unw_data2[box_2],\\n conn_data2[box_2],\\n np.float32(pair[0]),\\n range_correction=range_correction,\\n print_msg=verbose)\\n\\n # Correction methods: mean difference, 2pi integer cycles\\n if correction_method == 'cycle2pi':\\n correction = cycles2pi\\n elif correction_method == 'meanoff':\\n correction = diff\\n range_correction = False\\n else:\\n raise ValueError(f'Wrong correction method {correction_method}, ',\\n 'Select one of available: \\\"cycle2pi\\\", \\\"meanoff\\\"')\\n\\n # add range correction\\n if range_correction:\\n correction += range_corr\\n ik = conn_data2 == np.float32(pair[0])\\n unw_data2[ik] += correction\\n conn_data2[ik] = np.float32(pair[1])\\n\\n # Backward correction\\n conn_reverse = get_overlapping_conn(conn_data2[box_2],\\n conn_data1[box_1])\\n\\n # Keep only different componentes in pairing\\n ik = np.where(conn_reverse[:, 0] != conn_reverse[:, 1])\\n conn_reverse = conn_reverse[ik]\\n\\n for pair in conn_reverse:\\n print('Going backward!') if verbose else None\\n diff, cycles2pi, range_corr = _integer_2pi_cycles(\\n unw1=unw_data1[box_1],\\n concom1=conn_data1[box_1],\\n ix1=np.float32(pair[0]),\\n unw2=unw_data2[box_2],\\n concom2=conn_data2[box_2],\\n ix2=np.float32(pair[1]),\\n range_correction=range_correction,\\n print_msg=verbose)\\n\\n # Correction methods: mean difference, 2pi integer cycles\\n if correction_method == 'cycle2pi':\\n correction = cycles2pi\\n elif correction_method == 'meanoff':\\n correction = diff\\n range_correction = False\\n else:\\n raise ValueError(f'Wrong correction method {correction_method}, ',\\n 'Select one of available: \\\"cycle2pi\\\", \\\"meanoff\\\"')\\n\\n # add range correction\\n if range_correction:\\n correction += range_corr\\n\\n ik = conn_data1 == np.float32(pair[0])\\n unw_data1[ik] -= correction\\n conn_data1[ik] = np.float32(pair[1])\\n\\n # Update connected component frame 2 naming\\n idx1 = np.max(conn_data1)\\n idx = np.unique(conn_data2[conn_data2 > idx1]).compressed()\\n conn_data2 = update_connect_components(conn_data2, idx, idx1+1)\\n\\n # Combine corrected unwrappedPhase and connectedComponents arrays\\n comb_snwe = [rdict1['SNWE'], rdict2['SNWE']]\\n comb_latlon = [[rdict1['LAT_SPACING'], rdict1['LON_SPACING']],\\n [rdict2['LAT_SPACING'], rdict2['LON_SPACING']]]\\n\\n (combined_unwrap,\\n combined_snwe,\\n combined_latlon_spacing) = combine_data_to_single(\\n [_nan_filled_array(unw_data1),\\n _nan_filled_array(unw_data2)],\\n comb_snwe, comb_latlon,\\n method='mean')\\n combined_conn, _, _ = combine_data_to_single(\\n [_nan_filled_array(conn_data1),\\n _nan_filled_array(conn_data2)],\\n comb_snwe, comb_latlon,\\n method='min')\\n # combined dict\\n combined_dict = dict(SNWE=combined_snwe,\\n LAT_SPACING=combined_latlon_spacing[0],\\n LON_SPACING=combined_latlon_spacing[1])\\n\\n combined_unwrap = np.ma.masked_invalid(combined_unwrap)\\n np.ma.set_fill_value(combined_unwrap, 0.)\\n combined_conn = np.ma.masked_invalid(combined_conn)\\n np.ma.set_fill_value(combined_conn, -1.)\\n\\n return combined_unwrap, combined_conn, combined_dict\",\n \"def find_optimal_components_subset(contours, edges):\\n c_info = props_for_contours(contours, edges)\\n c_info.sort(key=lambda x: -x['sum'])\\n total = np.sum(edges) / 255\\n area = edges.shape[0] * edges.shape[1]\\n\\n c = c_info[0]\\n del c_info[0]\\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\\n crop = this_crop\\n covered_sum = c['sum']\\n\\n while covered_sum < total:\\n changed = False\\n recall = 1.0 * covered_sum / total\\n prec = 1 - 1.0 * crop_area(crop) / area\\n f1 = 2 * (prec * recall / (prec + recall))\\n # print '----'\\n for i, c in enumerate(c_info):\\n this_crop = c['x1'], c['y1'], c['x2'], c['y2']\\n new_crop = union_crops(crop, this_crop)\\n new_sum = covered_sum + c['sum']\\n new_recall = 1.0 * new_sum / total\\n new_prec = 1 - 1.0 * crop_area(new_crop) / area\\n new_f1 = 2 * new_prec * new_recall / (new_prec + new_recall)\\n\\n # Add this crop if it improves f1 score,\\n # _or_ it adds 25% of the remaining pixels for <15% crop expansion.\\n # ^^^ very ad-hoc! make this smoother\\n remaining_frac = c['sum'] / (total - covered_sum)\\n new_area_frac = 1.0 * crop_area(new_crop) / crop_area(crop) - 1\\n if new_f1 > f1 or (\\n remaining_frac > 0.25 and new_area_frac < 0.15):\\n print('%d %s -> %s / %s (%s), %s -> %s / %s (%s), %s -> %s' % (\\n i, covered_sum, new_sum, total, remaining_frac,\\n crop_area(crop), crop_area(new_crop), area, new_area_frac,\\n f1, new_f1))\\n crop = new_crop\\n covered_sum = new_sum\\n del c_info[i]\\n changed = True\\n break\\n\\n if not changed:\\n break\\n\\n return crop\",\n \"def compute_coverage_for_contour_pair(\\n contour1: np.ndarray,\\n contour2: np.ndarray,\\n max_size: int = DEFAULT_MAX_CONTOUR_MASK_SIZE,\\n):\\n im1, im2 = compute_contour_binary_masks(contour1, contour2, max_size=max_size)\\n return (im1 & im2).sum() / im1.sum()\",\n \"def test_1_2_2D_rec_splits(self):\\n check = [(3.0, -2.0), (7.0, -1.0), (7.0, -2.0), (3.0, -1.0),\\n (5.0, -1.5), (3.0, -1.5), (5.0, -2.0), (4.0, -1.75),\\n (7.0, -1.5), (5.0, -1.0), (6.0, -1.25), (6.0, -1.75),\\n (4.0, -1.25), (5.0, -1.75), (4.0, -1.5), (4.5, -1.625),\\n (3.0, -1.75), (4.0, -2.0), (3.5, -1.875), (3.5, -1.625),\\n (4.5, -1.875), (5.0, -1.25), (6.0, -1.5), (5.5, -1.375),\\n (7.0, -1.25), (6.0, -1.0), (6.5, -1.125), (6.5, -1.375),\\n (5.5, -1.125), (5.5, -1.625), (7.0, -1.75), (6.0, -2.0),\\n (6.5, -1.875), (6.5, -1.625), (5.5, -1.875), (4.5, -1.375),\\n (3.0, -1.25), (4.0, -1.0), (3.5, -1.125), (3.5, -1.375),\\n (4.5, -1.125)]\\n nn_checks = {(3.0, -2.0): [(3.0, -1.75), (3.5, -1.875), (4.0, -2.0)],\\n (5.0, -1.75): [(5.0, -2.0), (5.0, -1.5), (5.5, -1.625),\\n (5.5, -1.875), (4.5, -1.625), (6.0, -1.75),\\n (4.5, -1.875), (4.0, -1.75)],\\n (6.0, -2.0): [(5.0, -2.0), (5.5, -1.875), (6.0, -1.75),\\n (6.5, -1.875), (7, -2)],\\n (4.5, -1.125): [(5.0, -1.0), (4.0, -1.25), (5.0, -1.25),\\n (4.0, -1.0)]}\\n\\n init_triangulation(2, 2, check, nn_checks, bounds=[(3, 7), (-2, -1)])\",\n \"def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\\n # number of nodes\\n nx = 5 # along x\\n ny = 5 # along y\\n\\n # getting integration points\\n nint = 4\\n points, weights = get_points_weights(nint=nint)\\n\\n # geometry\\n a = 3 # along x\\n b = 3 # along y\\n\\n # material properties\\n E = 200e9\\n nu = 0.3\\n laminaprop = (E, E, nu)\\n stack = [0]\\n h = 0.001\\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\\n\\n # creating mesh\\n x = np.linspace(0, a, nx)\\n y = np.linspace(0, b, ny)\\n xmesh, ymesh = np.meshgrid(x, y)\\n\\n # node coordinates and position in the global matrix\\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\\n nids = 1 + np.arange(ncoords.shape[0])\\n nid_pos = dict(zip(nids, np.arange(len(nids))))\\n\\n # identifying nodal connectivity for plate elements\\n # similar than Nastran's CQUAD4\\n #\\n # ^ y\\n # |\\n #\\n # 4 ________ 3\\n # | |\\n # | | --> x\\n # | |\\n # |_______|\\n # 1 2\\n\\n\\n nids_mesh = nids.reshape(nx, ny)\\n n1s = nids_mesh[:-1, :-1].flatten()\\n n2s = nids_mesh[1:, :-1].flatten()\\n n3s = nids_mesh[1:, 1:].flatten()\\n n4s = nids_mesh[:-1, 1:].flatten()\\n\\n num_elements = len(n1s)\\n print('num_elements', num_elements)\\n\\n N = DOF*nx*ny\\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n init_k_KC0 = 0\\n init_k_KG = 0\\n\\n plates = []\\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\\n plate = BFSPlate2D()\\n plate.n1 = n1\\n plate.n2 = n2\\n plate.n3 = n3\\n plate.n4 = n4\\n plate.c1 = DOF*nid_pos[n1]\\n plate.c2 = DOF*nid_pos[n2]\\n plate.c3 = DOF*nid_pos[n3]\\n plate.c4 = DOF*nid_pos[n4]\\n plate.ABD = lam.ABD\\n plate.lex = a/(nx - 1)\\n plate.ley = b/(ny - 1)\\n plate.init_k_KC0 = init_k_KC0\\n plate.init_k_KG = init_k_KG\\n update_KC0(plate, points, weights, Kr, Kc, Kv)\\n init_k_KC0 += KC0_SPARSE_SIZE\\n init_k_KG += KG_SPARSE_SIZE\\n plates.append(plate)\\n\\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\\n\\n # applying boundary conditions\\n\\n # locating nodes\\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\\n\\n x = ncoords[:, 0]\\n y = ncoords[:, 1]\\n\\n # applying boundary conditions\\n # simply supported\\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\\n bk[2::DOF] = check\\n check = isclose(x, 0) | isclose(x, a)\\n bk[3::DOF] = check\\n # point supports\\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\\n bk[0::DOF] = check\\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\\n bk[1::DOF] = check\\n\\n # unconstrained nodes\\n bu = ~bk # logical_not\\n\\n # defining external force vector\\n fext = np.zeros(KC0.shape[0], dtype=float)\\n\\n # applying unitary load along u at x=a\\n # nodes at vertices get 1/2 the force\\n for plate in plates:\\n pos1 = nid_pos[plate.n1]\\n pos2 = nid_pos[plate.n2]\\n pos3 = nid_pos[plate.n3]\\n pos4 = nid_pos[plate.n4]\\n if isclose(x[pos3], a):\\n Nxx = -1\\n xi = +1\\n elif isclose(x[pos1], 0):\\n Nxx = +1\\n xi = -1\\n else:\\n continue\\n lex = plate.lex\\n ley = plate.ley\\n indices = []\\n c1 = DOF*pos1\\n c2 = DOF*pos2\\n c3 = DOF*pos3\\n c4 = DOF*pos4\\n cs = [c1, c2, c3, c4]\\n for ci in cs:\\n for i in range(DOF):\\n indices.append(ci + i)\\n fe = np.zeros(4*DOF, dtype=float)\\n for j in range(nint):\\n eta = points[j]\\n plate.update_Nu(xi, eta)\\n Nu = np.asarray(plate.Nu)\\n fe += ley/2*weights[j]*Nu*Nxx\\n fext[indices] += fe\\n\\n Kuu = KC0[bu, :][:, bu]\\n fextu = fext[bu]\\n\\n # static solver\\n uu = spsolve(Kuu, fextu)\\n u = np.zeros(KC0.shape[0], dtype=float)\\n u[bu] = uu\\n\\n if plot_static:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n uplot = u[0::DOF].reshape(nx, ny).T\\n vplot = u[1::DOF].reshape(nx, ny).T\\n print('u extremes', uplot.min(), uplot.max())\\n print('v extremes', vplot.min(), vplot.max())\\n levels = np.linspace(uplot.min(), uplot.max(), 300)\\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n # eigenvalue solver\\n\\n # getting integration points\\n for plate in plates:\\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\\n KGuu = KG[bu, :][:, bu]\\n\\n # solving modified generalized eigenvalue problem\\n # Original: (KC0 + lambda*KG)*v = 0\\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\\n num_eigenvalues = 5\\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\\n tol=1e-6, sigma=1., mode='cayley')\\n eigvals = -1./eigvals\\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\\n eigvecs[bu, :] = eigvecsu\\n\\n if plot_lb:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n mode = 0\\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\\n levels = np.linspace(wplot.min(), wplot.max(), 300)\\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\\n assert isclose(kc, 6.6, rtol=0.05)\",\n \"def threeRoadConnect(data, x1, y1, x2, y2):\\n temp_data = np.pad(data, (1, 1), 'constant', constant_values=0)\\n # init\\n points = [[x1, y1]]\\n flagX = False\\n flagY = False\\n if not data[y1][x1] == data[y2][x2]:\\n return False, []\\n # Two lines parallel to the X-AXIS\\n posX = 0\\n for i in range(0, 18):\\n if temp_data[y1 + 1][i] == 0 and temp_data[y2 + 1][i] == 0:\\n if XRoadConnect(temp_data, i, y1 + 1, x1 + 1, y1 + 1) \\\\\\n and XRoadConnect(temp_data, i, y2 + 1, x2 + 1, y2 + 1) \\\\\\n and YRoadConnect(temp_data, i, y1 + 1, i, y2 + 1):\\n flagX = True\\n posX = i - 1\\n if flagX:\\n points.append([posX, y1])\\n points.append([posX, y2])\\n\\n # Two lines parallel to the Y-AXIS\\n posY = 0\\n for i in range(0, 10):\\n if temp_data[i][x1 + 1] == 0 and temp_data[i][x2 + 1] == 0:\\n if YRoadConnect(temp_data, x1 + 1, i, x1 + 1, y1 + 1) \\\\\\n and YRoadConnect(temp_data, x2 + 1, i, x2 + 1, y2 + 1) \\\\\\n and XRoadConnect(temp_data, x1 + 1, i, x2 + 1, i):\\n flagY = True\\n posY = i - 1\\n if flagY and flagX == False:\\n points.append([x1, posY])\\n points.append([x2, posY])\\n\\n if flagX or flagY:\\n data[y1][x1] = data[y2][x2] = 0\\n points.append([x2, y2])\\n print(data)\\n print(3)\\n return flagX or flagY, points\",\n \"def simplify(self):\\n \\n added_clumps = []\\n staying_tunnels = []\\n removed_clumps = set()\\n \\n for tunnel in self.tunnels:\\n tunnel_end_distance = self.get_distance(tunnel.start, tunnel.end)\\n if tunnel_end_distance - tunnel.start.distance_from_wall < 0 or \\\\\\n tunnel_end_distance - tunnel.end.distance_from_wall < 0:\\n removed_clumps.add(tunnel.start.node)\\n removed_clumps.add(tunnel.end.node)\\n new_node = tunnel.merge_endpoints()\\n added_clumps.append(new_node)\\n else:\\n staying_tunnels.append(tunnel)\\n #print removed_clumps\\n \\n new_clumps = []\\n \\n for clump in list(self.clumps) + added_clumps:\\n if clump not in removed_clumps:\\n new_clumps.append(clump)\\n else:\\n removed_clumps.remove(clump)\\n\\n if removed_clumps:\\n raise Exception(\\\"Some removed clumps couldn't be found in the main set and I'm scared\\\")\\n \\n self.clumps = new_clumps\\n self.tunnels = staying_tunnels\",\n \"def coupled_decomposition(sdata, ddata, sorigin=(), dorigin=(), M=4, sub_skp=None):\\n\\n soriginx, soriginy = sorigin\\n doriginx, doriginy = dorigin\\n\\n # Create membership arrays for each input image\\n smembership = np.ones(sdata.shape)\\n dmembership = np.ones(ddata.shape)\\n\\n # Project the image into a polar coordinate system centered on p_{1}\\n stheta = reproject_image_into_polar(sdata, origin=(int(soriginx), int(soriginy)))\\n dtheta = reproject_image_into_polar(ddata, origin=(int(doriginx), int(doriginy)))\\n\\n # Compute the mean profiles for each radial slice\\n smean = np.empty(RADIAL_SIZE)\\n dmean = np.empty(RADIAL_SIZE)\\n for i, t in enumerate(THETAS):\\n # The way this method words, it is possible to get nan values in some of the steps as this is discrete\\n smean[i] = np.mean(sdata[(t <= stheta) & (stheta <= t + RADIAL_STEP)])\\n dmean[i] = np.mean(ddata[(t <= dtheta) & (dtheta <= t + RADIAL_STEP)])\\n\\n # Rotate the second image around the origin and compute the correlation coeff. for each 0.5 degree rotation.\\n maxp = -1\\n maxidx = 0\\n for j in range(RADIAL_SIZE):\\n dsearch = np.concatenate((dmean[j:], dmean[:j]))\\n r, p = pearsonr(smean, dsearch)\\n if r >= maxp:\\n maxp = r\\n maxidx = j\\n\\n # Maximum correlation (theta) defines the angle of rotation for the destination image\\n theta = THETAS[maxidx]\\n\\n if theta <= np.pi:\\n lam = theta\\n else:\\n lam = 2 * np.pi - theta\\n\\n # Classify the sub-images based on the decomposition size (M) and theta\\n breaks = np.linspace(0, 2 * np.pi, M + 1)\\n for i, t in enumerate(breaks[:-1]):\\n smembership[(t <= stheta) & ( stheta <= breaks[i+1])] = i\\n\\n for i, t in enumerate(breaks[:-1]):\\n # Handle the boundary crossers\\n start_theta = t + theta\\n stop_theta = breaks[i + 1] + theta\\n\\n if stop_theta > 2 * np.pi:\\n stop_theta -= 2 * np.pi\\n if start_theta > 2 * np.pi:\\n start_theta -= 2 * np.pi\\n\\n if start_theta > stop_theta:\\n # Handles the case where theta is a negative rotation\\n dmembership[(start_theta <= dtheta) & (dtheta <= 2 * np.pi)] = i\\n dmembership[(0 <= dtheta) * dtheta <= stop_theta + lam] = i\\n dmembership[(start_theta <= dtheta) & (dtheta <= stop_theta)] = i\\n else:\\n # Handles the standard case without boundary crossers\\n dmembership[(start_theta <= dtheta) & (dtheta <= stop_theta)] = i\\n\\n return smembership, dmembership\",\n \"def interpop_connections(mat_connections, n_mitral, n_subpop, n_mitral_per_subpop, inter_conn_rate, inter_conn_strength, homeostasy=False):\\n if homeostasy:\\n init_total = 1.*mat_connections.sum(axis=0)\\n tr_init_total = 1.*mat_connections.sum(axis=1)\\n\\n res_mat = mat_connections\\n n_granule = n_subpop\\n subpop_start = np.zeros((n_subpop)) # which is the first non interconnected mitral from each subpop\\n for mtpop in inter_conn_rate:\\n assert mtpop >= 0 and mtpop < n_subpop, \\\\\\n \\\"Incorrect mitral sub-population number \\\"+str(mtpop)+\\\" for inter-connectivity.\\\"\\n for grpop in inter_conn_rate[mtpop]:\\n if grpop != mtpop:\\n assert grpop >= 0 and grpop < n_granule, \\\\\\n \\\"Incorrect granule sub-population number \\\"+str(grpop)+\\\" for inter-connectivity.\\\"\\n conn = inter_conn_rate[mtpop][grpop]\\n assert conn >= 0 and conn <= 1, \\\"Connectivity must be in [0, 1].\\\"\\n nlinks = int(n_mitral_per_subpop*conn)\\n newconn = np.zeros((n_mitral_per_subpop, 1))\\n for i in xrange(nlinks):\\n try:\\n newconn[i + subpop_start[mtpop]] = inter_conn_strength[mtpop][grpop]\\n except Exception, e:\\n print \\\"Likely, too much connections to have no overlap, rewrite the code !\\\"\\n print \\\"EXCEPTION:\\\", e\\n exit(1)\\n subpop_start[mtpop] += nlinks\\n start = mtpop*n_mitral_per_subpop\\n stop = start + n_mitral_per_subpop\\n res_mat[start:stop, grpop] = newconn[:, 0]\\n \\n if not(homeostasy):\\n return res_mat, res_mat.transpose()\\n else:\\n # Connection strengthes are normalized such that each neuron (mitral or granule) receive the same total amount of excitation or inhibition \\n # (i.e. the same total of synaptic conductance) as if they were no interglomerular connections\\n tr_res_mat = res_mat.transpose().copy()\\n tr_res_mat_norm = tr_init_total/tr_res_mat.sum(axis=0) # here the numerator is 1. because there is only one granule\\n tr_res_mat = tr_res_mat*tr_res_mat_norm\\n res_mat_norm = init_total/res_mat.sum(axis=0)\\n res_mat = res_mat*res_mat_norm\\n return res_mat, tr_res_mat\",\n \"def sort_filtered_contours(self):\\r\\n\\r\\n # Get the contours again\\r\\n invert = 255 - self.thresh_invert\\r\\n real_contours = cv2.findContours(invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n real_contours = real_contours[0] if len(real_contours) == 2 else real_contours[1]\\r\\n\\r\\n # Make sure that they're within the correct range for size\\r\\n # If too small, it is probably noise; if too large, then should be things around the grid\\r\\n for i, c in enumerate(real_contours, 1):\\r\\n contour_area = cv2.contourArea(c)\\r\\n if self.min_cell_size < contour_area < self.max_cell_size:\\r\\n self.good_contours.append(c)\\r\\n\\r\\n # We assume a square board, so the number of rows/cols should be the square root of total contours/cells\\r\\n self.board_dimension = int(math.sqrt(len(self.good_contours)))\\r\\n\\r\\n # Sort the contours from top to bottom\\r\\n (half_sorted_contours, _) = contours.sort_contours(self.good_contours, method=\\\"top-to-bottom\\\")\\r\\n\\r\\n # We then sort each row from left to right\\r\\n row = []\\r\\n for i, c in enumerate(half_sorted_contours, 1):\\r\\n row.append(c)\\r\\n if i % self.board_dimension == 0:\\r\\n (full_sorted_contours, _) = contours.sort_contours(row, method=\\\"left-to-right\\\")\\r\\n self.game_board_contours.append(full_sorted_contours)\\r\\n row = []\",\n \"def plot_simplex(self, num_contours: int = 100, num_sub_div: int = 8,\\n color_map: str = 'viridis', border: bool = True, ax: Axes = None) -> Axes:\\n\\n corners = array([[0, 0], [1, 0], [0.5, 0.75 ** 0.5]])\\n triangle = Triangulation(corners[:, 0], corners[:, 1])\\n mid_points = [\\n (corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2\\n for i in range(3)\\n ]\\n\\n def to_barycentric(cartesian):\\n \\\"\\\"\\\"\\n Converts 2D Cartesian to barycentric coordinates.\\n\\n :param cartesian: A length-2 sequence containing the x and y value.\\n \\\"\\\"\\\"\\n s = [(corners[i] - mid_points[i]).dot(cartesian - mid_points[i]) / 0.75\\n for i in range(3)]\\n s_clipped = clip(a=s, a_min=0, a_max=1)\\n return s_clipped / norm(s_clipped, ord=1)\\n\\n refiner = UniformTriRefiner(triangle)\\n tri_mesh = refiner.refine_triangulation(subdiv=num_sub_div)\\n f = [self._method(to_barycentric(xy))\\n for xy in zip(tri_mesh.x, tri_mesh.y)]\\n ax = ax or new_axes()\\n ax.tricontourf(tri_mesh, f, num_contours, cmap=color_map)\\n ax.set_aspect('equal')\\n ax.set_xlim(0, 1)\\n ax.set_ylim(0, 0.75 ** 0.5)\\n ax.set_axis_off()\\n if border:\\n ax.triplot(triangle, linewidth=1)\\n\\n return ax\",\n \"def connect_points(clipped, side1, side2, window):\\n edge = side1\\n while edge != side2:\\n clipped.append(window.points[0][edge])\\n edge = (edge - 1) % 4\",\n \"def buildEdges(self):\\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\\n assert self.nonDoubleIntersectors()\\n # print('2.1')\\n for i in self.inter1:\\n assert self.nonDoubleIntersectors()\\n # print('test')\\n assert all(all(v in self.poly1.vertices for v in f.vertices) for f in self.poly1.faces)\\n if not i.isSTraced():\\n self.traceSurface(i)\\n # print('2.2')\\n for i in self.inter2:\\n if not i.isSTraced():\\n self.traceSurface(i)\\n for i in self.inter1:\\n if not i.isITraced():\\n self.traceInterior(i)\\n for i in self.inter2:\\n if not i.isITraced():\\n self.traceInterior(i)\",\n \"def build_non_planar_disconnected_test_graph_with_k5_subgraph():\\n graph = build_triangle_graph()\\n addition_graph = build_k5_graph()\\n addition_graph2 = build_k5_graph()\\n\\n merge_graphs(graph, addition_graph)\\n merge_graphs(graph, addition_graph2)\\n\\n return graph\",\n \"def imposeDSBconnections(self,Nc,breakLoci):\\n #TODO\\n #Adapt to any Nb\\n if Nc == 0:\\n return\\n else:\\n breakLoci = np.array(breakLoci)\\n breakLoci = np.vstack((breakLoci,breakLoci+1)).T.flatten() # [A1, B1] -> [A1, A2, B1, B2]\\n possible_pairs = [[a,b] for a,b in product(breakLoci, np.arange(0,self.numMonomers))]\\n\\n k0 = 0\\n k1 = 4\\n \\n if breakLoci[0] == 0:\\n for _ in range(2):\\n possible_pairs.pop(0)\\n k0 += 1\\n \\n if breakLoci[-1] == 99:\\n for _ in range(2):\\n possible_pairs.pop(-1)\\n k1 -= 1\\n \\n for i in range(k0,k1):\\n for _ in range(3):\\n possible_pairs.pop(self.numMonomers*i + breakLoci[i] - 1 - 3*i + k0)\\n \\n for _ in range(2):\\n possible_pairs.pop(breakLoci[2]-3 + k0)\\n for _ in range(2):\\n possible_pairs.pop(self.numMonomers + breakLoci[2] - 2*3 + k0 - 2)\\n selected = np.array(possible_pairs)[np.random.choice(len(possible_pairs),size=Nc,replace=False)].T\\n self.connect(selected) \\n self.Nc += Nc\",\n \"def drawShadedContours(xlist, ylist, zmatrix, levels):\\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))\",\n \"def __create_connections(self):\\n \\\"\\\"\\\"\\n When adding diagonals, each node adds only diagonals to nodes below it.\\n This prevents a case where two nodes add diagonals with each other, s.t. both diagonals are added.\\n \\\"\\\"\\\"\\n # top left corner:\\n self.add_connection(self.get_junc((0, 0)).right, self.get_junc((0, 1)).left)\\n self.add_connection(self.get_junc((0, 0)).down, self.get_junc((1, 0)).up)\\n # diagonal to down right\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((0, 0)).right, self.get_junc((1, 1)).up)\\n else:\\n self.add_connection(self.get_junc((0, 0)).down, self.get_junc((1, 1)).left)\\n # top row:\\n for wi in range(1, self.width - 1):\\n self.add_connection(self.get_junc((0, wi)).right, self.get_junc((0, wi + 1)).left)\\n self.add_connection(self.get_junc((0, wi)).left, self.get_junc((0, wi - 1)).right)\\n self.add_connection(self.get_junc((0, wi)).down, self.get_junc((1, wi)).up)\\n # diagonal to down left\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((0, wi)).left, self.get_junc((1, wi - 1)).up)\\n else:\\n self.add_connection(self.get_junc((0, wi)).down, self.get_junc((1, wi - 1)).right)\\n # diagonal to down right\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((0, wi)).right, self.get_junc((1, wi + 1)).up)\\n else:\\n self.add_connection(self.get_junc((0, wi)).down, self.get_junc((1, wi + 1)).left)\\n # top right corner:\\n self.add_connection(self.get_junc((0, -1)).left, self.get_junc((0, -2)).right)\\n self.add_connection(self.get_junc((0, -1)).down, self.get_junc((1, -1)).up)\\n # diagonal to down left\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((0, -1)).left, self.get_junc((1, -2)).up)\\n else:\\n self.add_connection(self.get_junc((0, -1)).down, self.get_junc((1, -2)).right)\\n # middle rows:\\n for hi in range(1, self.height - 1):\\n # left node\\n self.add_connection(self.get_junc((hi, 0)).right, self.get_junc((hi, 1)).left)\\n self.add_connection(self.get_junc((hi, 0)).down, self.get_junc((hi + 1, 0)).up)\\n self.add_connection(self.get_junc((hi, 0)).up, self.get_junc((hi - 1, 0)).down)\\n # diagonal to down right\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((hi, 0)).right, self.get_junc((hi + 1, 1)).up)\\n else:\\n self.add_connection(self.get_junc((hi, 0)).down, self.get_junc((hi + 1, 1)).left)\\n # middle nodes\\n for wi in range(1, self.width - 1):\\n self.add_connection(self.get_junc((hi, wi)).right, self.get_junc((hi, wi + 1)).left)\\n self.add_connection(self.get_junc((hi, wi)).left, self.get_junc((hi, wi - 1)).right)\\n self.add_connection(self.get_junc((hi, wi)).down, self.get_junc((hi + 1, wi)).up)\\n self.add_connection(self.get_junc((hi, wi)).up, self.get_junc((hi - 1, wi)).down)\\n # diagonal to down left\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((hi, wi)).left, self.get_junc((hi + 1, wi - 1)).up)\\n else:\\n self.add_connection(self.get_junc((hi, wi)).down, self.get_junc((hi + 1, wi - 1)).right)\\n # diagonal to down right\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((hi, wi)).right, self.get_junc((hi + 1, wi + 1)).up)\\n else:\\n self.add_connection(self.get_junc((hi, wi)).down, self.get_junc((hi + 1, wi + 1)).left)\\n # right node:\\n self.add_connection(self.get_junc((hi, -1)).left, self.get_junc((hi, -2)).right)\\n self.add_connection(self.get_junc((hi, -1)).down, self.get_junc((hi + 1, -1)).up)\\n self.add_connection(self.get_junc((hi, -1)).up, self.get_junc((hi - 1, -1)).down)\\n # diagonal to down left\\n if randint(0, 1) == 0:\\n self.add_connection(self.get_junc((hi, -1)).left, self.get_junc((hi + 1, -2)).up)\\n else:\\n self.add_connection(self.get_junc((hi, -1)).down, self.get_junc((hi + 1, -2)).right)\\n # bottom left corner:\\n self.add_connection(self.get_junc((-1, 0)).right, self.get_junc((-1, 1)).left)\\n self.add_connection(self.get_junc((-1, 0)).up, self.get_junc((-2, 0)).down)\\n # bottom row\\n for wi in range(1, self.width - 1):\\n self.add_connection(self.get_junc((-1, wi)).right, self.get_junc((-1, wi + 1)).left)\\n self.add_connection(self.get_junc((-1, wi)).left, self.get_junc((-1, wi - 1)).right)\\n self.add_connection(self.get_junc((-1, wi)).up, self.get_junc((-2, wi)).down)\\n # bottom right corner:\\n self.add_connection(self.get_junc((-1, -1)).left, self.get_junc((-1, -2)).right)\\n self.add_connection(self.get_junc((-1, -1)).up, self.get_junc((-2, -1)).down)\",\n \"def solve_part2(start):\\n inputs = load_inputs(False)\\n all_matches = []\\n tiles = inputs.keys()\\n for elem in tiles:\\n matches = defaultdict(list)\\n for elem2 in tiles:\\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\\n l = matches[elem]\\n l.append(elem2)\\n if matches[elem]:\\n all_matches.append(matches[elem])\\n\\n # start frmo an aribtrary corner\\n # find a match, rotate me so that the match is along the right side\\n # fill in properly oriented match\\n # repeat, for row = 1+, consider top-match and left-match\\n\\n # for eery rotations / orientation, look fot the pattern\",\n \"def listOfOverlappingTTPairs():\\n listOfHalfModules = listOfTTHalfModules()\\n ttmap = TTModulesMap_instance\\n pairs = []\\n regions = {'A':1, 'B':2, 'C':3}\\n print \\\"Overlapping TT half modules:\\\"\\n for hm1 in listOfHalfModules:\\n for hm2 in listOfHalfModules:\\n # they must be different\\n if hm1 == hm2: continue\\n # they must be both on top or both on bottom\\n if locateTTHalfModule(hm1)[3] != locateTTHalfModule(hm2)[3]: continue\\n # they must be on the same layer\\n if locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0]: continue\\n # avoid duplicates\\n if (hm1, hm2) in pairs: continue\\n if (hm2, hm1) in pairs: continue\\n # they must be contiguous:\\n if (locateTTHalfModule(hm1)[1] == locateTTHalfModule(hm2)[1]):\\n if (abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) == 1):\\n pairs.append( (hm1, hm2) )\\n else:\\n num1 = locateTTHalfModule(hm1)[2]\\n num2 = locateTTHalfModule(hm2)[2]\\n max1 = ttmap.numberOfModules[locateTTHalfModule(hm1)[0]]['Region'+locateTTHalfModule(hm1)[1]] - 1\\n max2 = ttmap.numberOfModules[locateTTHalfModule(hm2)[0]]['Region'+locateTTHalfModule(hm2)[1]] - 1\\n nreg1 = regions[locateTTHalfModule(hm1)[1]]\\n nreg2 = regions[locateTTHalfModule(hm2)[1]]\\n if ( (num1==max1 and num2==0 and nreg2-nreg1==1) or (num2==max2 and num1==0 and nreg1-nreg2==1) ):\\n pairs.append( (hm1, hm2) )\\n print '\\\\t', hm1, hm2\\n ## - same region\\n #if ((abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) != 1)\\n # and (locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])): continue\\n ## - or neighbouring region\\n #elif not ((locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])\\n # and ( ( (ttmap.numberOfModules[locateTTHalfModule(hm1)[0]] == locateTTHalfModule(hm1)[2]+1 )\\n # and (locateTTHalfModule(hm2)[2] == 0) )\\n # or ( (ttmap.numberOfModules[locateTTHalfModule(hm2)[0]] == locateTTHalfModule(hm2)[2]+1 )\\n # and (locateTTHalfModule(hm1)[2] == 0) ) ) ): continue\\n ## append to list of pairs\\n #pairs.append( (hm1, hm2) )\\n print\\n return pairs\",\n \"def test_construct_subcircuit_layers(self):\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=3)\\r\\n\\r\\n def circuit(params):\\r\\n # section 1\\r\\n qml.RX(params[0], wires=0)\\r\\n # section 2\\r\\n qml.RY(params[1], wires=0)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n # section 3\\r\\n qml.RX(params[2], wires=0)\\r\\n qml.RY(params[3], wires=1)\\r\\n qml.RZ(params[4], wires=2)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n # section 4\\r\\n qml.RX(params[5], wires=0)\\r\\n qml.RY(params[6], wires=1)\\r\\n qml.RZ(params[7], wires=2)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n return qml.expval(qml.PauliX(0)), qml.expval(qml.PauliX(1)), qml.expval(qml.PauliX(2))\\r\\n\\r\\n circuit = qml.QNode(circuit, dev)\\r\\n\\r\\n params = np.ones([8])\\r\\n tapes = circuit.metric_tensor(params, only_construct=True)\\r\\n\\r\\n # this circuit should split into 4 independent\\r\\n # sections or layers when constructing subcircuits\\r\\n assert len(tapes) == 4\\r\\n\\r\\n # first layer subcircuit\\r\\n assert len(tapes[0].operations) == 1\\r\\n assert isinstance(tapes[0].operations[0], qml.Hadamard) # PauliX decomp\\r\\n\\r\\n # second layer subcircuit\\r\\n assert len(tapes[1].operations) == 4\\r\\n assert isinstance(tapes[1].operations[0], qml.RX)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\\r\\n assert isinstance(tapes[1].operations[2], qml.S)\\r\\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\\r\\n\\r\\n # # third layer subcircuit\\r\\n assert len(tapes[2].operations) == 8\\r\\n assert isinstance(tapes[2].operations[0], qml.RX)\\r\\n assert isinstance(tapes[2].operations[1], qml.RY)\\r\\n assert isinstance(tapes[2].operations[2], qml.CNOT)\\r\\n assert isinstance(tapes[2].operations[3], qml.CNOT)\\r\\n # PauliX decomp\\r\\n assert isinstance(tapes[2].operations[4], qml.Hadamard)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[2].operations[5], qml.PauliZ)\\r\\n assert isinstance(tapes[2].operations[6], qml.S)\\r\\n assert isinstance(tapes[2].operations[7], qml.Hadamard)\\r\\n\\r\\n # # fourth layer subcircuit\\r\\n assert len(tapes[3].operations) == 13\\r\\n assert isinstance(tapes[3].operations[0], qml.RX)\\r\\n assert isinstance(tapes[3].operations[1], qml.RY)\\r\\n assert isinstance(tapes[3].operations[2], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[3], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[4], qml.RX)\\r\\n assert isinstance(tapes[3].operations[5], qml.RY)\\r\\n assert isinstance(tapes[3].operations[6], qml.RZ)\\r\\n assert isinstance(tapes[3].operations[7], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[8], qml.CNOT)\\r\\n # PauliX decomp\\r\\n assert isinstance(tapes[3].operations[9], qml.Hadamard)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[3].operations[10], qml.PauliZ)\\r\\n assert isinstance(tapes[3].operations[11], qml.S)\\r\\n assert isinstance(tapes[3].operations[12], qml.Hadamard)\",\n \"def get_contour_features(mask,selectcell=\\\"centered\\\"):\\r\\n \\r\\n #binarize image (everything above 0 becomes 1)\\r\\n mask = np.clip(mask,a_min=0,a_max=1)\\r\\n\\r\\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\\r\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\r\\n contours = list(contours)\\r\\n \\r\\n #in case there is no contour found, add a dummy contour\\r\\n if len(contours)==0:\\r\\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\\r\\n\\r\\n #Sort contours, longest first\\r\\n contours.sort(key=len,reverse=True)\\r\\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\\r\\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\\r\\n\\r\\n mu_origs = [cv2.moments(contour) for contour in contours]\\r\\n mu_hulls = [cv2.moments(hull) for hull in hulls]\\r\\n\\r\\n area_origs = [mu_orig[\\\"m00\\\"] for mu_orig in mu_origs]\\r\\n area_hulls = [mu_hull[\\\"m00\\\"] for mu_hull in mu_hulls]\\r\\n\\r\\n #drop events where area is zero\\r\\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \\r\\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\\r\\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\\r\\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\\r\\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\\r\\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\\r\\n \\r\\n \\r\\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n\\r\\n \\r\\n if selectcell == \\\"smooth\\\":\\r\\n #compute the area ratio (roughness of contour)\\r\\n area_ratio = np.array(area_hulls)/np.array(area_origs)\\r\\n #get the contour with minimum roughness (smooth contour)\\r\\n sorter = np.argsort(area_ratio) #smallest first\\r\\n\\r\\n if selectcell == \\\"centered\\\":\\r\\n #select contour that is closest to the center of the image. \\r\\n #In iPAC, cells are usually in the center.\\r\\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\\r\\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\\r\\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\\r\\n sorter = np.argsort(distances) #smallest first\\r\\n \\r\\n #sort values with respect to chosen metric (area_ratio or distance)\\r\\n contours = [contours[s] for s in sorter]\\r\\n hulls = [hulls[s] for s in sorter]\\r\\n pos_x = [pos_x[s] for s in sorter]\\r\\n pos_y = [pos_y[s] for s in sorter]\\r\\n mu_origs = [mu_origs[s] for s in sorter]\\r\\n area_origs = [area_origs[s] for s in sorter]\\r\\n area_hulls = [area_hulls[s] for s in sorter]\\r\\n \\r\\n # draw mask of the chosen contour\\r\\n mask = np.zeros_like(mask)\\r\\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\\r\\n\\r\\n hull = hulls[0]#[0:n_contours]\\r\\n pos_x = pos_x[0]\\r\\n pos_y = pos_y[0] \\r\\n mu_orig = mu_origs[0]#[0:n_contours]\\r\\n area_orig = area_origs[0]#[0:n_contours]\\r\\n area_hull = area_hulls[0]#[0:n_contours]\\r\\n \\r\\n if area_orig>0:\\r\\n area_ratio = area_hull/area_orig\\r\\n else:\\r\\n area_ratio = np.nan\\r\\n\\r\\n arc = cv2.arcLength(hull, True) \\r\\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\\\"m00\\\"]) / arc\\r\\n\\r\\n\\r\\n dic = {\\\"mask\\\":mask,\\\"pos_x\\\":pos_x,\\\"pos_y\\\":pos_y,\\\"area_orig\\\":area_orig,\\\"area_hull\\\":area_hull,\\\\\\r\\n \\\"area_ratio\\\":area_ratio,\\\"circularity\\\":circularity}\\r\\n return dic\",\n \"def discrete_coons_patch(ab, bc, dc, ad):\\n if not ab:\\n ab = [ad[0]] * len(dc)\\n if not bc:\\n bc = [ab[-1]] * len(ad)\\n if not dc:\\n dc = [bc[-1]] * len(ab)\\n if not ad:\\n ad = [dc[0]] * len(bc)\\n\\n n = len(ab)\\n m = len(bc)\\n\\n n_norm = normalize_values(range(n))\\n m_norm = normalize_values(range(m))\\n\\n array = [[0] * m for i in range(n)]\\n for i, ki in enumerate(n_norm):\\n for j, kj in enumerate(m_norm):\\n # first function: linear interpolation of first two opposite curves\\n lin_interp_ab_dc = add_vectors(scale_vector(ab[i], (1 - kj)), scale_vector(dc[i], kj))\\n # second function: linear interpolation of other two opposite curves\\n lin_interp_bc_ad = add_vectors(scale_vector(ad[j], (1 - ki)), scale_vector(bc[j], ki))\\n # third function: linear interpolation of four corners resulting a hypar\\n a = scale_vector(ab[0], (1 - ki) * (1 - kj))\\n b = scale_vector(bc[0], ki * (1 - kj))\\n c = scale_vector(dc[-1], ki * kj)\\n d = scale_vector(ad[-1] , (1 - ki) * kj)\\n lin_interp_a_b_c_d = sum_vectors([a, b, c, d])\\n # coons patch = first + second - third functions\\n array[i][j] = subtract_vectors(add_vectors(lin_interp_ab_dc, lin_interp_bc_ad), lin_interp_a_b_c_d)\\n\\n # create vertex list\\n vertices = []\\n for i in range(n):\\n vertices += array[i]\\n\\n # create face vertex list\\n face_vertices = []\\n for i in range(n - 1):\\n for j in range(m - 1):\\n face_vertices.append([i * m + j , i * m + j + 1 , (i + 1) * m + j + 1, (i + 1) * m + j])\\n return vertices, face_vertices\",\n \"def compare_transects(run1, run2, hours=[12,], extent=None, ztop=1000,\\n columntitles=['coupled','uncoupled'],\\n subsubdir=None,\\n third_transect=False):\\n ltoffset=fio.run_info[run1]['UTC_offset']\\n if extent is None:\\n extent = constants.extents[run1.split('_')[0]]\\n nrows=3+third_transect\\n # transects = extent centre +- frac of extent width/height\\n y0,x0 = (extent[2]+extent[3])/2.0, (extent[0]+extent[1])/2.0\\n # do middle point +- 1/3 of distance to extent edge\\n dx = (extent[1]-extent[0]) / 3.0\\n dy = (extent[3]-extent[2]) / 3.0\\n # transects: [[[lat,lon],[lat,lon]],...]\\n transects = [[[y0+dy,x0-dx], [y0+dy, x0+dx]],\\n [[y0,x0-dx], [y0, x0+dx]],\\n ]\\n tcolors = ['yellow','blue',]\\n if third_transect:\\n transects.append([[y0-dy,x0-dx], [y0-dy, x0+dx]])\\n tcolors.append('magenta')\\n \\n \\n dtimes=fio.run_info[run1]['filedates'][np.array(hours)]\\n \\n ## for each hour\\n for dti, dt in enumerate(dtimes):\\n ## read hour of data for both runs\\n cubes1 = fio.read_model_run(run1, fdtime=[dt], extent=extent, \\n add_topog=True, add_winds=True,\\n add_z=True, add_theta=True)\\n \\n u1,v1,w1,z1 = cubes1.extract([\\\"u\\\",\\\"v\\\",\\\"upward_air_velocity\\\",\\\"z_th\\\"])\\n ctimes=utils.dates_from_iris(w1)\\n zd1 = z1.data.data\\n theta1, = cubes1.extract(\\\"potential_temperature\\\")\\n topog1=cubes1.extract(\\\"surface_altitude\\\")[0].data\\n \\n # read fire outputs\\n ff1,sh1,u101,v101 = fio.read_fire(model_run=run1,\\n dtimes=ctimes, \\n extent=extent,\\n sensibleheat=True,\\n wind=True)\\n \\n cubes2 = fio.read_model_run(run2, fdtime=[dt], extent=extent, \\n add_topog=True, add_winds=True,\\n add_z=True, add_theta=True)\\n u2,v2,w2,z2 = cubes2.extract([\\\"u\\\",\\\"v\\\",\\\"upward_air_velocity\\\",\\\"z_th\\\"])\\n zd2 = z2.data.data\\n theta2, = cubes2.extract(\\\"potential_temperature\\\")\\n topog2=cubes2.extract(\\\"surface_altitude\\\")[0].data\\n # read fire outputs\\n ff2,sh2,u102,v102 = fio.read_fire(model_run=run2,\\n dtimes=ctimes, \\n extent=extent,\\n sensibleheat=True,\\n wind=True)\\n \\n \\n \\n for cti,ct in enumerate(ctimes):\\n \\n ## FIGURE BEGIN:\\n fig = plt.figure(figsize=[13,14])\\n ## looking at two separate runs\\n for runi, [sh,ff,u10,v10,u,v,w,zd,theta,topog] in enumerate(zip([sh1,sh2],[ff1,ff2],[u101,u102],[v101,v102],[u1,u2],[v1,v2],[w1,w2],[zd1,zd2],[theta1,theta2],[topog1,topog2])):\\n # read datacubes\\n\\n lats = ff.coord('latitude').points\\n lons = ff.coord('longitude').points\\n \\n shd = sh[cti].data.data\\n LT = ct + timedelta(hours=ltoffset)\\n \\n ffd = ff[cti].data.data\\n u10d = u10[cti].data.data\\n v10d = v10[cti].data.data\\n \\n \\n #plt.subplot(4,2,1+runi) # top row\\n _,ax = emberstorm.topdown_emberstorm(\\n fig=fig, subplot_row_col_n=(nrows,2,1+runi),\\n extent=extent, lats=lats, lons=lons,\\n ff=ffd, sh=shd, u10=u10d, v10=v10d,\\n topog=topog,\\n annotate=False,\\n sh_kwargs={'colorbar':False}\\n )\\n ax.set_aspect('equal')\\n if runi==1:\\n plt.yticks([],[])\\n plt.title(columntitles[runi])\\n for transect, tcolor in zip(transects,tcolors):\\n ## Add dashed line to show where transect will be\\n start,end = transect\\n # outline the dashed line\\n line_effects=[patheffects.Stroke(linewidth=5, foreground='darkgrey'), patheffects.Normal()]\\n plt.plot([start[1],end[1]],[start[0],end[0], ], \\n linestyle='--',\\n color=tcolor,\\n linewidth=3, \\n path_effects=line_effects,\\n #alpha=0.9,\\n )\\n \\n ## Plot title\\n plt.suptitle(LT.strftime('%b %d, %H%M (LT)'),fontsize=28)\\n \\n # Transect plots\\n for trani,transect in enumerate(transects):\\n ax=plt.subplot(nrows,2,3+runi+2*trani)\\n \\n trets = emberstorm.transect_emberstorm(\\n u[cti].data.data,\\n v[cti].data.data,\\n w[cti].data.data,\\n zd, lats, lons, transect,\\n topog=topog,\\n sh=shd,\\n theta=theta[cti].data.data,\\n ztop=ztop,\\n theta_contourargs={'levels':[297,300,303,306,309]},\\n wind_contourargs={'colorbar':False},\\n )\\n if runi==1:\\n plt.yticks([],[])\\n \\n # match splines to transect lines\\n plotting.set_spine_color(ax,tcolors[trani])\\n # finally add desired annotations\\n plotting.annotate_max_winds(trets['s'])\\n \\n \\n ## add wind speed colorbar\\n cbar_ax = fig.add_axes([0.92, 0.4, 0.02, 0.2]) # X Y Width Height\\n cmap = matplotlib.cm.get_cmap(name=plotting._cmaps_['windspeed'])\\n #cmap.set_over('1.0')\\n #norm = matplotlib.colors.Normalize(vmin=0, vmax=22.5)\\n norm = matplotlib.colors.BoundaryNorm(np.arange(0,22.51,2.5), cmap.N)\\n \\n cb1 = matplotlib.colorbar.ColorbarBase(cbar_ax, cmap=cmap,\\n norm=norm,\\n extend='max',\\n orientation='vertical')\\n cb1.set_label('ms$^{-1}$')\\n \\n \\n ## SAVE FIGURE\\n subdir='transects'\\n if subsubdir is not None:\\n subdir += '/'+subsubdir\\n plt.tight_layout(rect=[0,0.03,0.92,0.975]) #(left, bottom, right, top)\\n fio.save_fig(run2,_sn_,ct,subdir=subdir,plt=plt)\",\n \"def cfdProcessElementTopology(self):\\r\\n ## (list of lists) List where each index represents an element in the domain. Each index has an associated list which contains the elements for which is shares a face (i.e. the neighouring elements). Do not confuse a faces 'neighbour cell', which refers to a face's neighbour element, with the neighbouring elements of a cell. \\r\\n self.elementNeighbours = [[] for i in range(0,self.numberOfElements)]\\r\\n\\r\\n ## (list of lists) list of face indices forming each element\\r\\n self.elementFaces = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n #populates self.elementNeighbours\\r\\n for iFace in range(self.numberOfInteriorFaces):\\r\\n own=self.owners[iFace]\\r\\n nei=self.neighbours[iFace]\\r\\n \\r\\n #adds indices of neighbour cells\\r\\n self.elementNeighbours[own].append(nei)\\r\\n self.elementNeighbours[nei].append(own)\\r\\n \\r\\n #adds interior faces\\r\\n self.elementFaces[own].append(iFace)\\r\\n self.elementFaces[nei].append(iFace)\\r\\n \\r\\n #adds boundary faces ('patches')\\r\\n for iFace in range(self.numberOfInteriorFaces,self.numberOfFaces):\\r\\n own=self.owners[iFace]\\r\\n self.elementFaces[own].append(iFace)\\r\\n \\r\\n ## List of lists containing points forming each element\\r\\n self.elementNodes = [[] for i in range(0,self.numberOfElements)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n \\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n self.elementNodes[iElement].append(self.faceNodes[faceIndex])\\r\\n \\r\\n self.elementNodes[iElement] = list(set([item for sublist in self.elementNodes[iElement] for item in sublist]))\\r\\n \\r\\n ## Upper coefficient indices (owners)\\r\\n self.upperAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n ## Lower coefficient indices (owners)\\r\\n self.lowerAnbCoeffIndex=[[] for i in range(0,self.numberOfInteriorFaces)]\\r\\n \\r\\n for iElement in range(self.numberOfElements):\\r\\n ## Element number from 1 to numberOfElements + 1\\r\\n iNb=1\\r\\n for faceIndex in self.elementFaces[iElement]:\\r\\n \\r\\n #skip if it is a boundary face\\r\\n if faceIndex > self.numberOfInteriorFaces-1:\\r\\n continue\\r\\n \\r\\n own = self.owners[faceIndex]\\r\\n nei = self.neighbours[faceIndex]\\r\\n \\r\\n if iElement == own:\\r\\n self.upperAnbCoeffIndex[faceIndex] = iNb\\r\\n elif iElement == nei:\\r\\n self.lowerAnbCoeffIndex[faceIndex] = iNb\\r\\n \\r\\n iNb = iNb +1\",\n \"def monolayer_4band():\\n a = 0.222\\n ax = 0.438\\n ay = 0.332\\n theta = 96.79 * (pi / 180)\\n phi = 103.69 * (pi / 180)\\n\\n lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])\\n\\n h = a * sin(phi - pi / 2)\\n s = 0.5 * ax - a * cos(theta / 2)\\n lat.add_sublattices(\\n ('A', [0, 0, h], 0),\\n ('B', [s, 0, 0], 0),\\n ('C', [ax/2, ay/2, 0], 0),\\n ('D', [ax/2 + s, ay/2, h], 0)\\n )\\n\\n lat.register_hopping_energies({\\n 't1': -1.22,\\n 't2': 3.665,\\n 't3': -0.205,\\n 't4': -0.105,\\n 't5': -0.055\\n })\\n\\n lat.add_hoppings(\\n # t1\\n ([-1, 0], 'A', 'D', 't1'),\\n ([-1, -1], 'A', 'D', 't1'),\\n ([ 0, 0], 'B', 'C', 't1'),\\n ([ 0, -1], 'B', 'C', 't1'),\\n # t2\\n ([ 0, 0], 'A', 'B', 't2'),\\n ([ 0, 0], 'C', 'D', 't2'),\\n # t3\\n ([ 0, 0], 'A', 'D', 't3'),\\n ([ 0, -1], 'A', 'D', 't3'),\\n ([ 1, 1], 'C', 'B', 't3'),\\n ([ 1, 0], 'C', 'B', 't3'),\\n # t4\\n ([ 0, 0], 'A', 'C', 't4'),\\n ([ 0, -1], 'A', 'C', 't4'),\\n ([-1, 0], 'A', 'C', 't4'),\\n ([-1, -1], 'A', 'C', 't4'),\\n ([ 0, 0], 'B', 'D', 't4'),\\n ([ 0, -1], 'B', 'D', 't4'),\\n ([-1, 0], 'B', 'D', 't4'),\\n ([-1, -1], 'B', 'D', 't4'),\\n # t5\\n ([-1, 0], 'A', 'B', 't5'),\\n ([ 0, 1], 'A', 'B', 't5'),\\n ([ 0, -1], 'A', 'B', 't5'),\\n ([-1, 0], 'C', 'D', 't5'),\\n ([ 0, 1], 'C', 'D', 't5'),\\n ([ 0, -1], 'C', 'D', 't5'),\\n )\\n\\n return lat\",\n \"def connected((e,r)):\\n \\n # Deal with the middle case so we don't divide by zero\\n if r==0: return [(1,1),(2,1),(3,1),(4,1),(5,1),(0,1)]\\n # If the input is impossible, return nothing to prune the branch (shouldn't\\n # happen)\\n if e>=6*r: return []\\n connected=[]\\n mult=e//r\\n rem=e % r\\n #Going sideways\\n toAdd=((6*r-1,r) if e==0 else (e-1,r))\\n connected.append(toAdd)\\n toAdd=((0,r) if e==6*r-1 else (e+1,r))\\n connected.append(toAdd)\\n #Going inward\\n toAdd=( (0,r-1)if mult==5 and rem==r-1 else (mult*(r-1)+rem,r-1) )\\n connected.append(toAdd)\\n if rem!=0:\\n connected.append((mult*(r-1)+rem-1,r-1))\\n\\n #Going outward\\n if r<nLayers-1:\\n connected.append((mult*(r+1)+rem,r+1))\\n connected.append((mult*(r+1)+rem+1,r+1))\\n if rem==0: # only case where negatives could result\\n if mult>0: connected.append( (mult*(r+1)-1,r+1))\\n else: connected.append( (6*(r+1)-1,r+1))\\n \\n return connected\",\n \"def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\\n # get activation for each seperated vc\\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\\n max_ch_index = max_ch_index.view(-1, L) # n, L\\n\\n all_activation_vcs = []\\n\\n for i in range(len(integrate_activation_vc)):\\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\\n all_activation_vcs.append(integrate_activation_vc_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n print(f\\\"unique_vc_i {unique_vc_i.shape}\\\")\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\\n activate_vc_i[index_vc_i, :] = 0.\\n all_activation_vcs.append(activate_vc_i)\\n \\n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\\n \\n # decompose each mask \\n all_masks = []\\n for i in range(len(sim_map_max)):\\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\\n all_masks.append(sim_map_max_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\\n vc_sim_map_max_i[index_vc_i] = 0.\\n all_masks.append(vc_sim_map_max_i)\\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\\n\\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\\\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\\\"\\n\\n return all_activation_vcs, all_masks\",\n \"def registration(im1, im2, num = 10, opt = 'py', outputPath = 'None'):\\n\\n # determin which one is the right side of the breast\\n b_size = 5\\n n_row, n_col = im1.shape\\n side = 0\\n if np.sum(im1[0:b_size,0:b_size]) < np.sum(im1[0:b_size,n_col-b_size:n_col]):\\n side = 1 \\n\\n # flip the right side image\\n if side == 1:\\n im1 = np.fliplr(im1)\\n else:\\n im2 = np.fliplr(im2) \\n\\n # find edges of both images\\n edge1 = findEdge(im1)\\n edge2 = findEdge(im2)\\n\\n # tune edges of both side\\n edge1 = tuneEdge(edge1,im1.shape)\\n edge2 = tuneEdge(edge2,im2.shape)\\n\\n # samping from both side\\n points1 = contour_sampling(edge1, num)\\n points2 = contour_sampling(edge2, num)\\n\\n # for debugging .........................\\n sam_im1 = np.zeros(im1.shape,np.float32)\\n for point in points1:\\n sam_im1[point[0],point[1]] = 1\\n\\n sam_im2 = np.zeros(im2.shape,np.float32)\\n for point in points2:\\n sam_im2[point[0],point[1]] = 1\\n \\n selem = disk(15)\\n dilated1 = ndimage.convolve(sam_im1, selem, mode='constant', cval=0)\\n dilated2 = ndimage.convolve(sam_im2, selem, mode='constant', cval=0)\\n\\n points1 = np.asarray(points1)\\n points2 = np.asarray(points2)\\n \\n # Thin Plate Spline interpolation\\n dst = np.zeros(im1.shape)\\n # im1 as source\\n if opt == 'py': \\n tps = TPSpline.TPSpline()\\n tps.setCorrespondences(points1, points2)\\n dst = tps.warpImage(im1)\\n return dst\\n\\n if opt == 'c':\\n print \\\"Please run the interpolation with C++ exe file!\\\"\\n print \\\"./TPSpline /home/yanbin/Tomosynthesis/libs/TPSpline/test/ps.txt /home/yanbin/Tomosynthesis/libs/TPSpline/test/pd.txt /home/yanbin/Tomosynthesis/libs/TPSpline/test/5016_test.tif /home/yanbin/Tomosynthesis/libs/TPSpline/test/dst.tif\\\"\\n np.savetxt(outputPath + 'ps.txt', points1, '%d', delimiter=' ') # X is an array\\n np.savetxt(outputPath + 'pd.txt', points2, '%d', delimiter=' ') # X is an array\\n tiffLib.imsave(outputPath + 'im1.tif',im1)\\n return None\",\n \"def get_contour(atom_list):\\n initial = [atom for atom in atom_list if ((0 < len(identify_bonds(atom, atom_list)) < 3) and (check_connected(atom, identify_bonds(atom, atom_list)) == False))]\\n \\n extra_1 = []\\n for atom in atom_list:\\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n for i in neighbours:\\n neighbours2 = [bond[0] for bond in identify_bonds(i, atom_list)]\\n for j in neighbours2:\\n if j in initial:\\n extra_1.append(atom)\\n\\n extra_2 = []\\n for atom in atom_list:\\n neighbours = [bond[0] for bond in identify_bonds(atom, atom_list)]\\n check = 0\\n for i in neighbours:\\n if i in initial:\\n check += 1\\n if ((check == 2) and (atom not in initial)):\\n extra_2.append(atom) \\n return (initial + extra_1 + extra_2)\",\n \"def subj_corr_comparison(subj1, subj2, data_dir, save_dir, opacity = 0.6, save_fig=True):\\n\\n\\tfig = plt.figure(figsize=(15,9))\\n\\tax = fig.subplots()\\n\\tplt.plot([0.0, 0.16], [0.0, 0.16], 'black', label='unity')\\n\\tplot_color = '#2278B5'\\n\\tcorrs = []\\n\\twith h5py.File('%s/%s/%s_STRF_by_binned_pitches_MT.hf5'% (data_dir, subj1, subj1), 'r') as fh:\\n\\t\\tsubj1_corrs = fh['corrs_mt_norm'][:]\\n\\t\\tsubj1_cc_max = fh['/cc_max_mt'][:]\\n\\t\\tsubj1_corrs=corrs/cc_max\\n\\t\\tsubj1_wts = fh['wts_mt'][:]\\n\\t\\tsubj1_pvals = fh['pvals_mt'][:]\\n\\twith h5py.File('%s/%s/%s_STRF_by_binned_pitches_MT.hf5'%(data_dir, subj2, subj2), 'r') as fh:\\n\\t\\tsubj2_corrs = fh['corrs_mt'][:]\\n\\t\\tsubj2_cc_max = fh['/cc_max_mt'][:]\\n\\t\\tsubj2_corrs=corrs/cc_max\\n\\t\\tsubj2_wts = fh['wts_mt'][:]\\n\\t\\tsubj2_pval = fh['pvals_mt'][:]\\n\\n\\tcorrs.append([subj2_corrs, subj1_corrs])\\n\\tpoints = np.hstack(corrs).T\\n\\n\\thull1=ConvexHull(np.vstack((points[:,0] , points[:,1])).T)\\n\\thullv1 = hull1.vertices.copy()\\n\\thullv1 = np.append(hullv1, hullv1[0])\\n\\tprint(hullv1)\\n\\tplt.fill(points[hullv1,0], points[hullv1,1], facecolor=plot_color, alpha=opacity, zorder=2) #envs\\n\\n\\tplt.plot(subj2_corrs[np.where (subj2_pval[0] > 0.05)], np.take(subj1_corrs, np.asarray(np.where (subj2_pval[0] > 0.05)))[0], '.', color='#CDC1C5', label='non-sig corrs')\\n\\tplt.plot(subj2_corrs[np.where (subj2_pval[0] < 0.05)], np.take(subj1_corrs, np.asarray(np.where (subj2_pval[0] < 0.05))[0]), '.' , color='#996666', label='sig corrs')\\n\\t#plt.plot(MT_corrs_0020, MT_corrs_0002, '.', color='#996666') #significant \\n\\tplt.legend()\\n\\n\\tplt.xlabel('%s corr values (r)' %(subj2))\\n\\tplt.ylabel('%s corr values (r)' %(subj1))\\n\\tplt.axis('square')\\n\\n\\tif save_fig:\\n\\t\\tplt.savefig('%s/%s_%s_scatter_comparison.pdf' %(save_dir, subj1, subj2))\\n\\n\\t#run Wilcoxon\\n\\t[z_val, p_val] = wilcoxon(subj1_corrs, subj2_corrs)\\n\\tprint(z_val)\\n\\tprint(p_val)\\n\\n\\n\\t#% performance improvement \\n\\tsubject_list = [subj1, subj2] \\n\\tavg_corrs = []\\n\\tcorrs_std = []\\n\\n\\tavg_corrs.append(subj1_corrs.mean())\\n\\tavg_corrs.append(subj2_corrs.mean())\\n\\n\\t#append std. error for error bars\\n\\tcorrs_std.append(subj1_corrs.std()/np.sqrt(len(subj1_corrs)))\\n\\tcorrs_std.append(subj2_corrs.std()/np.sqrt(len(subj2_corrs)))\\n\\n\\tn_groups = 2\\n\\tplt.figure(figsize=(8,4))\\n\\tbar_width = 0.5\\n\\tindex = np.arange(n_groups)\\n\\n\\tplt.bar(index, avg_corrs, bar_width, yerr=corrs_std, color='#996666', alpha=0.6)\\n\\tplt.xticks(np.arange(len(subject_list)), subject_list, rotation=90)\\n\\tplt.ylabel('Correlation Values')\\n\\tplt.title('Avg. correlation values (MT0002 vs MT0020)')\\n\\n\\tif save_fig:\\n\\t\\tplt.savefig('%s/%s_%s_barplot_comparison.pdf' %(save_dir, subj1, subj2))\",\n \"def computesWingConnexions(self):\\n logger.warning(\\\"!!! WARINING !!!!\\\")\\n logger.warning(\\\"BE CERTAIN THAT CPACS FILE HAS THE HORIZONTAL TAIL\\\")\\n logger.warning(\\\"DEFINED BEFORE THE VERTICAL TAIL!!!!\\\")\\n if self.nWings <= 1:\\n logger.info(\\\"No wing connexions needed\\\")\\n elif self.nWings > 1 and self.nFuselage < 1:\\n logger.error(\\\"Multiple wings with no fuselage! Mesh can not be computed\\\")\\n sys.exit()\\n else:\\n ws_connextionsPoints = self.nWings + self.nFuselage - 1\\n # if self.nFuselage > 0:\\n # ws_connextionsPoints = self.nWings\\n # else:\\n # ws_connextionsPoints = self.nWings -1\\n\\n # ws: wings\\n # d: distance\\n # L: left, R: right, c: center\\n connectedNodes = np.zeros((ws_connextionsPoints,5))\\n for i in range(ws_connextionsPoints):\\n \\\"\\\"\\\"\\n for each wing there is 3 points that need to be taken into\\n account:\\n 1) Left tip position[0]\\n 2) center [np.floor(nNodes/2))]\\n WARNING: keep in mind that symmetric wings always have \\n an odd number of points!\\n 3) right tip position[-1]\\n \\\"\\\"\\\"\\n if self.nFuselage > 0:\\n wingIndex = i+1\\n else:\\n wingIndex = i\\n # logger.debug(\\\"Wing index = \\\"+str(wingIndex))\\n # N = len(self.aircraftNodesPoints[i])\\n currentWingNpoints = len(self.aircraftNodesPoints[wingIndex])\\n if currentWingNpoints > 2:\\n c = int(np.floor(len(self.aircraftNodesPoints[wingIndex])/2))\\n else:\\n c = 0\\n # logger.debug(\\\"c = \\\"+str(c))\\n ws_identifiers = np.empty((ws_connextionsPoints,5))\\n\\n for j in range(ws_connextionsPoints+1):\\n logger.debug(\\\"wingIndex,j = \\\"+str(wingIndex)+\\\" \\\"+str(j))\\n if wingIndex != j:\\n # c: stands for current\\n logger.debug(\\\"True with wingIndex,j = \\\"+str(wingIndex)+\\\" \\\"+str(j))\\n # Computes the distances between all point\\n dist_l = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][0], axis=1)\\n if currentWingNpoints > 2:\\n dist_c = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][c], axis=1)\\n else:\\n dist_c = dist_l\\n dist_r = np.linalg.norm(self.aircraftNodesPoints[j] - self.aircraftNodesPoints[wingIndex][-1],axis=1)\\n\\n # Gets the index of the minimal distance between all point\\n index_l = np.argmin(dist_l)\\n if currentWingNpoints > 2:\\n index_c = np.argmin(dist_c)\\n else:\\n index_c = index_l\\n index_r = np.argmin(dist_r)\\n indexes = np.array([index_l, index_c, index_r])\\n\\n # gets the minimal distance for each wing part\\n minDist_l = dist_l[index_l]\\n if currentWingNpoints > 2:\\n minDist_c = dist_c[index_c]\\n else:\\n minDist_c = minDist_l\\n minDist_r = dist_r[index_r]\\n minDist = np.array([minDist_l,minDist_c,minDist_r])\\n\\n k = np.argmin(minDist)\\n minimalDistance = minDist[k]\\n m = indexes[k]\\n r = len(self.aircraftNodesPoints[wingIndex])\\n tab = np.array([0,c,r])\\n k = tab[k]\\n\\n # minimalDistance: distance between both of these points\\n identifier = np.array([wingIndex,j,k,m,minimalDistance])\\n # logger.debug(\\\"Identifier \\\\n\\\"+str(identifier))\\n if j < wingIndex:\\n ws_identifiers[j] = identifier\\n else:\\n ws_identifiers[j-1] = identifier\\n \\n index2 = np.argmin(ws_identifiers[:,4])\\n old = np.array([ws_identifiers[index2,2],\\n ws_identifiers[index2,3],\\n ws_identifiers[index2,0],\\n ws_identifiers[index2,1],\\n ws_identifiers[index2,4]])\\n if old in connectedNodes and i > 1:\\n logger.warning(\\\"Found a matching connexion\\\")\\n logger.debug(old)\\n logger.debug(ws_identifiers)\\n ws_identifiers = np.delete(ws_identifiers,index2,0)\\n logger.debug(ws_identifiers)\\n index2 = np.argmin(ws_identifiers[:,4])\\n connectedNodes[i] = ws_identifiers[index2]\\n logger.debug(\\\"connected Nodes: \\\\n\\\"+str(connectedNodes[i]))\\n # logger.debug(connectedNodes)\\n \\n self.aircraftConnectedNodes.append(connectedNodes)\\n self.rigidNodesAdder()\\n # sys.exit()\",\n \"def clip(self, clip, s_entry, c_entry):\\n\\n # detect clip mode\\n unionmode = not s_entry and not c_entry\\n intersectionmode = s_entry and c_entry\\n differencemode = not s_entry and c_entry\\n\\n # prep by removing repeat of startpoint at end\\n first = self.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n first = clip.first\\n last = first.prev\\n if last.x == first.x and last.y == first.y:\\n first.prev = last.prev\\n last.prev.next = first\\n\\n # TODO: maybe also remove repeat points anywhere?\\n # ...\\n \\n # phase one - find intersections\\n # ------------------------------\\n anyintersection = False\\n s_intsecs = []\\n c_intsecs = []\\n for s in self.iter(): # for each vertex Si of subject polygon do\\n for c in clip.iter(): # for each vertex Cj of clip polygon do\\n try:\\n #print \\\"find isect %s - %s and %s - %s\\\" %(s.xy, self.next(s.next).xy, c.xy, clip.next(c.next).xy )\\n i, alphaS, alphaC = intersect_or_on(s, self.next(s.__next__),\\n c, clip.next(c.__next__))\\n \\n iS = Vertex(i, alphaS, intersect=True, entry=False)\\n iC = Vertex(i, alphaC, intersect=True, entry=False)\\n\\n iS.neighbour = iC\\n iC.neighbour = iS\\n \\n s_intsecs.append( (iS, alphaS, s, self.next(s.__next__)) )\\n c_intsecs.append( (iC, alphaC, c, clip.next(c.__next__)) )\\n \\n anyintersection = True\\n \\n except TypeError:\\n pass # this simply means intersect() returned None\\n\\n # insert intersections into originals\\n for iS,a,s,s_next in reversed(s_intsecs):\\n if a == 0:\\n self.replace(s, iS)\\n elif a == 1:\\n self.replace(s_next, iS)\\n else:\\n self.insert(iS, s, s_next)\\n for iC,a,c,c_next in reversed(c_intsecs):\\n if a == 0:\\n self.replace(c, iC)\\n elif a == 1:\\n self.replace(c_next, iC)\\n else:\\n clip.insert(iC, c, c_next)\\n\\n #print \\\"testing if insert was done correctly\\\"\\n for s in self.iter():\\n #print s\\n pass\\n #print \\\"and\\\"\\n for c in clip.iter():\\n #print c\\n pass\\n \\n\\n # phase one and a half - no intersections between subject and clip, so correctly return results\\n # --------------------\\n def specialcase_insidetest():\\n resultpolys = []\\n if unionmode: # union\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so just return subject shell\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so just return clip shell\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so return both\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif intersectionmode: # intersection\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the intersection is only the clip polygon\\n clipped = Polygon()\\n for c in clip.iter():\\n clipped.add(Vertex(c))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so the intersection is only the subject polygon\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n else:\\n #clip polygon is entirely outside subject, so no intersection to return\\n pass\\n elif differencemode: # difference\\n if clip.first.isInside(self):\\n # clip polygon is entirely inside subject, so the difference is subject with clip as a hole\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n hole = Polygon()\\n for c in clip.iter():\\n hole.add(Vertex(c))\\n polytuple = (clipped, [hole])\\n resultpolys.append(polytuple)\\n elif self.first.isInside(clip):\\n # subject polygon is entirely inside clip, so there is no difference\\n pass\\n else:\\n #clip polygon is entirely outside subject, so difference is simply the subject\\n clipped = Polygon()\\n for s in self.iter():\\n clipped.add(Vertex(s))\\n polytuple = (clipped, [])\\n resultpolys.append(polytuple)\\n # no need to continue so just return result\\n return resultpolys\\n \\n if not anyintersection: \\n return specialcase_insidetest()\\n\\n\\n\\n\\n\\n\\n\\n # phase two - identify entry/exit points\\n # --------------------------------------\\n\\n # From K&K\\n \\n def mark_flags(poly, c, c_entry):\\n \\\"c and c_entry are not actually the clip, can be for both s and c, just too lazy to change.\\\"\\n #print \\\"intersection\\\"\\n #print \\\"\\\\t\\\",c\\n # intersection is degenerate, is the start/endpoint of a line\\n # so maybe delete intersection flag based on prev/next locations\\n prevloc = testLocation(c.prev, poly)\\n nextloc = testLocation(c.__next__, poly)\\n if prevloc == \\\"on\\\" or nextloc == \\\"on\\\":\\n prevmid = Vertex(((c.x+c.prev.x)/2.0,(c.y+c.prev.y)/2.0))\\n prevloc = testLocation(prevmid, poly)\\n nextmid = Vertex(((c.x+c.next.x)/2.0,(c.y+c.next.y)/2.0))\\n nextloc = testLocation(nextmid, poly)\\n if prevloc == \\\"in\\\" or nextloc == \\\"in\\\":\\n poly.anyinside = True\\n #print \\\"\\\\t %s -> degenintsec -> %s\\\" %(prevloc,nextloc)\\n if prevloc == \\\"out\\\":\\n if nextloc == \\\"out\\\":\\n #just touching\\n c.entry = \\\"en/ex\\\" if c_entry else \\\"ex/en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n elif prevloc == \\\"in\\\":\\n #union and difference should never go inside the other polygon\\n #so this should only happen for intersectmode...\\n if nextloc == \\\"in\\\":\\n #just touching\\n c.entry = \\\"ex/en\\\" if c_entry else \\\"en/ex\\\"\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"on\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif prevloc == \\\"on\\\":\\n if nextloc == \\\"on\\\":\\n c.entry = None\\n elif nextloc == \\\"out\\\":\\n c.entry = \\\"ex\\\" if c_entry else \\\"en\\\"\\n elif nextloc == \\\"in\\\":\\n c.entry = \\\"en\\\" if c_entry else \\\"ex\\\"\\n\\n self.anyinside = False\\n\\n # set clip\\n prevsingle = None\\n for c in clip.iter():\\n if c.intersect:\\n mark_flags(self, c, c_entry)\\n # set couple\\n if c.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and c.entry == prevsingle.entry:\\n c.couple = prevsingle\\n prevsingle.couple = c\\n prevsingle = c\\n # set crosschange\\n # some modifications based on implementation in qt clipper source code\\n #if c.entry == \\\"en/ex\\\" == c.neighbour.entry or c.entry == \\\"ex/en\\\" == c.neighbour.entry:\\n if False: #c.entry == \\\"en/ex\\\" or c.entry == \\\"ex/en\\\":\\n print(\\\"Maybe crosschange...\\\")\\n # tri1\\n #a,b,c = c.neighbour.prev, c.prev, c.neighbour.next\\n a,b,c = c.neighbour.__next__, c.prev, c.neighbour.prev\\n dir1 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n # tri2\\n #a,b,c = c.neighbour.prev, c.prev, c.next\\n a,b,c = c.__next__, c.prev, c.neighbour.prev\\n dir2 = 0.5 * (a.x * (b.y-c.y) +\\n b.x * (c.y-a.y) +\\n c.x * (a.y-b.y))\\n print(dir1,dir2)\\n #if dir1 < 0 != dir2 < 0: # different orientation\\n if (dir1 * dir2) < 0: # different orientation means at least one negative, making the results less than 0\\n print(\\\"CROSSCHANGE!!!\\\")\\n c.cross_change = True\\n c.neighbour.cross_change = True # not sure if should set neighbour too\\n\\n # maybe early abort\\n if not self.anyinside and intersectionmode:\\n return []\\n\\n # what about perfect overlap???\\n # ...\\n\\n if False: #DEBUG:\\n print(\\\"view clip entries\\\")\\n for c in clip.iter():\\n print(c, c.entry)\\n\\n # find first isect where both neighbours have valid flag\\n for c in clip.iter():\\n if c.entry:\\n s = c.neighbour\\n mark_flags(clip, s, s_entry)\\n if s.entry:\\n first_c = c\\n first_s = s\\n # print 777,s.entry\\n break\\n\\n else:\\n return specialcase_insidetest()\\n #raise Exception(\\\"weird special case, no neighbours that both have flag left\\\")\\n \\n # autoset subj, if neighbour of first is different, then set all as opposite\\n # TODO: how deal with s_entry in case of different modes...?\\n print(\\\"view first\\\")\\n print(first_c, first_c.entry)\\n print(first_s, first_s.entry)\\n if first_c.entry != first_s.entry: # and s_entry: # this is the behaviour for standard intersect mode, otherwise flip, hence the s_entry\\n for c in clip.iter():\\n if c.entry:\\n if c.entry == \\\"en\\\": c.neighbour.entry = \\\"ex\\\"\\n elif c.entry == \\\"ex\\\": c.neighbour.entry = \\\"en\\\"\\n elif c.entry == \\\"en/ex\\\": c.neighbour.entry = \\\"ex/en\\\"\\n elif c.entry == \\\"ex/en\\\": c.neighbour.entry = \\\"en/ex\\\"\\n \\n # else set all same\\n else:\\n for c in clip.iter():\\n if c.entry:\\n c.neighbour.entry = c.entry\\n\\n # set couple for subj (not sure if needed)\\n prevsingle = None\\n for s in self.iter():\\n if s.entry:\\n if s.entry in (\\\"ex\\\",\\\"en\\\"):\\n if prevsingle and s.entry == prevsingle.entry:\\n s.couple = prevsingle\\n prevsingle.couple = s\\n prevsingle = s\\n\\n if False: #DEBUG: \\n print(\\\"view subj entries\\\")\\n for s in self.iter():\\n print(s, s.entry)\\n\\n\\n\\n\\n\\n # phase three - construct a list of clipped polygons\\n # --------------------------------------------------\\n\\n ######\\n # Defs\\n def next_unprocessed(vert):\\n origvert = vert\\n while vert:\\n if vert.entry and not (vert.checked or vert.neighbour.checked):\\n #print \\\"vert, found next unproc\\\", vert, vert.checked, vert.neighbour.checked\\n if vert.couple:\\n # rule 1\\n if vert.couple.entry and vert.entry:\\n # rule 2\\n if vert.couple.entry == \\\"en\\\" and vert.entry == \\\"en\\\":\\n return vert.couple\\n elif vert.couple.entry == \\\"ex\\\" and vert.entry == \\\"ex\\\":\\n return vert\\n # rule 3\\n else:\\n return vert\\n \\n vert = vert.__next__\\n \\n if vert == origvert:\\n # if returned to first, return None\\n return None\\n\\n def DeleteFlag1(cur, stat):\\n if cur.entry == \\\"en/ex\\\":\\n cur.entry = None\\n if cur.cross_change:\\n if stat == \\\"D3\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if stat == \\\"D3\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D3\\\":\\n cur.entry = \\\"en\\\"\\n return \\\"D2\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n return \\\"D1\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n return \\\"D1\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n return \\\"D2\\\"\\n\\n def DeleteFlag2(cur, prev, stat):\\n if cur.entry == \\\"en/ex\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"ex\\\"\\n else:\\n cur.entry = \\\"en\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex/en\\\":\\n if stat == \\\"D1\\\":\\n cur.entry = \\\"en\\\"\\n else:\\n cur.entry = \\\"ex\\\"\\n if cur.cross_change:\\n if stat == \\\"D1\\\":\\n return \\\"D4\\\"\\n else:\\n return \\\"D3\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"en\\\":\\n cur.entry = None\\n if stat == \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D1\\\"\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n if cur.entry == \\\"ex\\\":\\n cur.entry = None\\n if stat != \\\"D1\\\" and cur.couple and prev.couple == cur:\\n return \\\"D2\\\"\\n else:\\n if stat == \\\"D1\\\":\\n return \\\"D3\\\"\\n else:\\n return \\\"D4\\\"\\n\\n def proceed(cur, stat):\\n cur.checked = True\\n if stat == \\\"D1\\\":\\n clipped.add(Vertex(cur))\\n return cur.__next__\\n elif stat == \\\"D2\\\":\\n clipped.add(Vertex(cur))\\n return cur.prev\\n else:\\n return cur.neighbour\\n\\n ####\\n resultpolys = []\\n\\n self.first.checked = True\\n cur = prev = start = next_unprocessed(self.first)\\n\\n while cur:\\n # each new polygon\\n print(\\\"new poly\\\")\\n\\n stat = DeleteFlag1(cur, \\\"D3\\\")\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n clipped = Polygon()\\n cur = proceed(cur, stat)\\n\\n # collect vertexes\\n while cur != start:\\n if DEBUG: print(\\\"v\\\", cur, cur.entry, stat)\\n if cur.entry:\\n if stat == \\\"D1\\\" or stat == \\\"D2\\\":\\n stat = DeleteFlag2(cur, prev, stat)\\n else:\\n stat = DeleteFlag1(cur, stat)\\n prev = cur\\n cur = proceed(cur, stat)\\n\\n # return to first vertex\\n clipped.add(Vertex(clipped.first))\\n\\n print(clipped)\\n\\n resultpolys.append((clipped,[]))\\n cur = prev = start = next_unprocessed(self.first)\\n\\n\\n\\n # finally, sort into exteriors and holes\\n for pindex,(polyext,polyholes) in enumerate(resultpolys):\\n for otherext,otherholes in resultpolys:\\n if polyext == otherext:\\n continue # don't compare to self\\n if polyext.first.isInside(otherext):\\n otherholes.append(polyext) #poly is within other so make into a hole\\n del resultpolys[pindex] #and delete poly from being an independent poly\\n return resultpolys\",\n \"def _select_masks_to_boundaries(self, select_masks):\\n\\n def _merge(node_covers, select_idx):\\n \\\"\\\"\\\"\\n node_covers [[s1, e1], [s2, e2], ..., [sn, en]]\\n \\\"\\\"\\\"\\n new_node_covers = []\\n for i in range(len(node_covers) - 1):\\n if i == select_idx:\\n merge_node_boundary = [node_covers[select_idx][0], node_covers[select_idx + 1][1]]\\n new_node_covers.append(merge_node_boundary)\\n elif i < select_idx:\\n new_node_covers.append(node_covers[i])\\n else:\\n new_node_covers.append(node_covers[i + 1])\\n return new_node_covers, merge_node_boundary\\n batch_size = select_masks[0].size()[0]\\n max_length = select_masks[0].size()[1] + 1\\n combine_matrix = torch.rand(batch_size, max_length, 2).long()\\n for j in range(max_length):\\n combine_matrix[:, j, :] = j\\n results = []\\n for batch_idx in range(batch_size):\\n node_covers = combine_matrix[batch_idx, :, :].numpy().tolist()\\n result = []\\n for node_idx in range(max_length - 2):\\n select = select_masks[node_idx][batch_idx, :]\\n select_idx = torch.nonzero(select).data[0][0]\\n node_covers, merge_boundary = _merge(node_covers, select_idx)\\n result.append(merge_boundary)\\n results.append(result)\\n results = torch.LongTensor(results)\\n return results\",\n \"def merge_mesh(x1, ngroups1, conn1, mat_ids1, x2, ngroups2, conn2, mat_ids2,\\n cmap):\\n n1 = x1.shape[0]\\n n2 = x2.shape[0]\\n\\n err = nm.sum(nm.sum(nm.abs(x1[cmap[:,0],:-1] - x2[cmap[:,1],:-1])))\\n if abs(err) > (10.0 * eps):\\n raise ValueError('nonmatching meshes! (error: %e)' % err)\\n\\n mask = nm.ones((n2,), dtype=nm.int32)\\n mask[cmap[:,1]] = 0\\n remap = nm.cumsum(mask) + n1 - 1\\n remap[cmap[:,1]] = cmap[:,0]\\n\\n i2 = nm.setdiff1d(nm.arange( n2, dtype=nm.int32), cmap[:,1])\\n xx = nm.r_[x1, x2[i2]]\\n ngroups = nm.r_[ngroups1, ngroups2[i2]]\\n\\n conn = nm.vstack((conn1, remap[conn2]))\\n\\n mat_ids = None\\n if (mat_ids1 is not None) and (mat_ids2 is not None):\\n mat_ids = nm.concatenate((mat_ids1, mat_ids2))\\n\\n return xx, ngroups, conn, mat_ids\",\n \"def build_contacting(masks, r=1):\\n source_nodes = []\\n target_nodes = []\\n for i in range(1, masks.max()+1):\\n neigh = find_neighbors(masks, i, r=r)\\n source_nodes.append([i]*(neigh.size))\\n target_nodes.append(neigh)\\n # flatten arrays of arrays\\n source_nodes = np.fromiter(itertools.chain.from_iterable(source_nodes), int).reshape(-1,1)\\n target_nodes = np.fromiter(itertools.chain.from_iterable(target_nodes), int).reshape(-1,1)\\n # remove duplicate pairs\\n pairs = np.hstack((source_nodes, target_nodes))\\n pairs = remove_duplicate_pairs(pairs)\\n return pairs\",\n \"def find_original_contours(self):\\r\\n\\r\\n # Convert to gray, threshold and invert the image. Also save a thresholded but non-inverted image copy\\r\\n gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\\r\\n self.thresh_invert = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV,\\r\\n int(self.cell_size), 5)\\r\\n self.thresh_orig = 255 - self.thresh_invert\\r\\n\\r\\n # Find the contours of the image. Each contour should correspond to a cell\\r\\n orig_contours = cv2.findContours(self.thresh_invert, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\r\\n orig_contours = orig_contours[0] if len(orig_contours) == 2 else orig_contours[1]\\r\\n for block in orig_contours:\\r\\n area = cv2.contourArea(block)\\r\\n\\r\\n # If the contours are not too large, we draw them over the image to remove the digits in the grid\\r\\n if area < self.min_cell_size:\\r\\n cv2.drawContours(self.thresh_invert, [block], -1, (0, 0, 0), -1)\",\n \"def intrapop_connections(n_mitral, n_granule, n_subpop, n_mitral_per_subpop):\\n resmat = np.zeros((n_mitral, n_granule))\\n for i_subpop in xrange(n_subpop):\\n start = i_subpop*n_mitral_per_subpop\\n stop = start + n_mitral_per_subpop\\n resmat[start:stop, i_subpop] = 1.\\n return resmat\",\n \"def get_bundle_corner(\\n ports1: List[Port],\\n ports2: List[Port],\\n route_filter: Callable[..., Route] = get_route_from_waypoints,\\n separation: float = 5.0,\\n path_length_match_loops: int = None,\\n path_length_match_extra_length: float = 0.0,\\n path_length_match_modify_segment_i: int = -2,\\n **kwargs,\\n) -> List[Route]:\\n if \\\"straight\\\" in kwargs.keys():\\n _ = kwargs.pop(\\\"straight\\\")\\n\\n routes = _get_bundle_corner_waypoints(\\n ports1,\\n ports2,\\n routing_func=generate_manhattan_waypoints,\\n separation=separation,\\n **kwargs,\\n )\\n if path_length_match_loops:\\n routes = [np.array(route) for route in routes]\\n routes = path_length_matched_points(\\n routes,\\n extra_length=path_length_match_extra_length,\\n nb_loops=path_length_match_loops,\\n modify_segment_i=path_length_match_modify_segment_i,\\n **kwargs,\\n )\\n\\n return [route_filter(r, **kwargs) for r in routes]\",\n \"def __fcc_transition_diagonals(self) -> cq.cq.Workplane:\\n corner_points = self.unit_cell_size * np.array(\\n [(0, 0),\\n (1, 0),\\n (1, 0),\\n (1, 1),\\n (1, 1),\\n (0, 1)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_fcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": self.unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": 0,\\n \\\"angle_y\\\": 45},\\n {\\\"unit_cell_size\\\": self.unit_cell_size * 0.5,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": 0,\\n \\\"angle_y\\\": - 45},\\n {\\\"unit_cell_size\\\": self.unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": -45,\\n \\\"angle_y\\\": 0},\\n {\\\"unit_cell_size\\\": self.unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": 45,\\n \\\"angle_y\\\": 0},\\n {\\\"unit_cell_size\\\": self.unit_cell_size * 0.5,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": 0,\\n \\\"angle_y\\\": - 45},\\n {\\\"unit_cell_size\\\": self.unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": 0,\\n \\\"angle_y\\\": 45}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def segment_neighborhood(self, complexes, reactions):\\n\\t\\t\\t\\t\\n\\t\\t# First we initialize the graph variables that will be used for\\n\\t\\t# Tarjan's algorithm\\n\\t\\t\\n\\t\\tself._tarjan_index = 0\\n\\t\\tself._tarjan_stack = []\\n\\t\\tself._SCC_stack = []\\n\\n\\t\\t# Set up for Tarjan's algorithm\\n\\t\\tfor node in complexes:\\n\\t\\t\\tnode._outward_edges = []\\n\\t\\t\\tnode._full_outward_edges = []\\n\\t\\t\\tnode._index = -1\\n\\t\\tfor reaction in reactions:\\n\\t\\t\\tfor product in reaction.products:\\n\\t\\t\\t\\tproduct._outward_edges = []\\n\\t\\t\\t\\tproduct._full_outward_edges = []\\n\\t\\t\\t\\tproduct._index = -1\\n\\t\\t\\t\\t\\n\\t\\t# Detect which products are actually in the neighborhood\\t\\n\\t\\tfor reaction in reactions:\\n\\t\\t\\tfor product in reaction.products:\\n\\t\\t\\t\\tproduct_in_N = False\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tfor complex in complexes:\\n\\t\\t\\t\\t\\tif (complex == product):\\n\\t\\t\\t\\t\\t\\tproduct_in_N = True\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# If this product is in the neighborhood, we have an edge\\n\\t\\t\\t\\tif product_in_N:\\n\\t\\t\\t\\t\\t# We know all these reactions are unimolecular\\n\\t\\t\\t\\t\\treaction.reactants[0]._outward_edges.append(product)\\n\\t\\t\\t\\treaction.reactants[0]._full_outward_edges += (reaction.products)\\n\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tnode._lowlink = -1\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t# We now perform Tarjan's algorithm, marking nodes as appropriate\\n\\t\\tfor node in complexes:\\n\\t\\t\\tif node._index == -1:\\n\\t\\t\\t\\tself.tarjans(node)\\n\\t\\t\\n\\t\\t# Now check to see which of the SCCs are resting states\\n\\t\\tresting_states = []\\n\\t\\tresting_state_complexes = []\\n\\t\\ttransient_state_complexes = []\\n\\t\\tfor scc in self._SCC_stack:\\n\\t\\t\\tscc_products = []\\n\\t\\t\\tis_resting_state = True\\n\\t\\t\\t\\n\\t\\t\\tfor node in scc:\\n\\t\\t\\t\\tfor product in node._full_outward_edges:\\n\\t\\t\\t\\t\\tscc_products.append(product)\\n\\t\\t\\t\\n\\t\\t\\tfor product in scc_products:\\n\\t\\t\\t\\tproduct_in_scc = False\\n\\t\\t\\t\\tfor complex in scc:\\n\\t\\t\\t\\t\\tif product == complex:\\n\\t\\t\\t\\t\\t\\tproduct_in_scc = True\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# If the product is not in the SCC, then there is a fast edge\\n\\t\\t\\t\\t# leading out of the SCC, so this is not a resting state\\n\\t\\t\\t\\tif not product_in_scc:\\n\\t\\t\\t\\t\\tis_resting_state = False\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\n\\t\\t\\tif is_resting_state:\\n\\t\\t\\t\\tresting_state_complexes += (scc)\\n\\t\\t\\t\\tresting_state = RestingState(self.get_auto_name(), scc[:])\\n\\t\\t\\t\\tresting_states.append(resting_state)\\n\\t\\t\\t\\t\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttransient_state_complexes += (scc)\\n\\t\\tresting_states.sort()\\n\\t\\tresting_state_complexes.sort()\\n\\t\\ttransient_state_complexes.sort()\\n\\t\\treturn {\\n\\t\\t\\t\\t'resting_states': resting_states, \\n\\t\\t\\t 'resting_state_complexes': resting_state_complexes,\\n\\t\\t\\t\\t'transient_state_complexes': transient_state_complexes\\n\\t\\t\\t\\t}\",\n \"def fix_double_nodes(coor, ngroups, conns):\\n n_nod, dim = coor.shape\\n cmap = find_map(coor, nm.zeros((0,dim)), allow_double=True)\\n if cmap.size:\\n output('double nodes in input mesh!')\\n output('trying to fix...')\\n\\n while cmap.size:\\n # Just like in Variable.equation_mapping()...\\n ii = nm.argsort(cmap[:,1])\\n scmap = cmap[ii]\\n\\n eq = nm.arange(n_nod)\\n eq[scmap[:,1]] = -1\\n eqi = eq[eq >= 0]\\n eq[eqi] = nm.arange(eqi.shape[0])\\n remap = eq.copy()\\n remap[scmap[:,1]] = eq[scmap[:,0]]\\n output(coor.shape)\\n coor = coor[eqi]\\n ngroups = ngroups[eqi]\\n output(coor.shape)\\n ccs = []\\n for conn in conns:\\n ccs.append(remap[conn])\\n conns = ccs\\n cmap = find_map(coor, nm.zeros((0,dim)), allow_double=True)\\n output('...done')\\n return coor, ngroups, conns\",\n \"def new_decomposition(self):\\n from sage.combinat.binary_tree import BinaryTree\\n t_low = self.lower_binary_tree().to_tilting()\\n t_up = self.upper_binary_tree().to_tilting()\\n common = [p for p in t_low if p in t_up]\\n\\n def extract_tree(x, y, tilt, common):\\n \\\"\\\"\\\"\\n Extract a tree with root at position xy (recursive).\\n \\\"\\\"\\\"\\n left_tree = None\\n for k in range(y - 1, x, -1):\\n if (x, k) in tilt:\\n if (x, k) not in common:\\n left_tree = extract_tree(x, k, tilt, common)\\n break\\n right_tree = None\\n for k in range(x + 1, y):\\n if (k, y) in tilt:\\n if (k, y) not in common:\\n right_tree = extract_tree(k, y, tilt, common)\\n break\\n return BinaryTree([left_tree, right_tree])\\n\\n TIP = self.parent()\\n return [TIP.from_binary_trees(extract_tree(cx, cy, t_low, common),\\n extract_tree(cx, cy, t_up, common))\\n for cx, cy in common]\",\n \"def Compare2dMasksFrom3dMasks(OrigSegRoi, NewSegRoi, OrigDicomDir, NewDicomDir): \\n \\n from DicomTools import GetDicomSOPuids\\n from SegTools import GetPFFGStoSliceInds\\n import matplotlib.pyplot as plt\\n \\n # Get the DICOM SOP UIDs:\\n OrigSOPuids = GetDicomSOPuids(DicomDir=OrigDicomDir)\\n NewSOPuids = GetDicomSOPuids(DicomDir=NewDicomDir)\\n \\n # Get the Per-frameFunctionalGroupsSequence-to-slice indices:\\n OrigPFFGStoSliceInds = GetPFFGStoSliceInds(OrigSegRoi, OrigSOPuids)\\n NewPFFGStoSliceInds = GetPFFGStoSliceInds(NewSegRoi, NewSOPuids)\\n \\n # Combined indices from OrigPFFGStoSliceInds and NewPFFGStoSliceInds:\\n AllInds = OrigPFFGStoSliceInds + NewPFFGStoSliceInds\\n \\n # Remove duplicates:\\n AllInds = list(set(AllInds))\\n \\n \\n # Get the 3D SEG masks:\\n Orig3dMask = OrigSegRoi.pixel_array\\n New3dMask = NewSegRoi.pixel_array\\n \\n OrigShape = Orig3dMask.shape\\n NewShape = New3dMask.shape\\n \\n print(f'Segments exist in OrigSegRoi on slices {OrigPFFGStoSliceInds}')\\n print(f'Shape of Orig3dMask = {OrigShape}')\\n print(f'\\\\nSegments exist in NewSegRoi on slices {NewPFFGStoSliceInds}')\\n print(f'Shape of New3dMask = {NewShape}\\\\n')\\n \\n # Initialise the 3D cropped SEG masks:\\n Orig3dMaskCropped = []\\n New3dMaskCropped = []\\n \\n for i in range(OrigShape[0]):\\n cropped = CropNonZerosIn2dMask(Orig3dMask[i])\\n \\n Orig3dMaskCropped.append(cropped)\\n \\n for i in range(NewShape[0]):\\n cropped = CropNonZerosIn2dMask(New3dMask[i])\\n \\n New3dMaskCropped.append(cropped)\\n \\n \\n Nrows = len(AllInds)\\n \\n Ncols = 2\\n \\n n = 1 # initialised sub-plot number\\n \\n fig, ax = plt.subplots(Nrows, Ncols, figsize=(5*Ncols, 6*Nrows))\\n \\n for i in range(len(AllInds)):\\n SliceNum = AllInds[i]\\n \\n # Does slice SliceNum have a segment in OrigSegRoi or NewSegRoi?\\n if SliceNum in OrigPFFGStoSliceInds:\\n OrigFrameNum = OrigPFFGStoSliceInds.index(SliceNum)\\n \\n ax = plt.subplot(Nrows, Ncols, n, aspect='equal')\\n ax.imshow(Orig3dMaskCropped[OrigFrameNum])\\n ax.set_xlabel('Pixels'); ax.set_ylabel('Pixels')\\n ax.set_title(f'Orig slice {SliceNum}')\\n \\n n += 1 # increment sub-plot number\\n \\n if SliceNum in NewPFFGStoSliceInds:\\n NewFrameNum = NewPFFGStoSliceInds.index(SliceNum)\\n \\n ax = plt.subplot(Nrows, Ncols, n, aspect='equal')\\n ax.imshow(New3dMaskCropped[NewFrameNum])\\n ax.set_xlabel('Pixels'); ax.set_ylabel('Pixels')\\n ax.set_title(f'New slice {SliceNum}')\\n \\n n += 1 # increment sub-plot number\\n \\n return\",\n \"def double_crossover(self, original1, original2):\\n point1=self.r.uniform(0.1,0.3)\\n point2=self.r.uniform(0.6,0.8)\\n len1=len(original1)\\n len2=len(original2)\\n cut11=int(point1*len1)\\n cut12=int(point2*len1)\\n cut21=int(point1*len2)\\n cut22=int(point2*len2)\\n child1=original1[:cut11]+original2[cut21:cut22]+original1[cut12:]\\n child2=original2[:cut21]+original1[cut11:cut12]+original2[cut22:]\\n return child1, child2\",\n \"def group_connected(triggers):\\n groups = []\\n ungrouped = set((x, y, difficulty) for (x, y), difficulty in triggers.items())\\n while ungrouped:\\n x, y, difficulty = ungrouped.pop()\\n pos = x, y\\n locs = [pos]\\n queue = [pos]\\n while queue:\\n pos = queue.pop()\\n for x, y in HexGrid.neighbours(pos):\\n if (x, y, difficulty) in ungrouped:\\n ungrouped.discard((x, y, difficulty))\\n c = x, y\\n locs.append(c)\\n queue.append(c)\\n groups.append(TriggerArea(locs, difficulty))\\n\\n groups_by_loc = {}\\n for g in groups:\\n for l in g.locs:\\n groups_by_loc[l] = g\\n return groups, groups_by_loc\",\n \"def cluster_contours(device, img, roi_objects, nrow=1, ncol=1, debug=None):\\n\\n device += 1\\n\\n if len(np.shape(img)) == 3:\\n iy, ix, iz = np.shape(img)\\n else:\\n iy, ix, = np.shape(img)\\n\\n # get the break groups\\n\\n if nrow == 1:\\n rbreaks = [0, iy]\\n else:\\n rstep = np.rint(iy / nrow)\\n rstep1 = np.int(rstep)\\n rbreaks = range(0, iy, rstep1)\\n if ncol == 1:\\n cbreaks = [0, ix]\\n else:\\n cstep = np.rint(ix / ncol)\\n cstep1 = np.int(cstep)\\n cbreaks = range(0, ix, cstep1)\\n\\n # categorize what bin the center of mass of each contour\\n\\n def digitize(a, step):\\n if isinstance(step, int) == True:\\n i = step\\n else:\\n i = len(step)\\n for x in range(0, i):\\n if x == 0:\\n if a >= 0 and a < step[x + 1]:\\n return x + 1\\n elif a >= step[x - 1] and a < step[x]:\\n return x\\n elif a > step[x - 1] and a > np.max(step):\\n return i\\n\\n dtype = [('cx', int), ('cy', int), ('rowbin', int), ('colbin', int), ('index', int)]\\n coord = []\\n for i in range(0, len(roi_objects)):\\n m = cv2.moments(roi_objects[i])\\n if m['m00'] == 0:\\n pass\\n else:\\n cx = int(m['m10'] / m['m00'])\\n cy = int(m['m01'] / m['m00'])\\n # colbin = np.digitize(cx, cbreaks)\\n # rowbin = np.digitize(cy, rbreaks)\\n colbin = digitize(cx, cbreaks)\\n rowbin = digitize(cy, rbreaks)\\n a = (cx, cy, colbin, rowbin, i)\\n coord.append(a)\\n coord1 = np.array(coord, dtype=dtype)\\n coord2 = np.sort(coord1, order=('colbin', 'rowbin'))\\n\\n # get the list of unique coordinates and group the contours with the same bin coordinates\\n\\n groups = []\\n for i, y in enumerate(coord2):\\n col = y[3]\\n row = y[2]\\n location = str(row) + ',' + str(col)\\n groups.append(location)\\n\\n unigroup = np.unique(groups)\\n coordgroups = []\\n\\n for i, y in enumerate(unigroup):\\n col = int(y[0])\\n row = int(y[2])\\n for a, b in enumerate(coord2):\\n if b[2] == col and b[3] == row:\\n grp = i\\n contour = b[4]\\n coordgroups.append((grp, contour))\\n else:\\n pass\\n\\n coordlist = [[y[1] for y in coordgroups if y[0] == x] for x in range(0, (len(unigroup)))]\\n\\n contours = roi_objects\\n grouped_contour_indexes = coordlist\\n\\n # Debug image is rainbow printed contours\\n\\n if debug == 'print':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n print_image(img_copy, (str(device) + '_clusters.png'))\\n\\n elif debug == 'plot':\\n if len(np.shape(img)) == 3:\\n img_copy = np.copy(img)\\n else:\\n iy, ix = np.shape(img)\\n img_copy = np.zeros((iy, ix, 3), dtype=np.uint8)\\n\\n rand_color = color_palette(len(coordlist))\\n for i, x in enumerate(coordlist):\\n for a in x:\\n cv2.drawContours(img_copy, roi_objects, a, rand_color[i], -1, lineType=8)\\n plot_image(img_copy)\\n\\n return device, grouped_contour_indexes, contours\",\n \"def innerProd(linearCombo1, linearCombo2):\\n innerProd = 0\\n # TODO: I'm starting with simple sets on both sides, not sum of sets, \\n # with coefficient 1. We need to fix this later\\n # TODO: find way to represent dashed vs undashed arrows\\n # For now, assume both are already sums (sets) of dashed subdiagrams\\n\\n # copy linear combinations to make it easier to alter them as needed\\n linearComboCopy1 = deepcopy(linearCombo1)\\n linearComboCopy2 = deepcopy(linearCombo2)\\n print len(linearComboCopy2[0][1])\\n\\n # get list of subdiagrams, get coefficients\\n for coeffAndSubdiagrams1 in linearComboCopy1:\\n subdiagramSet1 = coeffAndSubdiagrams1[1]\\n coeff1 = coeffAndSubdiagrams1[0]\\n subdiagramsToRemove1 = []\\n\\n for coeffAndSubdiagrams2 in linearComboCopy2:\\n subdiagramSet2 = coeffAndSubdiagrams2[1]\\n coeff2 = coeffAndSubdiagrams2[0]\\n subdiagramsToRemove2 = []\\n\\n # look for equivalent pairs of dashed subdiagrams in both lists\\n for subdiagram1 in subdiagramSet1:\\n for subdiagram2 in subdiagramSet2: \\n # for equivalent pairs of dashed subdiagrams, increment innerProd by \\n # product of coefficients and remove the subdiagrams to avoid \\n # over-counting diagrams\\n if equiv(subdiagram1, subdiagram2):\\n innerProd += coeff1 * coeff2\\n subdiagramsToRemove1.append(subdiagram1)\\n subdiagramsToRemove2.append(subdiagram2)\\n print \\\" \\\", innerProd\\n # remove the used subdiagrams\\n # print \\\"sub 2\\\\t\\\" + str(subdiagramSet2)\\n # print \\\" 2 \\\" + str(subdiagramsToRemove2)\\n # print \\\" 1 \\\" + str(subdiagramsToRemove1)\\n for removal2 in subdiagramsToRemove2:\\n # print \\\" remove \\\" + str(removal2)\\n subdiagramSet2.remove(removal2)\\n subdiagramsToRemove2 = []\\n # for removal1 in subdiagramsToRemove1:\\n # subdiagramSet1.remove(removal1) \\n return innerProd\",\n \"def remove_adjacent_grid(self, pg1, pg2, adj_grids):\\n\\n if pg1.size()>pg2.size():\\n bigger = pg1\\n smaller = pg2\\n else:\\n bigger = pg2\\n smaller = pg1\\n \\n for adj in adj_grids:\\n \\n\\n # If the adjacent grids are a subset of the secondary grids (i.e. not necessary)\\n # remove them from each\\n if adj in bigger.secondary_grids:\\n debug.info(3,\\\"Removing {} from bigger secondary {}\\\".format(adj, bigger))\\n bigger.grids.remove(adj)\\n bigger.secondary_grids.remove(adj)\\n self.blocked_grids.add(adj)\\n elif adj in smaller.secondary_grids:\\n debug.info(3,\\\"Removing {} from smaller secondary {}\\\".format(adj, smaller))\\n smaller.grids.remove(adj)\\n smaller.secondary_grids.remove(adj)\\n self.blocked_grids.add(adj)\\n else:\\n # If we couldn't remove from a secondary grid, we must remove from the primary\\n # grid of at least one pin\\n if adj in bigger.grids:\\n debug.info(3,\\\"Removing {} from bigger primary {}\\\".format(adj, bigger))\\n bigger.grids.remove(adj)\\n elif adj in smaller.grids:\\n debug.info(3,\\\"Removing {} from smaller primary {}\\\".format(adj, smaller))\\n smaller.grids.remove(adj)\",\n \"def box_ciou(boxes1, boxes2):\\n area1 = box_area(boxes1)\\n area2 = box_area(boxes2)\\n\\n lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2]\\n rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2]\\n\\n wh = (rb - lt).clamp(min=0) # [N,M,2]\\n inter = wh[:, :, 0] * wh[:, :, 1] # [N,M]\\n\\n # Calculate the diagonal length of the smallest bbox covering the 2 boxes\\n clt=torch.min(boxes1[:, None, :2], boxes2[:, :2])\\n crb=torch.max(boxes1[:, None, 2:], boxes2[:, 2:])\\n outer_diag=((crb-clt)**2).sum(dim=2)\\n # Calculate the euclidean distance between central points of boxes1 and boxes2\\n center_x1=(boxes1[:, None, 0] + boxes1[:, None, 2])/2\\n center_y1=(boxes1[:, None, 1] + boxes1[:, None, 3])/2\\n center_x2=(boxes2[:, None, 0] + boxes2[:, None, 2])/2\\n center_y2=(boxes2[:, None, 1] + boxes2[:, None, 3])/2\\n inner_diag=(center_x1-center_x2.t())**2 + (center_y1-center_y2.t())**2\\n union = area1[:, None] + area2 - inter\\n # Aspect ratio parameter\\n w1 = boxes1[:, 2] - boxes1[:, 0]\\n h1 = boxes1[:, 3] - boxes1[:, 1]\\n w2 = boxes2[:, 2] - boxes2[:, 0]\\n h2 = boxes2[:, 3] - boxes2[:, 1]\\n v = (4 / (math.pi**2)) * torch.square((torch.atan(w2/h2) - torch.atan(w1/h1)))\\n # Trade-off parameter\\n alpha = v / (1- inter/union + v)\\n # Calculate ciou\\n cious = inter/union - (inner_diag/outer_diag + alpha*v)\\n cious = torch.clamp(cious, min=-1.0, max = 1.0)\\n return cious\",\n \"def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\\n orderOfSCsByValueByFrame = [\\n cellNetworkList[i].orderOfSubContoursDict for i in range(len(watershed))\\n ]\\n return scListByFrame, orderOfSCsByValueByFrame\",\n \"def sweep_CPPN(genotype, E1, subp_1, subp_2, norm_in, canvas):\\n\\n\\t# get value from widget field\\n\\tinnov_num = E1.get()\\n\\n\\t# find index of desired connection\\n\\tindex = -1\\n\\tfor con_ind in range(len(genotype.connections)):\\n\\t\\tif(genotype.connections[con_ind].getInnovationNumber() == innov_num):\\n\\t\\t\\tindex = con_ind\\n\\told_weight = genotype.connections[con_ind].getWeight()\\n\\n\\tsweep_weight = 10\\n\\twhile(sweep_weight > -10):\\n\\t\\tgenotype.connections[con_ind].setWeight(sweep_weight)\\n\\t\\t# clear both subplots so new graphs can be placed into the GUI\\n\\t\\tsubp_1.clear()\\n\\t\\tsubp_2.clear()\\n\\n\\t\\t# create graphs again and put graphs onto them\\n\\t\\toutputs = []\\n\\t\\tfor ins in norm_in:\\n\\t\\t\\toutputs.append(genotype.getOutput(ins)[0])\\n\\t\\toutputs_np = np.array(outputs, copy=True)\\n\\t\\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\\n\\n\\t\\tgraph_genotype_GUI(genotype, subp_2)\\n\\n\\t\\tcanvas.show()\\n\\t\\tcanvas.get_tk_widget().pack()\\n\\t\\tsweep_weight -= .5\\n\\t\\ttime.sleep(TIME_DELAY)\\n\\n\\t# reset the graphs to their old state with the original weight\\n\\tgenotype.connections[con_ind].setWeight(old_weight)\\n\\t# clear both subplots so new graphs can be placed into the GUI\\n\\tsubp_1.clear()\\n\\tsubp_2.clear()\\n\\n\\t# create graphs again and put graphs onto them\\n\\toutputs = []\\n\\tfor ins in norm_in:\\n\\t\\toutputs.append(genotype.getOutput(ins)[0])\\n\\toutputs_np = np.array(outputs, copy=True)\\n\\tsubp_1.imshow(np.reshape(outputs_np, (num_x, num_y)), cmap='Greys')\\n\\n\\tgraph_genotype_GUI(genotype, subp_2)\\n\\n\\tcanvas.show()\\n\\tcanvas.get_tk_widget().pack()\",\n \"def _build_adjacency_matrix_2(self):\\n\\n from scipy import sparse as sparse\\n \\n down_neighbour = np.empty(self.tri.npoints)\\n down_neighbour1 = np.empty(self.tri.npoints)\\n\\n for node in range (0,self.tri.npoints):\\n down_neighbour[node] = self.neighbour_array_lo_hi[node][0]\\n down_neighbour1[node] = self.neighbour_array_lo_hi[node][1]\\n\\n # Build a matrix of downhill-ness - one entry per node ! \\n \\n size = self.tri.npoints\\n row_array = np.empty(size)\\n col_array = np.empty(size)\\n down_array = np.ones(size)\\n\\n # Catch cases where node is local low point (i.e. it is its own low neighbour)\\n for row in range(0, self.tri.npoints): \\n row_array[row] = row\\n col_array[row] = down_neighbour1[row]\\n if row == down_neighbour[row]:\\n down_array[row] = 0.0 \\n if row == down_neighbour1[row]:\\n col_array[row] = down_neighbour[row]\\n\\n\\n downMCOO = sparse.coo_matrix( (down_array, (row_array, col_array)), shape=(size,size) ).T \\n self.adjacency2 = downMCOO.tocsr() \\n\\n # Catch pathological cases - sometimes if there is a flat spot on the boundary, then \\n # the filling method above will produce a non-square matrix. This is caused by\\n # repetition of values in the COO list which are summed on conversion.\\n\\n if downMCOO.shape[0] != downMCOO.shape[1]:\\n # This approach works but is a lot slower\\n\\n print \\\"\\\"\\\"\\n Warning: the downhill matrices require a slow build method. This is probably\\n Because there are degeneracies in the slope - particularly at the boundaries\\n A small random perturbation is usually enough to fix this problem\\n \\\"\\\"\\\"\\n downMat = sparse.lil_matrix((size, size))\\n\\n for row in range(0, self.tri.npoints): \\n downMat[down_neighbour[row],row] = 1.0\\n\\n for row in range(0, self.tri.npoints): \\n if row == down_neighbour[row] or row == down_neighbour1[row]:\\n downMat[row,row] = 0.0\\n \\n self.adjacency2 = downMat.T.tocsr() \\n\\n return\",\n \"def mark_contours(contour_arr, img, symmetry, _plot=False):\\n marg, flag = 7, 0\\n # fig, ax = plt.subplots()\\n # ax.imshow(img, cmap=\\\"gray\\\")\\n sub_images = [] # init array for pictures\\n for contour in contour_arr:\\n\\n lower_dim = contour[:, 0]\\n x, y = lower_dim[:, 0], lower_dim[:, 1]\\n min_x, min_y, max_x, max_y = min(x), min(y), max(x), max(y)\\n\\n # remove small noise\\n if (max_x - min_x) * (max_y - min_y) < MIN_IMG_SIZE:\\n continue\\n # avoid index error\\n if min_x - marg < 0 or min_y - marg < 0 or max_y + marg > img.shape[0] or max_x + marg > img.shape[1]:\\n marg = 0\\n # crop only half cause image is symmetric:\\n # TODO: address different types of symmetry as input from user\\n if symmetry == HORIZONTAL:\\n if max_x <= img.shape[1] // 2:\\n sub_images.append(img[min_y:max_y, min_x:max_x])\\n flag = 1\\n else: # symmetry is around the X-axis\\n if max_y <= img.shape[0] // 2:\\n sub_images.append(img[min_y:max_y, min_x:max_x])\\n flag = 1\\n if _plot and flag:\\n ax.plot([min_x - marg, max_x + marg, max_x + marg, min_x - marg, min_x - marg],\\n [min_y - marg, min_y - marg, max_y + marg, max_y + marg, min_y - marg], c='r', linewidth=0.4)\\n flag = 0\\n if _plot:\\n plt.savefig(\\\"found_subshapes2.jpg\\\")\\n # plt.show()\\n return sub_images\",\n \"def subdivideMesh(IKLE,MESHX,MESHY): \\n # ~~> Singling out edges\\n from matplotlib.tri import Triangulation\\n edges = Triangulation(MESHX,MESHY,IKLE).get_cpp_triangulation().get_edges()\\n \\n # ~~> Memory allocation for new MESH\\n IELEM = len(IKLE); IPOIN = len(MESHX); IEDGE = len(edges)\\n JKLE = np.zeros((IELEM*4,3),dtype=np.int) # you subdivide every elements by 4\\n MESHJ = np.zeros((IEDGE,2),dtype=np.int) # you add one point on every edges\\n \\n # ~~> Lookup tables for node numbering on common edges\\n pa,pb = edges.T\\n k1b,k1a = np.sort(np.take(IKLE,[0,1],axis=1)).T\\n indx1 = np.searchsorted(pa,k1a)\\n jndx1 = np.searchsorted(pa,k1a,side='right')\\n k2b,k2a = np.sort(np.take(IKLE,[1,2],axis=1)).T\\n indx2 = np.searchsorted(pa,k2a)\\n jndx2 = np.searchsorted(pa,k2a,side='right')\\n k3b,k3a = np.sort(np.take(IKLE,[2,0],axis=1)).T\\n indx3 = np.searchsorted(pa,k3a)\\n jndx3 = np.searchsorted(pa,k3a,side='right')\\n \\n # ~~> Building one triangle at a time /!\\\\ Please get this loop parallelised\\n j = 0\\n for i in range(IELEM):\\n k1 = indx1[i]+np.searchsorted(pb[indx1[i]:jndx1[i]],k1b[i])\\n k2 = indx2[i]+np.searchsorted(pb[indx2[i]:jndx2[i]],k2b[i])\\n k3 = indx3[i]+np.searchsorted(pb[indx3[i]:jndx3[i]],k3b[i])\\n # ~~> New connectivity JKLE\\n JKLE[j] = [IKLE[i][0],IPOIN+k1,IPOIN+k3]\\n JKLE[j+1] = [IKLE[i][1],IPOIN+k2,IPOIN+k1]\\n JKLE[j+2] = [IKLE[i][2],IPOIN+k3,IPOIN+k2]\\n JKLE[j+3] = [IPOIN+k1,IPOIN+k2,IPOIN+k3]\\n # ~~> New interpolation references for values and coordinates\\n MESHJ[k1] = [IKLE[i][0],IKLE[i][1]]\\n MESHJ[k2] = [IKLE[i][1],IKLE[i][2]]\\n MESHJ[k3] = [IKLE[i][2],IKLE[i][0]]\\n j += 4\\n\\n # ~~> Reset IPOBO while you are at it\\n MESHX = np.resize(MESHX,IPOIN+IEDGE)\\n MESHY = np.resize(MESHY,IPOIN+IEDGE)\\n MESHX[IPOIN:] = np.sum(MESHX[MESHJ],axis=1)/2.\\n MESHY[IPOIN:] = np.sum(MESHY[MESHJ],axis=1)/2.\\n neighbours = Triangulation(MESHX,MESHY,JKLE).get_cpp_triangulation().get_neighbors()\\n JPOBO = np.zeros(IPOIN+IEDGE,np.int)\\n for n in range(IELEM*4):\\n s1,s2,s3 = neighbours[n]\\n e1,e2,e3 = JKLE[n]\\n if s1 < 0:\\n JPOBO[e1] = e1+1\\n JPOBO[e2] = e2+1\\n if s2 < 0:\\n JPOBO[e2] = e2+1\\n JPOBO[e3] = e3+1\\n if s3 < 0:\\n JPOBO[e3] = e3+1\\n JPOBO[e1] = e1+1\\n\\n return JKLE,MESHX,MESHY,JPOBO,MESHJ\",\n \"def get_groups(board: numpy.ndarray, player: int) -> List[Group]:\\n # Generate couples\\n # Array of (p1, p2, x) where x = -1 if p1 == p2, 0 if p1 and p2 are close and 1 if they are close\\n couples = []\\n size = board.shape[0]\\n for i in range(1, size - 1):\\n for j in range(1, size - 1):\\n if board[i, j] == player:\\n l0 = [(i + x, j + y) for x, y in NEIGHBORS_1]\\n l1 = [(i + x, j + y) for x, y in NEIGHBORS_2]\\n for p in l0 + l1 + [(i, j)]:\\n corner = all([x in [0, size - 1] for x in p])\\n if 0 <= p[0] < size and 0 <= p[1] < size and board[p] == player and not corner:\\n if p == (i, j):\\n couples.append(((i, j), p, -1))\\n elif p in l0:\\n couples.append(((i, j), p, 0))\\n else:\\n p1, p2 = get_common_neighbours((i, j), p)\\n if player not in [board[p1], board[p2]] and (board[p1] == -1 and board[p2] == -1):\\n couples.append(((i, j), p, 1))\\n\\n # Group couples\\n groups = [[k] for k in couples]\\n\\n def fusion(f_groups):\\n for group1 in f_groups:\\n for group2 in f_groups:\\n if group1 != group2:\\n for c1 in group1:\\n for c2 in group2:\\n if c1[0] == c2[0] or c1[0] == c2[1] or c1[1] == c2[0] or c1[1] == c2[1]:\\n group1.extend(group2)\\n f_groups.remove(group2)\\n return True\\n return False\\n\\n while fusion(groups):\\n pass\\n\\n return groups\",\n \"def assign(self, points, gt_bboxes, gt_contours, sizes):\\n num_gts, num_points = gt_contours.shape[0], points.shape[0]\\n\\n if num_points == 0 or num_gts == 0:\\n # stores the assigned gt heatmap of each point\\n assigned_gt_ct = points.new_ones((num_points,), dtype=torch.long)\\n # stores the assigned gt dist (to this point) of each point\\n assigned_gt_offsets = points.new_zeros((num_points, 2), dtype=torch.float32)\\n pos_inds = torch.nonzero(assigned_gt_ct == 0, as_tuple=False).squeeze(-1).unique()\\n neg_inds = torch.nonzero(assigned_gt_ct > 0, as_tuple=False).squeeze(-1).unique()\\n\\n return assigned_gt_ct, assigned_gt_offsets, pos_inds, neg_inds\\n\\n points_range = torch.arange(num_points)\\n points_xy = points[:, :2]\\n points_stride = points[:, 2]\\n points_lvl = torch.log2(points_stride).int() # [3...,4...,5...,6...,7...]\\n lvl_min, lvl_max = points_lvl.min(), points_lvl.max()\\n\\n # stores the assigned gt heatmap of each point\\n assigned_gt_ct = points.new_ones((num_points,), dtype=torch.long)\\n # stores the assigned gt dist (to this point) of each point\\n assigned_gt_offsets = points.new_zeros((num_points, 2), dtype=torch.float32)\\n\\n lvls = torch.arange(lvl_min, lvl_max + 1, dtype=points_lvl.dtype, device=points_lvl.device)\\n for gt_lvl in lvls:\\n lvl_size = sizes[gt_lvl - 3]\\n\\n lvl_idx = gt_lvl == points_lvl\\n points_index = points_range[lvl_idx]\\n\\n # generate contours\\n downscale_factor = torch.pow(2, gt_lvl)\\n\\n f_lvl_contours_pts_x = (gt_contours[:, 0] / downscale_factor).clamp_(max=lvl_size[1] - 1)\\n lvl_contours_pts_x = torch.round(f_lvl_contours_pts_x)\\n f_lvl_contours_pts_y = (gt_contours[:, 1] / downscale_factor).clamp_(max=lvl_size[0] - 1)\\n lvl_contours_pts_y = torch.round(f_lvl_contours_pts_y)\\n lvl_indices = (lvl_contours_pts_x + lvl_contours_pts_y * lvl_size[1]).to(torch.long)\\n\\n points_index = points_index[lvl_indices]\\n\\n assigned_gt_offsets[points_index, 0] = f_lvl_contours_pts_x - lvl_contours_pts_x\\n assigned_gt_offsets[points_index, 1] = f_lvl_contours_pts_y - lvl_contours_pts_y\\n\\n assigned_gt_ct[points_index] = 0\\n\\n pos_inds = torch.nonzero(assigned_gt_ct == 0, as_tuple=False).squeeze(-1).unique()\\n neg_inds = torch.nonzero(assigned_gt_ct > 0, as_tuple=False).squeeze(-1).unique()\\n\\n return assigned_gt_ct, assigned_gt_offsets, pos_inds, neg_inds\",\n \"def single_crossover(self, original1, original2):\\n point=self.r.uniform(0.1,0.6)\\n cut1=int(point*len(original1))\\n cut2=int(point*len(original2))\\n child1=original1[:cut1]+original2[cut2:]\\n child2=original2[:cut2]+original1[cut1:]\\n return child1, child2\",\n \"def plot_links_2d_intra(epo1: mne.Epochs, epo2: mne.Epochs,\\n C1: np.ndarray, C2: np.ndarray,\\n threshold: str='auto', steps: int=2):\\n\\n # extract sensor infos and transform loc to fit with headmodel\\n loc1 = copy(np.array([ch['loc'][:3] for ch in epo1.info['chs']]))\\n loc1 = transform_2d_intra(loc1, traX=-0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\\n\\n loc2 = copy(np.array([ch['loc'][:3] for ch in epo2.info['chs']]))\\n loc2 = transform_2d_intra(loc2, traX=0.178, traY=0.012, traZ=0, rotZ=(-np.pi/2))\\n\\n ctr1 = np.nanmean(loc1, 0)\\n ctr2 = np.nanmean(loc2, 0)\\n \\n # Calculate vmin and vmax for colormap as min and max [C1, C2]\\n Cmax1=np.nanmax(C1[:])\\n Cmax2=np.nanmax(C2[:])\\n Cmax=[]\\n Cmax=[Cmax1, Cmax2]\\n vmax=np.nanmax(Cmax)\\n Cmin1=np.nanmin(C1[:])\\n Cmin2=np.nanmin(C2[:])\\n Cmin=[]\\n Cmin=[Cmin1, Cmin2]\\n vmin=np.min(Cmin)\\n\\n # Calculate automatic threshold\\n if threshold == 'auto':\\n threshold = np.max([np.median(C1, 0),np.median(C2,0)])+np.max([np.std(C1, 0),np.std(C2, 0)])\\n else:\\n threshold = threshold\\n \\n\\n # Define colormap for both participant\\n cmap_p = matplotlib.cm.get_cmap('Reds')\\n norm_p = matplotlib.colors.Normalize(vmin=threshold, vmax=vmax)\\n cmap_n = matplotlib.cm.get_cmap('Blues_r')\\n norm_n = matplotlib.colors.Normalize(vmin=vmin, vmax=-threshold)\\n\\n # plot links\\n for e1 in range(len(loc1)):\\n x1 = loc1[e1, 0]\\n y1 = loc1[e1, 1]\\n for e2 in range(len(loc1)):\\n x2 = loc1[e2, 0]\\n y2 = loc1[e2, 1]\\n if C1[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n plt.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n plt.plot([xn, xnn], [yn, ynn],\\n '-', color=color_p, linewidth=weight)\\n if C1[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C1[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n plt.plot([loc1[e1, 0], loc1[e2, 0]],\\n [loc1[e1, 1], loc1[e2, 1]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C1[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr1[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr1[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr1[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr1[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr1[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr1[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr1[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr1[1]) +\\n b**3 * y2)\\n plt.plot([xn, xnn], [yn, ynn],\\n '-', color=color_n, linewidth=weight)\\n\\n for e1 in range(len(loc2)):\\n x1 = loc2[e1, 0]\\n y1 = loc2[e1, 1]\\n for e2 in range(len(loc2)):\\n x2 = loc2[e2, 0]\\n y2 = loc2[e2, 1]\\n if C2[e1, e2] >= threshold:\\n color_p = cmap_p(norm_p(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n plt.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n '-', color=color_p, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n plt.plot([xn, xnn], [yn, ynn],\\n '-', color=color_p, linewidth=weight)\\n if C2[e1, e2] <= -threshold:\\n color_n = cmap_n(norm_n(C2[e1, e2]))\\n if steps <= 2:\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n plt.plot([loc2[e1, 0], loc2[e2, 0]],\\n [loc2[e1, 1], loc2[e2, 1]],\\n '-', color=color_n, linewidth=weight)\\n else:\\n alphas = np.linspace(0, 1, steps)\\n weight = 0.2 +1.6*((-C2[e1, e2]-threshold)/(np.nanmax(vmax-threshold)))\\n for idx in range(len(alphas)-1):\\n a = alphas[idx]\\n b = alphas[idx+1]\\n xn = ((1-a)**3 * x1 +\\n 3 * (1-a)**2 * a * (2 * x1 - ctr2[0]) +\\n 3 * (1-a) * a**2 * (2 * x2 - ctr2[0]) +\\n a**3 * x2)\\n xnn = ((1-b)**3 * x1 +\\n 3 * (1-b)**2 * b * (2 * x1 - ctr2[0]) +\\n 3 * (1-b) * b**2 * (2 * x2 - ctr2[0]) +\\n b**3 * x2)\\n yn = ((1-a)**3 * y1 +\\n 3 * (1-a)**2 * a * (2 * y1 - ctr2[1]) +\\n 3 * (1-a) * a**2 * (2 * y2 - ctr2[1]) +\\n a**3 * y2)\\n ynn = ((1-b)**3 * y1 +\\n 3 * (1-b)**2 * b * (2 * y1 - ctr2[1]) +\\n 3 * (1-b) * b**2 * (2 * y2 - ctr2[1]) +\\n b**3 * y2)\\n plt.plot([xn, xnn], [yn, ynn],\\n '-', color=color_n, linewidth=weight)\",\n \"def test_1_1_2D_cube_init(self): # TODO: REMOVE FUNC AFTER SPLIT\\n check = [(0, 0), (1, 1), (1, 0), (0, 1), (0.5, 0.5)]\\n\\n nn_checks = {(0.5, 0.5): [(0, 1), (1, 0), (0, 0), (1, 1)],\\n (0, 1): [(0, 0), (1, 1), (0.5, 0.5)]}\\n\\n init_triangulation(2, 0, check, nn_checks)\",\n \"def cross_junctions(I, bounds, Wpts):\\n #--- FILL ME IN ---\\n\\n Ipts = np.zeros((2, 48))\\n\\n#parameters\\n alpha = 0.15 #typically 0.04 to 0.06\\n threshold = 1500 #default 2000\\n sigma = 2\\n ws = 12 #window size for saddle point\\n\\n#building Harris Detecter\\n I = I/255.0\\n gradx, grady = np.gradient(I)\\n IxIx = gaussian_filter(gradx*gradx,sigma)\\n IxIy = gaussian_filter(gradx*grady,sigma)\\n IyIy = gaussian_filter(grady*grady,sigma)\\n print(I.shape)\\n\\n #get harris score\\n cand_score = []\\n cand_index = []\\n cand = []\\n s_cand = []\\n\\n for j in range(len(I)):\\n for i in range(len(I[0])):\\n a11 = IxIx[j][i]\\n a12 = IxIy[j][i]\\n a21 = a12\\n a22 = IyIy[j][i]\\n A = np.array([[a11, a12],[a21, a22]])\\n ev0, ev1 = np.linalg.eigvals(A)\\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\\n cand_score.append(-h_score)\\n cand_index.append([i, j])\\n\\n #get the coordinates of the top 5000 scores\\n sorted_ind = np.argsort(cand_score)\\n sorted_score = np.sort(cand_score).tolist()\\n\\n for ind in sorted_ind[:threshold]:\\n cand.append(cand_index[ind])\\n s_cand = sorted_score[:threshold]\\n\\n\\n#clustering\\n #using homography to project candidate points to a up-front view\\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\\n H = dlt_homography(bounds, new_bbox)\\n cand = np.array(cand).T\\n cand = np.vstack((cand, np.ones(cand.shape[1])))\\n Ho_cand = np.matmul(H,cand).T\\n for pt in Ho_cand:\\n pt[0] = pt[0]/pt[2]\\n pt[1] = pt[1]/pt[2]\\n Ho_cand = Ho_cand[:,:2]\\n Ho_cand = Ho_cand.tolist()\\n\\n #get rid of points that are not in the boundry\\n temp_Ho_cand = []\\n temp_s_cand = []\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\\n continue\\n else:\\n temp_Ho_cand.append(pt)\\n temp_s_cand.append(s_cand[i])\\n Ho_cand = np.array(temp_Ho_cand)\\n s_cand = temp_s_cand\\n #divide candidates into clusters\\n assignment = []\\n assignment_score = []\\n\\n #first put in the point that has the highest score\\n assignment.append([Ho_cand[0]])\\n assignment_score.append([s_cand[0]])\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n if min(dist) > 6:\\n assignment.append([pt])\\n assignment_score.append([s_cand[i]])\\n\\n assignment = np.array(assignment)\\n\\n #assign points to clusters\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\\n continue\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n index = np.argsort(dist)[-1]\\n np.append(assignment[index], pt)\\n assignment_score[index].append(s_cand[i])\\n\\n #get centroids for each cluster\\n Ho_centroids = []\\n for i in range(len(assignment)):\\n cl = assignment[i]\\n cl = np.array(cl)\\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\\n assignment_score[i] = sum(assignment_score[i])\\n\\n print(len(assignment_score))\\n\\n Ho_centroids = np.array(Ho_centroids)\\n #get rid of edge points\\n\\n xmin = np.amin(Ho_centroids.T[0])\\n xmax = np.amax(Ho_centroids.T[0]) \\n ymin = np.amin(Ho_centroids.T[1])\\n ymax = np.amax(Ho_centroids.T[1])\\n\\n final_cand = []\\n final_score = []\\n for i in range(len(Ho_centroids)):\\n pt = Ho_centroids[i]\\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\\n continue\\n else:\\n final_cand.append(pt)\\n final_score.append(assignment_score[i])\\n print(\\\"Number of corner found: \\\")\\n print(len(final_cand))\\n\\n #get rid of fake corners\\n if (len(final_cand)>48):\\n ultimate_cand =[]\\n for ind in np.argsort(final_score)[:48]:\\n ultimate_cand.append(final_cand[ind])\\n final_cand = ultimate_cand\\n print(\\\"real corners count:\\\", len(ultimate_cand))\\n\\n\\n #sort the points\\n final_cand = np.array(final_cand)\\n y_sort_ind = np.argsort(final_cand.T[1])\\n final_cand = final_cand.tolist()\\n rows = []\\n for i in range(6):\\n row = []\\n for ind in y_sort_ind[i*8:(i+1)*8]:\\n row.append(final_cand[ind])\\n rows.append(row)\\n\\n ordered = []\\n for row in rows:\\n r = []\\n x_sort_ind = np.argsort(np.array(row).T[0])\\n for ind in x_sort_ind:\\n r.append(row[ind])\\n ordered.append(r)\\n\\n final_cand = []\\n for row in ordered:\\n for pt in row:\\n final_cand.append(pt)\\n \\n\\n\\n #get coordinates of the centroids in the original frame\\n Ho_centroids = np.array(final_cand)\\n\\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\\n centroids = np.matmul(np.linalg.inv(H), centroids).T\\n for pt in centroids:\\n pt[0] = int(pt[0]/pt[2])\\n pt[1] = int(pt[1]/pt[2])\\n centroids = centroids[:,:2]\\n\\n#finding saddle points around the centroids\\n saddle_points = []\\n for pt in centroids:\\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\\n saddle = saddle_point(img)\\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\\n saddle_points.append(saddle)\\n\\n saddle_points = np.array(saddle_points)\\n #------------------\\n print(saddle_points.T)\\n return saddle_points.T\",\n \"def plot_contour_overlay(I1, I2, contour_level, minval, maxval):\\n if I1.shape != I2.shape:\\n raise ValueError(\\\"I1 and I2 must have the same shape\\\")\\n if not skimage_imported:\\n raise ImportError(\\\"skimage not found\\\")\\n \\n contours = find_contours(gaussian_filter(I1, 1), contour_level)\\n \\n fig = figure()\\n ax = fig.gca()\\n \\n I2 = I2.copy()\\n I2[I2 < minval] = nan\\n I2[I2 > maxval] = maxval\\n \\n im = ax.imshow(I2, vmin=minval, vmax=maxval, cmap=cm.gray)\\n for ct in contours:\\n ax.plot(ct[:, 1], ct[:, 0], linewidth=2.0, linestyle=\\\"-\\\", color='r')\\n \\n fig.colorbar(im)\\n \\n ax.set_xlim(0, size(I1, 1))\\n ax.set_ylim(size(I1, 0), 0)\\n ax.set_xticks([])\\n ax.set_yticks([])\\n \\n return fig\",\n \"def intersectConics(E1, E2):\\n\\n P = np.array([])\\n r1 = matrix_rank(E1)\\n r2 = matrix_rank(E2)\\n \\n if(r1==3 and r2==3):\\n P = completeIntersection(E1,E2) \\n else:\\n if (r2 < 3): #E2 is degenerate\\n defE = E2\\n fullE = E1\\n else:\\n defE = E1 #E1 is degenerate\\n fullE = E2\\n m, l = decomposeDegenerateConic(defE)\\n P1 = intersectConicLine(fullE,m)\\n P2 = intersectConicLine(fullE,l)\\n P = np.array([P1, P2])\\n points_x = []\\n points_y = []\\n for i in range(2):\\n P1 = P[i]\\n if(P1.size!=0):\\n for j in range(P1.shape[0]):\\n points_x.append(P1[j,0]/P1[j,2])\\n points_y.append(P1[j,1]/P1[j,2])\\n return points_x, points_y\",\n \"def test_split_outer_multipolygon_way_2():\\n data = cache_query(ways=[15001, 15002], deps=True)\\n assert data['ways']['15001']['relations'].keys() == ['15001']\\n assert data['ways']['15002']['relations'].keys() == ['15001']\\n\\n assert query_row(db_conf, 'osm_landusages', 15001) == None\\n park_15001 = query_row(db_conf, 'osm_landusages', -15001)\\n assert park_15001['type'] == 'park'\\n assert_almost_equal(park_15001['geometry'].area, 9816216452, -1)\\n assert query_row(db_conf, 'osm_roads', 15002)['type'] == 'residential'\",\n \"def clusters_connected( self):\\n def check_connected( k, vertices, edges):\\n dads = {}\\n for p in vertices:\\n dads[p] = p\\n\\n def Find( c):\\n while c != dads[c]:\\n c = dads[c]\\n return c\\n\\n def Union( p, q):\\n dads[Find(p)] = Find(q)\\n\\n for p,q in edges:\\n Union( p, q)\\n\\n stuff = set([ Find(p) for (k,p) in dads.items()])\\n assert len(stuff) == 1, \\\"More than one partition\\\"\\n\\n vertices = collections.defaultdict( list)\\n for p in itertools.product( range(self.n), repeat=2):\\n vertices[self.raster[p]].append( p)\\n\\n def X():\\n for x in range(self.n-1):\\n for y in range(self.n):\\n yield (x,y),(x+1,y)\\n\\n def Y():\\n for x in range(self.n):\\n for y in range(self.n-1):\\n yield (x,y),(x,y+1)\\n\\n connections = collections.defaultdict( list)\\n for (p,q) in itertools.chain( X(), Y()):\\n if self.raster[p] == self.raster[q]:\\n connections[self.raster[p]].append( ( p, q))\\n\\n for (k,v) in vertices.items():\\n check_connected( k, v, connections[k])\",\n \"def ISOMAPEmbbeding(TurosR=10,Torusr=4,Classes=[3,5,7],nei=[5,10,20], DataSet = {'Turos', 'Digits'}):\\n\\n S, dig = CreateDS_Torus_Digits(TurosR=TurosR,Torusr=Torusr,Classes=[3,5,7])\\n ### ------ Isomap ------###\\n nei = nei\\n\\n if 'Turos' in DataSet:\\n # Ploting Torus Isomapping\\n fig = plt.figure(figsize=(30, 10))\\n for i, j in enumerate(nei):\\n Torus_isomap = Isomap(S, 2, j)\\n neighbors = j\\n method = 'Torus ISOMAP'\\n ax = fig.add_subplot(1, len(nei), i + 1)\\n scatter = ax.scatter(Torus_isomap[:, 0], Torus_isomap[:, 1], c=S[:, 0:1], cmap=plt.cm.Spectral)\\n # legend = ax.legend(*scatter.legend_elements(), loc=\\\"lower left\\\", title=\\\"Classes\\\")\\n # ax.add_artist(legend)\\n # ax.legend()\\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\\n # making_plot(Torus_isomap, pallete=S[:, 0:1], neighbors=j, method='Torus ISOMAP') #An option to plot single graphs\\n plt.savefig('Torus ISOMAP embbeding for {} neighbour'.format(nei))\\n\\n if 'Digits' in DataSet:\\n # Plotting Digits Isomapping\\n for Argclass, Specificcalss in enumerate(dig):\\n fig = plt.figure(figsize=(30, 10))\\n for i, j in enumerate(nei):\\n neighbors = j\\n Digit_isomap = Isomap(Specificcalss[0], 2, j)\\n method = 'Digit ISOMAP'\\n ax = fig.add_subplot(1, len(nei), i + 1)\\n scatter = ax.scatter(Digit_isomap[:, 0], Digit_isomap[:, 1], c=Specificcalss[1], cmap=plt.cm.Spectral)\\n legend = ax.legend(*scatter.legend_elements(), loc=\\\"lower left\\\", title=\\\"Classes\\\")\\n ax.add_artist(legend)\\n ax.legend()\\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\\n # making_plot(Digit_isomap, Specificcalss[1], neighbors=j, method='Digit ISOMAP') #An option to plot single graphs\\n plt.savefig('Digits up to {} - ISOMAP embbeding for {} neighbour'.format(Classes[Argclass], nei))\",\n \"def test_rebulding_zpf_boundary_sets_regions():\\n\\n compsets_298 = CompsetPair([\\n BinaryCompset('P1', 298.15, 'B', 0.5, [0.5, 0.5]),\\n BinaryCompset('P2', 298.15, 'B', 0.8, [0.2, 0.8]),\\n ])\\n\\n compsets_310 = CompsetPair([\\n BinaryCompset('P1', 310, 'B', 0.5, [0.5, 0.5]),\\n BinaryCompset('P2', 310, 'B', 0.8, [0.2, 0.8]),\\n ])\\n\\n compsets_300_diff_phases = CompsetPair([\\n BinaryCompset('P2', 300, 'B', 0.5, [0.5, 0.5]),\\n BinaryCompset('P3', 300, 'B', 0.8, [0.2, 0.8]),\\n ])\\n\\n zpfbs = ZPFBoundarySets(['A', 'B'], v.X('B'))\\n\\n # Initial compsets\\n zpfbs.add_compsets(compsets_298)\\n assert len(zpfbs.all_compsets) == 1\\n assert len(zpfbs.two_phase_regions) == 1\\n\\n # Compsets added create a new region because phases changed\\n zpfbs.add_compsets(compsets_300_diff_phases)\\n assert len(zpfbs.all_compsets) == 2\\n assert len(zpfbs.two_phase_regions) == 2\\n\\n # Compsets added create a new region because phases the temperature is out of tolerance\\n zpfbs.add_compsets(compsets_310)\\n assert len(zpfbs.all_compsets) == 3\\n assert len(zpfbs.two_phase_regions) == 3\\n\\n # Rebuild the regions with a larger tolerance should create two regions with one and two compsets.\\n zpfbs.rebuild_two_phase_regions(Ttol=20)\\n assert len(zpfbs.all_compsets) == 3\\n assert len(zpfbs.two_phase_regions) == 2\\n assert sorted([len(tpr.compsets) for tpr in zpfbs.two_phase_regions]) == [1, 2]\",\n \"def __bcc_top_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def test_two_layer_equi_group1(self):\\n print('Test equivariance for a chiral net with two layers')\\n batch_size = 2\\n time_size = 5\\n num_joints = 3\\n in_dim = 2\\n out_dim = 3\\n neg_dim_in = 1\\n neg_dim_out = 1\\n sym_groupings = ([1, 1, 1], [1, 1, 1])\\n\\n # Generate chiral pairs.\\n x, x_chiral = self._get_input_pairs(batch_size, time_size, num_joints,\\n in_dim, neg_dim_in, sym_groupings)\\n\\n # Reshape to joints and dim to a column vector.\\n x = x.view(x.shape[0], -1, x.shape[-1])\\n x_chiral = x_chiral.view(x.shape[0], -1, x.shape[-1])\\n\\n chiral_conv1 = ChiralConv1d(in_dim*num_joints, out_dim*num_joints,\\n kernel_size=3,\\n sym_groupings=sym_groupings,\\n neg_dim_in=neg_dim_in,\\n neg_dim_out=neg_dim_out)\\n\\n chiral_conv2 = ChiralConv1d(out_dim*num_joints, out_dim*num_joints,\\n kernel_size=3,\\n sym_groupings=sym_groupings,\\n neg_dim_in=neg_dim_in,\\n neg_dim_out=neg_dim_out)\\n\\n # Build a simple two layer network.\\n y = chiral_conv2(torch.tanh(chiral_conv1(x)))\\n y_chiral = chiral_conv2(torch.tanh(chiral_conv1(x_chiral)))\\n\\n # Reshape back to joints, dim representation.\\n y = y.view(y.shape[0], num_joints, -1, y.shape[-1])\\n y_chiral = y_chiral.view(y.shape[0], num_joints, -1, y.shape[-1])\\n\\n # Compare output.\\n self._checks_chiral_equivariant(y, y_chiral, num_joints, out_dim,\\n neg_dim_out, sym_groupings[1])\",\n \"def make_maps_of_2x1_pix_coordinates (sp) : \\n x_rhs = np.arange(sp.colsh)*sp.pixs + sp.pixw - sp.pixsh\\n x_rhs[0] = sp.pixwh # set x-coordinate of the wide pixel \\n x_arr = np.hstack([-x_rhs[::-1],x_rhs])\\n\\n y_arr = np.arange(sp.rows) * sp.pixs\\n y_arr -= y_arr[-1]/2 # move origin to the center of array\\n\\n sp.x_map2x1, sp.y_map2x1 = np.meshgrid(x_arr, y_arr)\",\n \"def unique_combos(self, background_strains, foreground_strains):\\n elem_intervals = self.make_elementary_intervals(\\n [self.sample_dict[sn][0] for sn in background_strains + foreground_strains])\\n background = self.build_pairwise_matrix(background_strains, elem_intervals)\\n foreground = self.build_pairwise_matrix(foreground_strains, elem_intervals)\\n output = []\\n uniquities = np.logical_and(foreground == len(foreground_strains), np.logical_not(background))\\n for combo in xrange(subspecies.NUM_SUBSPECIES**2):\\n combo_uniquities = np.where(uniquities[combo])\\n combo_color = subspecies.to_color(combo, ordinal=True)\\n for i, j in zip(combo_uniquities[0], combo_uniquities[1]):\\n output.append([\\n # proximal interval start, end\\n elem_intervals[i - 1],\\n elem_intervals[i],\\n # distal interval start, end\\n elem_intervals[j - 1],\\n elem_intervals[j],\\n combo_color\\n ])\\n return output\",\n \"def add_boundaries(self):\\n\\n bound_conns=[]\\n bound_coords=[]\\n bound_vert_index=[]\\n throat_vert_index=[]\\n #Find boundary extent\\n [x_min,x_max,y_min,y_max,z_min,z_max]=vo.vertex_dimension(self,self.pores(),parm='minmax')\\n min_point = np.around(np.array([x_min,y_min,z_min]),10)\\n max_point = np.around(np.array([x_max,y_max,z_max]),10)\\n Np = self.num_pores()\\n Nt = self.num_throats()\\n new_throat_count = 0\\n # ridge_dict contains a dictionary where the key is a set of 2 neighbouring pores and the value is the vertex indices\\n # that form the throat or ridge between them\\n for p,v in self._vor.ridge_dict.items():\\n # if the vertex with index -1 is contained in list then the ridge is unbounded - ignore these\\n if np.all(np.asarray(v) >=0):\\n #boundary throats will be those connecting one pore inside the original set and one out\\n if (p[0] in range(Np) and p[1] not in range(Np)) or\\\\\\n (p[0] not in range(Np) and p[1] in range(Np)):\\n # the dictionary key is not in numerical order so find the pore index inside\\n if p[0] in range(Np):\\n my_pore=p[0]\\n else:\\n my_pore=p[1]\\n my_pore_coord = self[\\\"pore.coords\\\"][my_pore]\\n new_pore_coord = my_pore_coord.copy()\\n #rounding necessary here to identify the plane as Voronoi can have 1e-17 and smaller errors\\n throat_verts = np.around(self._vor.vertices[v],10)\\n #find which plane we are aligned with (if any) and align new_pore with throat plane\\n if len(np.unique(throat_verts[:,0])) == 1:\\n new_pore_coord[0]=np.unique(throat_verts[:,0])\\n elif len(np.unique(throat_verts[:,1])) == 1:\\n new_pore_coord[1]=np.unique(throat_verts[:,1])\\n elif len(np.unique(throat_verts[:,2])) == 1:\\n new_pore_coord[2]=np.unique(throat_verts[:,2])\\n else:\\n new_pore_coord = throat_verts.mean()\\n bound_coords.append(new_pore_coord)\\n bound_conns.append(np.array([my_pore,new_throat_count+Np]))\\n bound_vert_index.append(dict(zip(v,throat_verts)))\\n throat_vert_index.append(dict(zip(v,throat_verts)))\\n new_throat_count += 1\\n\\n #Add new pores and connections\\n self.extend(pore_coords=bound_coords, throat_conns=bound_conns)\\n #Record new number of pores\\n Mp = self.num_pores()\\n Mt = self.num_throats()\\n new_pore_ids = np.arange(Np,Mp)\\n new_throat_ids = np.arange(Nt,Mt)\\n #Identify which boundary the pore sits on\\n front = self.pores()[self['pore.coords'][:,0]==min_point[0]]\\n back = self.pores()[self['pore.coords'][:,0]==max_point[0]]\\n left = self.pores()[self['pore.coords'][:,1]==min_point[1]]\\n right = self.pores()[self['pore.coords'][:,1]==max_point[1]]\\n bottom = self.pores()[self['pore.coords'][:,2]==min_point[2]]\\n top = self.pores()[self['pore.coords'][:,2]==max_point[2]]\\n #Assign labels\\n self['pore.boundary'] = False\\n self['pore.boundary'][new_pore_ids] = True\\n self['pore.right_boundary'] = False\\n self['pore.left_boundary'] = False\\n self['pore.front_boundary'] = False\\n self['pore.back_boundary'] = False\\n self['pore.top_boundary'] = False\\n self['pore.bottom_boundary'] = False\\n self['pore.right_boundary'][right] = True\\n self['pore.left_boundary'][left] = True\\n self['pore.front_boundary'][front] = True\\n self['pore.back_boundary'][back] = True\\n self['pore.top_boundary'][top] = True\\n self['pore.bottom_boundary'][bottom] = True\\n #Save the throat verts\\n self[\\\"pore.vert_index\\\"][new_pore_ids] = bound_vert_index\\n self[\\\"throat.vert_index\\\"][new_throat_ids] = throat_vert_index\",\n \"def test_broken_multipolygon_ways():\\n # outer way does not merge (17002 has one node)\\n assert query_row(db_conf, 'osm_landusages', -17001) == None\\n assert query_row(db_conf, 'osm_roads', 17001)['type'] == 'residential'\\n assert query_row(db_conf, 'osm_roads', 17002) == None\\n\\n # outer way does not merge (17102 has no nodes)\\n assert query_row(db_conf, 'osm_landusages', -17101) == None\\n assert query_row(db_conf, 'osm_roads', 17101)['type'] == 'residential'\\n assert query_row(db_conf, 'osm_roads', 17102) == None\",\n \"def candidate_map(self):\\n candidates = [[set(range(1, 10)) for _dummy in range(9)] for _dummy in range(9)]\\n vertex_value_unknown = [[True for _dummy in range(9)] for _dummy in range(9)]\\n for (line, row) in [(ln, rw) for ln in range(9) for rw in range(9)]:\\n if self.grid[line][row] in range(1, 10):\\n candidates[line][row] = set([self.grid[line][row]])\\n vertex_value_unknown[line][row] = False\\n for i in range(9):\\n if i != row:\\n candidates[line][i].discard(self.grid[line][row])\\n if i != line:\\n candidates[i][row].discard(self.grid[line][row])\\n if line - line%3 + i//3 != line or row - row%3 + i%3 != row:\\n candidates[line - line%3 + i//3][row - row%3 + i%3].discard(self.grid[line][row])\\n # Further reduce candidate map\\n reduce_cadidate_map_further = True\\n while reduce_cadidate_map_further:\\n reduce_cadidate_map_further = False\\n total_number_of_candidates = sum([len(candidates[ln][rw]) for ln in range(9) for rw in range(9)])\\n for number in range(1, 10):\\n for i in range(9):\\n # Check for single possible vertex for *number* in candidate map line *i*\\n seen_in_j = []\\n for j in range(9):\\n if number in candidates[i][j]:\\n seen_in_j.append(j)\\n if len(seen_in_j) == 1 and vertex_value_unknown[i][seen_in_j[0]]:\\n candidates[i][seen_in_j[0]] = set([number])\\n vertex_value_unknown[i][seen_in_j[0]] = False\\n # Discard other candidates for *number* in corresponding row and subsquare\\n for j in range(9):\\n if j != i:\\n candidates[j][seen_in_j[0]].discard(number)\\n if i - i%3 + j//3 != i:\\n candidates[i - i%3 + j//3][seen_in_j[0] - seen_in_j[0]%3 + j%3].discard(number)\\n # otherwise add check wheter all candidates for *number* are in the same subsquare\\n elif 1 < len(seen_in_j) < 4:\\n subsquares = set()\\n for j in seen_in_j:\\n subsquares.add(3*(i//3) + j//3)\\n if len(subsquares) == 1:\\n subsquare = subsquares.pop()\\n for j in range(9):\\n if 3*(subsquare//3) + j//3 != i:\\n candidates[3*(subsquare//3) + j//3][3*(subsquare%3) + j%3].discard(number)\\n # Check for single possible vertex for *number* in candidate map row *i*\\n seen_in_j = []\\n for j in range(9):\\n if number in candidates[j][i]:\\n seen_in_j.append(j)\\n if len(seen_in_j) == 1 and vertex_value_unknown[seen_in_j[0]][i]:\\n candidates[seen_in_j[0]][i] = set([number])\\n vertex_value_unknown[seen_in_j[0]][i] = False\\n # Discard other candidates for *number* in corresponding line and subsquare\\n for j in range(9):\\n if j != i:\\n candidates[seen_in_j[0]][j].discard(number)\\n if i - i%3 + j%3 != i:\\n candidates[seen_in_j[0] - seen_in_j[0]%3 + j//3][i - i%3 + j%3].discard(number)\\n # otherwise add check wheter all candidates for *number* are in the same subsquare\\n elif 1 < len(seen_in_j) < 4:\\n subsquares = set()\\n for j in seen_in_j:\\n subsquares.add(3*(j//3) + i//3)\\n if len(subsquares) == 1:\\n subsquare = subsquares.pop()\\n for j in range(9):\\n if 3*(subsquare%3) + j%3 != i:\\n candidates[3*(subsquare//3) + j//3][3*(subsquare%3) + j%3].discard(number)\\n # Check for single possible vertex for *number* in candidate map subsquare *i*\\n seen_in_j = []\\n for j in range(9):\\n if number in candidates[3*(i//3) + j//3][3*(i%3) + j%3]:\\n seen_in_j.append(j)\\n if len(seen_in_j) == 1 and vertex_value_unknown[3*(i//3) + seen_in_j[0]//3][3*(i%3) + seen_in_j[0]%3]:\\n candidates[3*(i//3) + seen_in_j[0]//3][3*(i%3) + seen_in_j[0]%3] = set([number])\\n vertex_value_unknown[3*(i//3) + seen_in_j[0]//3][3*(i%3) + seen_in_j[0]%3] = False\\n # Discard other candidates for *number* in corresponding line and row\\n for j in range(9):\\n if j not in [3*(i%3), 3*(i%3) + 1, 3*(i%3) + 2]:\\n candidates[3*(i//3) + seen_in_j[0]//3][j].discard(number)\\n if j not in [3*(i//3), 3*(i//3) + 1, 3*(i//3) + 2]:\\n candidates[j][3*(i%3) + seen_in_j[0]%3].discard(number)\\n # otherwise add check wheter all candidates for *number* are in the same line/row\\n elif 1 < len(seen_in_j) < 4:\\n lines = set()\\n rows = set()\\n for j in seen_in_j:\\n lines.add(3*(i//3) + j//3)\\n rows.add(3*(i%3) + j%3)\\n if len(lines) == 1:\\n line = lines.pop()\\n for row in [rw for rw in range(9) if rw not in [3*(i%3), 3*(i%3) + 1, 3*(i%3) + 2]]:\\n candidates[line][row].discard(number)\\n elif len(rows) == 1:\\n row = rows.pop()\\n for line in [ln for ln in range(9) if ln not in [3*(i//3), 3*(i//3) + 1, 3*(i//3) + 2]]:\\n candidates[line][row].discard(number)\\n if sum([len(candidates[ln][rw]) for ln in range(9) for rw in range(9)]) < total_number_of_candidates:\\n reduce_cadidate_map_further = True\\n return candidates\",\n \"def getContours(image, copyImage):\\n contours, heirarchy = cv.findContours(image, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE)\\n for contour in contours:\\n area = cv.contourArea(contour)\\n \\n if area > 500.0:\\n cv.drawContours(copyImage, contour, -1, (255,0,0),3)\\n perimeter = cv.arcLength(contour, True)\\n \\n # Approximates to the nearest polygon\\n approx = cv.approxPolyDP(contour,0.02*perimeter, True)\\n objectCoordinates = len(approx)\\n\\n # Returns the x, y and height width of the polygon\\n x, y, w, h = cv.boundingRect(approx)\\n\\n if objectCoordinates == 3:\\n objectShape = \\\"Triangle\\\"\\n elif objectCoordinates == 4:\\n ratio = w / float(h)\\n if ratio >= 0.95 and ratio <= 1.05:\\n objectShape = \\\"Square\\\"\\n else: objectShape = \\\"Rectangle\\\"\\n else: objectShape = \\\"Circle\\\" \\n\\n \\n\\n # Draw rectangles around the images\\n cv.rectangle(copyImage, (x,y), (x+w, y+h), (0,255,0), 2)\\n cv.putText(copyImage, objectShape, (x + (w//2), y + (h//2)),cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))\",\n \"def testMergeCollectionsCCCParentWithDuplicates(self):\\n # Now we have the same color decisions in both node and node2\\n self.node.color_decisions = self.node2.color_decisions\\n\\n merged = self.node.merge_collections([self.node2])\\n\\n self.assertEqual(\\n self.node.desc + self.node2.desc,\\n merged.desc\\n )\\n self.assertEqual(\\n self.node.input_desc,\\n merged.input_desc\\n )\\n self.assertEqual(\\n self.node.viewing_desc,\\n merged.viewing_desc\\n )\\n # We'll just check the length\\n self.assertEqual(\\n len(set(self.node.all_children + self.node2.all_children)),\\n len(merged.all_children)\\n )\\n self.assertEqual(\\n self.node.type,\\n merged.type\\n )\",\n \"def triangulationWarping(src, srcTri, dstTri, size, epsilon=0.1):\\n dst_tri = dstTri\\n src_tri = srcTri\\n\\n # coordinates of the bounding rectangle\\n x, y, w, h = cv2.boundingRect(np.float32([dst_tri]))\\n\\n # obtain the height and width of the rectangle\\n rect_left = x\\n rect_right = x + w\\n rect_top = y\\n rect_bottom = y + h\\n\\n # obtaining the destination matrix\\n matrix_dst = np.linalg.inv([[dst_tri[0][0], dst_tri[1][0], dst_tri[2][0]],\\n [dst_tri[0][1], dst_tri[1][1], dst_tri[2][1]],\\n [1, 1, 1]])\\n\\n grid = np.mgrid[rect_left:rect_right, rect_top:rect_bottom].reshape(2, -1)\\n # grid 2xN\\n grid = np.vstack((grid, np.ones((1, grid.shape[1]))))\\n # grid 3xN\\n barycentric_coords = np.dot(matrix_dst, grid)\\n\\n dst_tri = []\\n b = np.all(barycentric_coords > -epsilon, axis=0)\\n a = np.all(barycentric_coords < 1 + epsilon, axis=0)\\n for i in range(len(a)):\\n dst_tri.append(a[i] and b[i])\\n dst_y = []\\n dst_x = []\\n for i in range(len(dst_tri)):\\n if dst_tri[i]:\\n dst_y.append(i % h)\\n dst_x.append(i / h)\\n\\n barycentric_coords = barycentric_coords[:, np.all(-epsilon < barycentric_coords, axis=0)]\\n barycentric_coords = barycentric_coords[:, np.all(barycentric_coords < 1 + epsilon, axis=0)]\\n\\n src_matrix = np.matrix([[src_tri[0][0], src_tri[1][0], src_tri[2][0]],\\n [src_tri[0][1], src_tri[1][1], src_tri[2][1]],\\n [1, 1, 1]])\\n\\n # matrix multiplication of source matrix and barycentric coordinates\\n pts = np.matmul(src_matrix, barycentric_coords)\\n\\n # converting values to homogenous coordinates\\n xA = pts[0, :] / pts[2, :]\\n yA = pts[1, :] / pts[2, :]\\n\\n dst = np.zeros((size[1], size[0], 3), np.uint8)\\n\\n # copy back the value of the pixel at (xA,yA) to the target location.\\n # Using scipy.interpolate.interp2d to perform this operation.\\n i = 0\\n for x, y in zip(xA.flat, yA.flat):\\n y_values = np.linspace(0, src.shape[0], num=src.shape[0], endpoint=False)\\n x_values = np.linspace(0, src.shape[1], num=src.shape[1], endpoint=False)\\n\\n g = src[:, :, 1]\\n fg = interp2d(x_values, y_values, g, kind='cubic')\\n green = fg(x, y)[0]\\n\\n b = src[:, :, 0]\\n fb = interp2d(x_values, y_values, b, kind='cubic')\\n blue = fb(x, y)[0]\\n\\n r = src[:, :, 2]\\n fr = interp2d(x_values, y_values, r, kind='cubic')\\n red = fr(x, y)[0]\\n\\n try:\\n dst[dst_y[i], dst_x[i]] = (blue, green, red)\\n except:\\n pass\\n i = i + 1\\n\\n return dst\",\n \"def test_recomb(self):\\n sol1, sol2 = [0,0,0,0],[1,1,1,1]\\n hot_regions = [0,0,0,1] ##NOTE: sum(hot_regions) shouls always be 1\\n rec_events = 1\\n sol = list(d.recombine(sol1,sol2,rec_events,hot_regions))\\n print(f\\\"recomb sol: {sol}\\\")\\n self.assertTrue( (sol == [0,0,0,1]) or (sol == [1,1,1,0]) )\",\n \"def create_cont_constraint_mat_separable(H,v1s,v2s,nSides,nConstraints,nC,\\n dim_domain,dim_range,tess):\\n if dim_domain != 2:\\n raise ValueError\\n if dim_range not in [1,2]:\\n raise ValueError\\n nHomoCoo=dim_domain+1 \\n length_Avee = dim_range*nHomoCoo\\n L1 = np.zeros((nConstraints/2,nC*nHomoCoo))\\n\\n \\n\\n nPtsInSide = 2 # Since, in 2D, the side is always a line joining 2 pts.\\n# if nSides != nConstraints/(nPtsInSide*dim_domain):\\n# raise ValueError(nSides,nConstraints)\\n \\n if nSides != nConstraints/(nPtsInSide*dim_range):\\n print \\\" print nSides , nConstraints/(nPtsInSide*dim_range):\\\"\\n print nSides , nConstraints/(nPtsInSide*dim_range)\\n ipshell('stop')\\n raise ValueError( nSides , (nConstraints,nPtsInSide,dim_range))\\n\\n \\n if nSides != H.shape[0]:\\n raise ValueError(nSides,H.shape)\\n\\n\\n# M = nPtsInSide*dim_range\\n M = nPtsInSide\\n if dim_range == 1:\\n raise NotImplementedError\\n for i in range(nSides): \\n v1 = v1s[i]\\n v2 = v2s[i]\\n \\n h = H[i]\\n a,b = h.nonzero()[0] # idx for the relevant As \\n # s stands for start\\n # e stands for end \\n s1 = a*length_Avee \\n e1 = s1+nHomoCoo \\n s2 = b*length_Avee\\n e2 = s2+nHomoCoo \\n \\n # Constraint 1: \\n L[i*M,s1:e1]= v1 \\n L[i*M,s2:e2]= -v1 \\n # Constraint 2: \\n L[i*M+1,s1:e1]= v2 \\n L[i*M+1,s2:e2]= -v2 \\n \\n \\n elif dim_range==2:\\n for i in range(nSides): \\n v1 = v1s[i]\\n v2 = v2s[i]\\n\\n if np.allclose(v1,v2):\\n raise ValueError(v1,v2)\\n\\n\\n \\n \\n \\n h = H[i]\\n a,b = h.nonzero()[0] # idx for the relevant As \\n \\n\\n # L1 is acting on columns of the following form:\\n # [ a_1 b_1 c_1 d_1 a_2 b_2 c_2 d_2 ... a_Nc b_Nc c_Nc d_Nc] \\n # s stands for start\\n # e stands for end \\n s1 = a*nHomoCoo\\n e1 = s1+nHomoCoo \\n s2 = b*nHomoCoo\\n e2 = s2+nHomoCoo \\n \\n \\n try: \\n # Constraint 1: \\n row = np.zeros(L1.shape[1])\\n row[s1:e1]=v1\\n row[s2:e2]=-v1 \\n # x component \\n L1[i*M]=row \\n except:\\n ipshell('fail')\\n raise \\n\\n # Constraint 2: \\n row = np.zeros(L1.shape[1])\\n row[s1:e1]=v2\\n row[s2:e2]=-v2 \\n # x component \\n L1[i*M+1]=row\\n \\n\\n \\n \\n \\n \\n \\n else:\\n raise ValueError(dim_range)\\n\\n \\n return L1\",\n \"def snap_connect_nodes(\\n self,\\n two_nodes,\\n subsections=None,\\n spacing=None,\\n boundary_id=-1,\\n ):\\n two_nodes = np.asarray(two_nodes)\\n if two_nodes.shape[0] != 2:\\n raise ValueError(\\\"`two_nodes` takes two nodes only.\\\")\\n\\n # Abuse KDT since it is fast enough for this.\\n kdt = KDTree(self.nodes_)\\n _, nn_ind = kdt.query(two_nodes) # there are two indices\\n logging.debug(\\n \\\"Segment - Snapping and connecting [{ni}] nodes: {n}.\\\".format(\\n ni=nn_ind,\\n n=self.nodes[nn_ind]\\n )\\n )\\n\\n self.connect_nodes(\\n nn_ind,\\n reference_nodes=False,\\n subsections=subsections,\\n spacing=spacing,\\n boundary_id=boundary_id,\\n )\",\n \"def build_contacting_nn(masks, r=1, k=3):\\n \\n pairs = build_contacting(masks, r=r)\\n # reencode the coordinates to match node positions with their respective areas\\n coords = mask_val_coord(masks)\\n coords, pairs = refactor_coords_pairs(coords, pairs)\\n \\n pairs = link_solitaries(coords, pairs)\\n \\n return coords, pairs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5663014","0.55421275","0.5500052","0.54700613","0.54657197","0.5435926","0.54106635","0.540982","0.5407893","0.54021794","0.5359405","0.5358323","0.5355261","0.53323746","0.5324935","0.5305605","0.53029805","0.5296254","0.5277591","0.5276798","0.5273874","0.52360076","0.52089274","0.5205712","0.51992726","0.5186821","0.5185173","0.5179626","0.51741076","0.5173692","0.51566964","0.515071","0.51442903","0.51431125","0.5142839","0.51384693","0.51133764","0.51128304","0.51047796","0.50977474","0.50943595","0.50919944","0.50779176","0.5076585","0.50693065","0.5058041","0.5050569","0.5049945","0.5042438","0.5041683","0.50369924","0.50337124","0.5028345","0.5024733","0.5019272","0.50071335","0.50019395","0.5001235","0.5001005","0.5000576","0.49957442","0.4973021","0.49660298","0.49653253","0.4963516","0.49587575","0.49583724","0.49477205","0.4942443","0.4940564","0.49332055","0.49324927","0.4924283","0.49227023","0.49197847","0.49166313","0.4911993","0.4910704","0.49106568","0.49030557","0.49000984","0.4899644","0.4898591","0.48956418","0.4890846","0.48861867","0.4881914","0.4869045","0.4867794","0.486526","0.4864784","0.48625737","0.48554546","0.48549634","0.48538676","0.48515043","0.4850705","0.48505738","0.4850378","0.48493564"],"string":"[\n \"0.5663014\",\n \"0.55421275\",\n \"0.5500052\",\n \"0.54700613\",\n \"0.54657197\",\n \"0.5435926\",\n \"0.54106635\",\n \"0.540982\",\n \"0.5407893\",\n \"0.54021794\",\n \"0.5359405\",\n \"0.5358323\",\n \"0.5355261\",\n \"0.53323746\",\n \"0.5324935\",\n \"0.5305605\",\n \"0.53029805\",\n \"0.5296254\",\n \"0.5277591\",\n \"0.5276798\",\n \"0.5273874\",\n \"0.52360076\",\n \"0.52089274\",\n \"0.5205712\",\n \"0.51992726\",\n \"0.5186821\",\n \"0.5185173\",\n \"0.5179626\",\n \"0.51741076\",\n \"0.5173692\",\n \"0.51566964\",\n \"0.515071\",\n \"0.51442903\",\n \"0.51431125\",\n \"0.5142839\",\n \"0.51384693\",\n \"0.51133764\",\n \"0.51128304\",\n \"0.51047796\",\n \"0.50977474\",\n \"0.50943595\",\n \"0.50919944\",\n \"0.50779176\",\n \"0.5076585\",\n \"0.50693065\",\n \"0.5058041\",\n \"0.5050569\",\n \"0.5049945\",\n \"0.5042438\",\n \"0.5041683\",\n \"0.50369924\",\n \"0.50337124\",\n \"0.5028345\",\n \"0.5024733\",\n \"0.5019272\",\n \"0.50071335\",\n \"0.50019395\",\n \"0.5001235\",\n \"0.5001005\",\n \"0.5000576\",\n \"0.49957442\",\n \"0.4973021\",\n \"0.49660298\",\n \"0.49653253\",\n \"0.4963516\",\n \"0.49587575\",\n \"0.49583724\",\n \"0.49477205\",\n \"0.4942443\",\n \"0.4940564\",\n \"0.49332055\",\n \"0.49324927\",\n \"0.4924283\",\n \"0.49227023\",\n \"0.49197847\",\n \"0.49166313\",\n \"0.4911993\",\n \"0.4910704\",\n \"0.49106568\",\n \"0.49030557\",\n \"0.49000984\",\n \"0.4899644\",\n \"0.4898591\",\n \"0.48956418\",\n \"0.4890846\",\n \"0.48861867\",\n \"0.4881914\",\n \"0.4869045\",\n \"0.4867794\",\n \"0.486526\",\n \"0.4864784\",\n \"0.48625737\",\n \"0.48554546\",\n \"0.48549634\",\n \"0.48538676\",\n \"0.48515043\",\n \"0.4850705\",\n \"0.48505738\",\n \"0.4850378\",\n \"0.48493564\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6103664"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93483,"cells":{"query":{"kind":"string","value":"Go all the way from raw 2d+t array to an pointList,indexes format"},"document":{"kind":"string","value":"def MakePolygonNetworkFromWaterSeg(\n waterArr, minSplit=30, allValsByFrame=None, cVLS=None\n):\n if allValsByFrame is None:\n allValsByFrame = [list(set(w.flat)) for w in waterArr]\n if cVLS is None:\n cVLS = GetContourValuesLengthsAndSubContoursByFrame(waterArr, allValsByFrame)\n allPtsList = []\n allSegsList = []\n for t in range(len(cVLS)):\n contours = [i[2] for i in cVLS[t]]\n nc = len(contours)\n lc = [len(i) for i in contours]\n div = [i // 30 for i in lc]\n sep = [(lc[i] if div[i] == 0 else lc[i] // div[i]) for i in range(nc)]\n # subPtsOld = [ ([] if div[i]==0 else contours[i][ ::(len(contours[i])//div[i]) ] )\n # for i in range(nc) ]\n inds = [\n (\n [0, lc[i] - 1]\n if (lc[i] - 1 < 2 * minSplit)\n else list(range(0, lc[i] - 2, sep[i])) + [lc[i] - 1]\n )\n for i in range(nc)\n ]\n\n subPts = [[tuple(contours[i][j]) for j in inds[i]] for i in range(nc)]\n allPts = sorted(list(set(flatten(subPts))))\n subPtsInds = [[allPts.index(j) for j in i] for i in subPts]\n allSegsInds = flatten([zip(i[:-1], i[1:]) for i in subPtsInds])\n allPtsList.append(allPts)\n allSegsList.append(allSegsInds)\n\n return allPtsList, allSegsList"},"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 _point_array(self, objects, unique_id):\n points = []\n ids = []\n for idx, row in tqdm(objects.iterrows(), total=objects.shape[0]):\n if row[\"geometry\"].type in [\"Polygon\", \"MultiPolygon\"]:\n poly_ext = row[\"geometry\"].boundary\n else:\n poly_ext = row[\"geometry\"]\n if poly_ext is not None:\n if poly_ext.type == \"MultiLineString\":\n for line in poly_ext:\n point_coords = line.coords\n row_array = np.array(point_coords[:-1]).tolist()\n for i, a in enumerate(row_array):\n points.append(row_array[i])\n ids.append(row[unique_id])\n elif poly_ext.type == \"LineString\":\n point_coords = poly_ext.coords\n row_array = np.array(point_coords[:-1]).tolist()\n for i, a in enumerate(row_array):\n points.append(row_array[i])\n ids.append(row[unique_id])\n else:\n raise Exception(\"Boundary type is {}\".format(poly_ext.type))\n return points, ids","def get_data_as_indices(self, file_name):\n X, Y = [],[]\n org_X, org_Y = [], []\n\n for (words, tags) in read_conll_file(file_name):\n word_indices, word_char_indices = self.get_features(words)\n tag_indices = [self.tag2idx.get(tag) for tag in tags]\n X.append((word_indices,word_char_indices))\n Y.append(tag_indices)\n org_X.append(words)\n org_Y.append(tags)\n return X, Y #, org_X, org_Y - for now don't use","def transform(self,list_array):\n transformed_list = []\n for instance in list_array:\n transformed_list.append([self.notes_to_index[note] for note in instance])\n return np.array(transformed_list, dtype=np.int32)","def getIntArray2D(self) -> typing.List[typing.List[int]]:\n ...","def indices(self):\n return tuple([slice(*r) for r in self.location])","def Indexes(self, latitudes, longitudes):\n res = self._transform.TransformPoints(\n np.column_stack((longitudes, latitudes)))\n res = list(zip(*res))\n x, y = np.array(res[0]), np.array(res[1])\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\n return idx_row.astype(int), idx_col.astype(int)","def convert_shapely_points_to_tuples(list_of_points) -> list:\n return [(p.x, p.y) for p in list_of_points]","def points(self):\n return self._arr.T.ravel().view(\n dtype=[('x', self.dtype), ('y', self.dtype), ('z', self.dtype)])","def ind2coord(self, index):\n\n # assert (index >= 0)\n # assert(index < self.n - 1)\n\n col = index // self.rows\n row = index % self.rows\n\n return [row, col]","def image_to_points(numpy_image):\r\n res = []\r\n for i in range(numpy_image.shape[0]):\r\n for j in range(numpy_image.shape[1]):\r\n if numpy_image[i,j]==0:\r\n res.append([i,j])\r\n return res","def _idxs_postformat_array(self):\n self.idxs = np.array(self.idxs)","def makeIndexMap(self):\n\t\tn = self.numRects\n\t\thalfList = [[(j,n-1-i+j) for j in range(i+1)] for i in range(n)]\n\t\tfullList = halfList + [[(j[1],j[0]) for j in i] for i in halfList[n-2::-1]]\n\t\treturn fullList","def convert(points):\n distance = []\n for i in points:\n x = int(i[0])\n y = int(i[1])\n distance.append([x,y])\n return distance","def rasterize(x):\n for i, y in enumerate(x):\n for v in y:\n yield i, v","def getShortArray2D(self) -> typing.List[typing.List[int]]:\n ...","def cvt2array(tuples):\n rc = []\n for t in tuples:\n rc.append(point3d(np.float32(t[X]), np.float32(t[Y]), np.float32(t[Z])))\n return rc","def array_coords(shape=(1, 1)):\n indexes = np.arange(np.product(shape))\n coords = [indexes % shape[1], indexes // shape[1]]\n return np.transpose(coords).astype('float64')","def coordinates(self, mask):\n y,x = mask.nonzero()\n return list(zip(x,y))","def grid_coordinates(points: np.array, dtype = np.uint16) -> np.array:\n xmin = np.min(points[:, 0])\n xmax = np.max(points[:, 0]) + 1\n ymin = np.min(points[:, 1])\n ymax = np.max(points[:, 1]) + 1\n return np.asarray([(x, y) for y in range(ymin, ymax)\n for x in range(xmin, xmax)], dtype = dtype)","def file_to_points():\r\n points = []\r\n file = open(sys.argv[1])\r\n # First line not needed for how .dat file is read into array, read to get out of way\r\n file.readline()\r\n for line in file:\r\n line = line.strip('\\n').split()\r\n line = (int(line[0]), int(line[1]))\r\n points.append(line)\r\n return points","def convert_int_data(lines):\n tagdict = load('help/tagsets/upenn_tagset.pickle')\n list_tags = list(tagdict.keys()) # Get the list of all the tags.\n X, Y = [], [] # Creation of the array\n for j in range(len(lines)):\n line = lines[j]\n if len(line) >= 5: # We want the word in the middle of five words\n index = np.random.random_integers(low=2, high=len(line) - 3) # Take the index of the word to be choosen\n neighbours_words = [line[i] for i in (index - 2, index - 1, index + 1, index + 2)] # Extract the words\n Y.append(one_hot_encoding(lines[j][index], list_tags)) # Append the target to the array\n sample = []\n for word in neighbours_words:\n sample.append(one_hot_encoding(word, list_tags).tolist())\n X.append(sample) # Append the 4 neighbouring words\n\n return np.array(X), np.array(Y)","def coordinates(self):\n return np.array([[f.x, f.y] for f in self])","def getContents(self):\r\n cont=[]\r\n for i in range (len(self._indices)):\r\n cont.append(self._dataset.getPoint(self._indices[i]))\r\n return cont","def indices(self):\n slice_list = []\n for axis in range(self.ndim):\n if axis in self.displayed:\n slice_list.append(slice(None))\n else:\n if self.clip:\n p = np.clip(\n self.point[axis],\n np.round(self.range[axis][0]),\n np.round(self.range[axis][1]) - 1,\n )\n else:\n p = self.point[axis]\n p = np.round(p / self.range[axis][2]).astype(int)\n slice_list.append(p)\n return tuple(slice_list)","def _dense_point_array(self, geoms, distance, index):\n # interpolate lines to represent them as points for Voronoi\n points = []\n ids = []\n\n if pygeos.get_type_id(geoms[0]) not in [1, 2, 5]:\n lines = pygeos.boundary(geoms)\n else:\n lines = geoms\n lengths = pygeos.length(lines)\n for ix, line, length in zip(index, lines, lengths):\n if length > distance: # some polygons might have collapsed\n pts = pygeos.line_interpolate_point(\n line,\n np.linspace(0.1, length - 0.1, num=int((length - 0.1) // distance)),\n ) # .1 offset to keep a gap between two segments\n points.append(pygeos.get_coordinates(pts))\n ids += [ix] * len(pts)\n\n points = np.vstack(points)\n\n return points, ids\n\n # here we might also want to append original coordinates of each line\n # to get a higher precision on the corners","def coord_indices_of(self, v_list):\n return [self.coord_index_of(v) for v in v_list]","def aind(x):\n\treturn tuple(x.T)","def read_2d(fpath):\n #check_isfile(fpath)\n objs = []\n ids = []\n with open(fpath, 'r') as f:\n for ff in f:\n id_position, players_x, players_y = token_position(ff)\n objs.append((players_x, players_y))\n ids.append(id_position)\n objs = np.array(objs)\n ids = np.array(ids)\n return ids, objs","def morton_idx(pts):\n lib = _initlib()\n p = require(pts, dtype=float64, requirements=['C']) \n inv_cell_width = 1.0/8192\n npts = len(p)\n out = empty(npts, dtype=int64)\n lib.get_morton_idx(p, npts, inv_cell_width, out)\n return out","def getLongArray2D(self) -> typing.List[typing.List[int]]:\n ...","def point_location(tri, p): \n simplex_index = tri.find_simplex(p)\n bc = []\n for id_, point in zip(simplex_index, p):\n # Calculate the two first barycentric coordinates for the relevant\n # simplex\n b = tri.transform[id_, :2].dot(point-tri.transform[id_, 2])\n bc.append(np.c_[np.atleast_2d(b), 1-b.sum()])\n # Create the full array and squeeze the shit out of it\n bc = np.array(bc).squeeze()\n return simplex_index, bc","def coord_list_t(connected_data, t):\n coord_list = []\n for spot_id in connected_data:\n this_spot_data = connected_data[spot_id]\n row = this_spot_data[this_spot_data[:,0] == t]\n if (len(row) > 0):\n row = list(row[0])\n spot_coords = [spot_id] + row[2:5]\n coord_list.append(spot_coords)\n return coord_list","def _xy_locs(mask):\n y, x = mask.nonzero()\n return list(zip(x, y))","def arrays(pos, line):\n list = []\n num = line.shape[0]\n for n in range(num):\n list.append(line[n][pos])\n list = np.asarray(list)\n\n return list","def index_coords(data, origin=None):\r\n ny, nx = data.shape[:2]\r\n if origin is None :\r\n origin_x, origin_y = nx // 2, ny // 2\r\n else :\r\n origin_x, origin_y = origin\r\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\r\n x -= origin_x\r\n y -= origin_y\r\n return x, y","def index_points(points, idx):\n device = points.device\n B = points.shape[0]\n view_shape = list(idx.shape)\n view_shape[1:] = [1] * (len(view_shape) - 1)\n repeat_shape = list(idx.shape)\n repeat_shape[0] = 1\n batch_indices = torch.arange(B, dtype=torch.long).view(view_shape).repeat(repeat_shape)\n new_points = points[batch_indices, idx, :]\n return new_points","def _sort_index(self):\n\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\n\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\n\n for i, traceItem in enumerate(self.data):\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\n for j, altPos in enumerate(allAltPos):\n for k, aziPos in enumerate(allAziPos):\n if alt==altPos and azi==aziPos:\n if sign==1:\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\n else: indON[j][k]=i\n\n if sign==-1:\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\n else: indOFF[j][k]=i\n\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\n\n return indON,indOFF,allAltPos,allAziPos","def index_to_xy(index):\n x = index % columns\n y = index // columns\n return x, y","def row_to_indices(row):\r\n return [(row, col) for col in range(0, 9)]","def find_coord_indices(lon_array, lat_array, lon_points, lat_points, proj_str):\n\n proj = Proj(proj_str)\n proj_lon, proj_lat = np.array(proj(lon_array, lat_array)) # transform to distances using specified projection\n lonlat = np.column_stack(\n (proj_lon.ravel(), proj_lat.ravel())) # Stack all coarse x, y distances for array shape (n, 2)\n ll = np.array(proj(lon_points, lat_points)).T # transform lists of fine grid x, y to match shape (n, 2)\n idx = cdist(lonlat, ll).argmin(0) # Calculate all distances and get index of minimum\n\n return np.column_stack((np.unravel_index(idx, lon_array.shape))).tolist()","def get_arr_edge_indices(arr, res='4x5', extra_points_point_on_edge=None,\n verbose=True, debug=False):\n if verbose:\n print(('get_arr_edge_indices for arr of shape: ', arr.shape))\n\n # initialise variables\n lon_c, lat_c, NIU = get_latlonalt4res(res=res, centre=True)\n lon_e, lat_e, NIU = get_latlonalt4res(res=res, centre=False)\n lon_diff = lon_e[-5]-lon_e[-6]\n lat_diff = lat_e[-5]-lat_e[-6]\n nn, n, = 0, 0\n last_lat_box = arr[nn, n]\n coords = []\n last_lon_box = arr[nn, n]\n need_lon_outer_edge, need_lat_outer_edge = False, False\n if debug:\n print((lon_e, lat_e))\n\n # ---- Loop X dimension ( lon )\n for nn, lon_ in enumerate(lon_c):\n\n # Loop Y dimension ( lat ) and store edges\n for n, lat_ in enumerate(lat_c):\n\n if debug:\n print((arr[nn, n], last_lat_box, last_lon_box,\n arr[nn, n] == last_lat_box, arr[nn, n] == last_lon_box))\n\n if arr[nn, n] != last_lat_box:\n\n # If 1st lat, selct bottom of box\n point_lon = lon_e[nn]+lon_diff/2\n if need_lat_outer_edge:\n point_lat = lat_e[n+1]\n else:\n point_lat = lat_e[n]\n need_lat_outer_edge = True\n need_lat_outer_edge = False\n\n # Add mid point to cordinates list\n if isinstance(extra_points_point_on_edge, type(None)):\n mid_point = [point_lon, point_lat]\n coords += [mid_point]\n\n # Add given number of points along edge\n else:\n coords += [[lon_e[nn]+(lon_diff*i), point_lat] for i in\n np.linspace(0, 1, extra_points_point_on_edge,\n endpoint=True)]\n\n # temporally save the previous box's value\n last_lat_box = arr[nn, n]\n\n # ---- Loop Y dimension ( lat )\n for n, lat_ in enumerate(lat_c):\n\n if debug:\n print((arr[nn, n], last_lat_box, last_lon_box,\n arr[nn, n] == last_lat_box, arr[nn, n] == last_lon_box))\n # Loop X dimension ( lon ) and store edges\n for nn, lon_ in enumerate(lon_c):\n\n # If change in value at to list\n if arr[nn, n] != last_lon_box:\n point_lat = lat_e[n]+lat_diff/2\n\n # Make sure we select the edge lon\n if need_lon_outer_edge:\n point_lon = lon_e[nn+1]\n else:\n point_lon = lon_e[nn]\n need_lon_outer_edge = True\n need_lon_outer_edge = False\n\n # Add mid point to coordinates list\n if isinstance(extra_points_point_on_edge, type(None)):\n mid_point = [point_lon, point_lat]\n coords += [mid_point]\n\n # Add given number of points along edge\n else:\n coords += [[point_lon, lat_e[n]+(lat_diff*i)] for i in\n np.linspace(0, 1, extra_points_point_on_edge,\n endpoint=True)]\n\n # temporally save the previous box's value\n last_lon_box = arr[nn, n]\n\n return coords","def index_coords(data, origin=None):\n ny, nx = data.shape[:2]\n if origin is None:\n origin_x, origin_y = nx // 2, ny // 2\n else:\n origin_x, origin_y = origin\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\n x -= origin_x\n y -= origin_y\n return x, y","def points(self):\n return np.vstack((self.x(), self.y()))","def createCoordTuples(data):\n data['xy'] = None\n for i, row in data.iterrows():\n data['xy'][i] = [np.round(row['geometry'].x, decimals=5), np.round(row['geometry'].y, decimals=5)]\n return data","def coordinates(self, bin_indices):\n indices = numpy.asarray(bin_indices).transpose()\n coords = [numpy.interp(i, range(n), c)\n for (i, n, c) in zip(indices, self.shape, self.centers)]\n coords_arr = numpy.array(coords).transpose()\n return numpy.atleast_2d(coords_arr)","def idx_to_list(bytez):\n # byte 0: 0\n # byte 1: 0\n if not (bytez[0] == 0 and bytez[1] == 0):\n raise IOError(\"IDX file should start with two 0 bytes\")\n\n # byte 2: The number of dimensions\n # byte 3: The type code\n typebyte = bytez[2]\n numdims = bytez[3]\n\n # 4 bytes for each dimension: size of dimensions\n fmtstring = '>' + 'i'*numdims\n dimension_sizes = struct.unpack(fmtstring, bytez[4:4+4*numdims])\n\n # Rest of the data starts here\n startoffset = 4 + 4*numdims\n\n typedata = {\n 0x08: ('B', 1),\n 0x09: ('b', 1),\n 0x0B: ('h', 2),\n 0x0C: ('i', 4),\n 0x0D: ('f', 4),\n 0x0E: ('d', 8)\n }\n\n typecode = typedata[typebyte][0]\n flatarray = array.array(typecode, bytez[startoffset:])\n if sys.byteorder == 'little':\n flatarray.byteswap()\n\n if flatarray.itemsize != typedata[typebyte][1]:\n raise EnvironmentError(\"It's assumed a C int is 4 bytes\")\n\n def _recursive(inputlst, dimsizes):\n \"\"\"Recursively split the flat list into chunks and merge them back into a\n nested list structure.\"\"\"\n if len(dimsizes) == 1:\n return list(inputlst)\n\n outerlist = []\n chunksize = len(inputlst)//dimsizes[0]\n for i in range(0, len(inputlst), chunksize):\n chunk = inputlst[i:i+chunksize]\n outerlist.append(_recursive(chunk, dimsizes[1:]))\n\n return outerlist\n\n return _recursive(flatarray, dimension_sizes)","def entries(self):\n out = []\n for y,x in self.coords(False):\n out.append((y,x,self.retrieve(y,x)))\n return out","def coords(self, point):\n\n ref_x, ref_y = point\n index_row, index_col = self.index\n fp_coords = []\n for offset in self.offsets:\n x_off = (offset[1] - index_col) * self.cell_size + ref_x\n y_off = (index_row - offset[0]) * self.cell_size + ref_y\n fp_coords.append((x_off, y_off))\n return fp_coords","def transform_points(transf_matrix, points):\n if(type(points)==list):\n temp_pts = [np.array([x[0],x[1],x[2],1]) for x in points]\n newpts = []\n for pt in temp_pts:\n newpts.append((transf_matrix@pt)[:3])\n else:\n temp_pts = np.array([points[0],points[1],points[2],1])\n newpts=(transf_matrix@temp_pts)[:3]\n return newpts","def cell_list(self):\n lst_of_idx = []\n height = self.__height\n width = self.__width\n for i in range(width):\n for j in range(height):\n lst_of_idx.append((i,j))\n lst_of_idx.append((3,7))\n return lst_of_idx","def loc_data_idx(loc_idx):\n retval = []\n for i in as_tuple(loc_idx):\n if isinstance(i, slice) and i.step is not None and i.step == -1:\n if i.stop is None:\n retval.append(slice(0, i.start+1, -i.step))\n else:\n retval.append(slice(i.stop+1, i.start+1, -i.step))\n elif isinstance(i, slice) and i.step is not None and i.step < -1:\n if i.stop is None:\n lmin = i.start\n while lmin >= 0:\n lmin += i.step\n retval.append(slice(lmin-i.step, i.start+1, -i.step))\n else:\n retval.append(slice(i.stop+1, i.start+1, -i.step))\n elif is_integer(i):\n retval.append(slice(i, i+1, 1))\n else:\n retval.append(i)\n return as_tuple(retval)","def mapping_to_indices(coords, batch_size):\n h, w = coords.shape[:2]\n indices_axis_0 = list(np.repeat(np.arange(batch_size), h * w))\n indices_axis_1 = [0]\n indices_axis_2 = list(np.tile(coords[:,:,0].reshape(-1), 2))\n indices_axis_3 = list(np.tile(coords[:,:,1].reshape(-1), batch_size))\n return [indices_axis_0, indices_axis_1, indices_axis_2, indices_axis_3]","def cvt_points_to_vector(points):\n\n return numpy.hstack(points)","def GetPointToOneRingPointsArray(self, p_int):\n ...","def xy_to_index(x, y):\n index = y * columns + x\n return index","def point_to_coords(self, point: Sequence[float]) -> np.ndarray:\n point = np.asarray(point)\n result = np.asarray([axis.point_to_number(point) for axis in self.get_axes()])\n if point.ndim == 2:\n return result.T\n return result","def _build_points(self, xs, ys):\n return np.hstack([xs, ys])","def points_to_index(points, points_dict):\r\n index_locations = ''\r\n for point in points:\r\n index_locations += str(points_dict[point]) + ' '\r\n return index_locations","def cell_verts(self, idx):\r\n coords = []\r\n xyz = [0, 0, 0]\r\n cell = self.grid.GetCell(idx[0] - 1, idx[1] - 1, idx[2] - 1)\r\n p_ids = cell.GetPointIds()\r\n n_ids = pointIds.GetNumberOfIds()\r\n for n in range(n_ids):\r\n p = p_ids.GetId(n)\r\n self.grid.GetPoint(p, xyz)\r\n coords.append(copy.deepcopy(xyz))\r\n return coords","def points(self):\n p = []\n for v in self.iter():\n p.append((v.x, v.y))\n return p","def arrayTo2DPts(direction: str, arr: np.ndarray, ij2xy_func: Callable) -> List[Point]:\n\n pts = []\n for i in range(arr.shape[0]):\n for j in range(arr.shape[1]):\n val = arr[i, j]\n if np.isfinite(val):\n if direction == 'i':\n i_int, j_int = i + val, j\n elif direction == 'j':\n i_int, j_int = i, j + val\n else:\n raise Exception('Unexpected array direction value: {}'.format(direction))\n x, y = ij2xy_func(i_int, j_int)\n pts.append(Point(x, y))\n\n return pts","def generate_bitmap_to_linear_index_map(bladeTupList, firstIdx):\n bitmap_map = np.zeros(len(bladeTupList), dtype=int)\n for ind, blade in enumerate(bladeTupList):\n bitmap_map[compute_bitmap_representation(blade, firstIdx)] = ind\n return bitmap_map","def trans_to_coordinates(T, pts):\n p = []\n for i in range(len(pts)):\n \n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\n p_a = np.matmul(T, p_b).tolist()\n p.append(p_a[0:3])\n\n return p","def trans_to_coordinates(T, pts):\n p = []\n for i in range(len(pts)):\n \n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\n p_a = np.matmul(T, p_b).tolist()\n p.append(p_a[0:3])\n\n return p","def get_data_by_indexes(indexes: list, data: np.ndarray) -> np.ndarray:\n return np.asarray([data[i, j] for i, j in indexes])","def reconstruct_input(self, ix):","def coords_to_positions(self, coords):\n return [self.to_position(x, y, i, j) for (x, y, i, j) in coords]","def get_indices(min_lat, max_lat, min_lon, max_lon, lons, lats):\n\n distances1, distances2, indices = [], [], []\n index = 1\n for point in lats:\n s1 = max_lat - point\n s2 = min_lat - point\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index - 1))\n index = index + 1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n distances1, distances2 = [], []\n index = 1\n for point in lons:\n s1 = max_lon - point\n s2 = min_lon - point\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index - 1))\n index = index + 1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # max_lat_indices, min_lat_indices, max_lon_indices, min_lon_indices.\n res = np.zeros((4), dtype=np.float64)\n res[0] = indices[3][2]\n res[1] = indices[2][2]\n res[2] = indices[1][2]\n res[3] = indices[0][2]\n return res","def _vertex_arrays_to_list(x_coords_metres, y_coords_metres):\n\n _check_polyline(\n x_coords_metres=x_coords_metres, y_coords_metres=y_coords_metres)\n\n num_vertices = len(x_coords_metres)\n vertex_list_xy_metres = []\n for i in range(num_vertices):\n vertex_list_xy_metres.append((x_coords_metres[i], y_coords_metres[i]))\n\n return vertex_list_xy_metres","def GetPointToIncidentEdgesArray(self, p_int):\n ...","def site_indexes_to_coords(results, site_coords):\n coords = []\n for i in range(0,len(results)):\n cursites = results[i]['coveringsites']\n if len(cursites) > 0: #clean out empty end stages\n tmpcoords = []\n for ind in cursites:\n tmpcoords.append(site_coords[ind])\n coords.append(tmpcoords)\n return coords","def xy2ind(x, y, xdim):\n if isinstance(x, np.ndarray):\n return x + (y * xdim)\n else:\n return int(x) + int(y) * xdim","def dlib_point_to_np_array(point: dlib.point):\n return np.array([point.x, point.y])","def _parse_points(self, scan_data):\n \n # check data\n if not scan_data['mz_data'] or not scan_data['int_data']:\n return []\n \n # decode data\n mz_data = base64.b64decode(scan_data['mz_data'])\n int_data = base64.b64decode(scan_data['int_data'])\n \n # decompress data\n if scan_data['mz_compression'] == 'zlib':\n mz_data = zlib.decompress(mz_data)\n \n if scan_data['int_compression'] == 'zlib':\n int_data = zlib.decompress(int_data)\n \n # get precision\n mz_precision = 'f'\n if scan_data['mz_precision'] == 64:\n mz_precision = 'd'\n \n int_precision = 'f'\n if scan_data['int_precision'] == 64:\n int_precision = 'd'\n \n # convert from binary\n count = len(mz_data) // struct.calcsize('<' + mz_precision)\n mz_data = struct.unpack('<' + mz_precision * count, mz_data[0:len(mz_data)])\n \n count = len(int_data) // struct.calcsize('<' + int_precision)\n int_data = struct.unpack('<' + int_precision * count, int_data[0:len(int_data)])\n \n # format\n if scan_data['spectrum_type'] == 'centroided':\n points = map(list, zip(mz_data, int_data))\n else:\n mz_data = numpy.array(mz_data)\n mz_data.shape = (-1, 1)\n int_data = numpy.array(int_data)\n int_data.shape = (-1, 1)\n data = numpy.concatenate((mz_data,int_data), axis=1)\n points = data.copy()\n \n return points","def calcul_xy_array(img_x, img_y, tile_x, tile_y):\n array = []\n\n modu_x = img_x % tile_x\n modu_y = img_y % tile_y\n div_x = img_x // tile_x\n div_y = img_y // tile_y\n current_x = 0\n current_y = 0\n\n for i in range(div_y):\n for j in range(div_x):\n array.append((current_x, current_y))\n current_x += tile_x\n if modu_x:\n array.append((img_x - tile_x, current_y))\n current_y += tile_y\n current_x = 0\n\n if modu_y:\n current_y = img_y - tile_y\n for j in range(div_x):\n array.append((current_x, current_y))\n current_x += tile_x\n if modu_x:\n array.append((img_x - tile_x, current_y))\n\n return array","def as_numpy_array_2D(self):\n wx = []\n wy = []\n for wp in self.waypoints:\n wx.append(wp.location.x)\n wy.append(wp.location.y)\n return np.array([wx, wy])","def extract_data(data_file):\n\n data_points = set()\n points_to_coordinates = {}\n x_coor_dict = {}\n # need this since we need to iterate through the first point indices in a fixed order\n first_point_indices = []\n\n with open(data_file) as input_file:\n # consume the first line, it only tells us how many points there are\n input_file.readline()\n point_number = 0\n current_x_coor = inf\n # point that's used as the indexing point for a list of points with the same x coordinates\n first_point_index = 1\n\n for line in input_file:\n point_number += 1\n line = line.strip('\\n')\n split_line = line.split(\" \")\n print(split_line)\n x_coor = float(split_line[1])\n # if we're seeing this x coordinate for the first time\n if current_x_coor != x_coor:\n first_point_index = point_number\n first_point_indices.append(first_point_index)\n x_coor_dict[first_point_index] = []\n current_x_coor = x_coor\n x_coor_dict[first_point_index].append(point_number)\n new_point = Point(x_coor, float(split_line[2]))\n points_to_coordinates[point_number] = new_point\n data_points.add(point_number)\n\n return data_points, points_to_coordinates, x_coor_dict, first_point_indices","def _build_point_grid(n_per_side: int) -> np.ndarray:\n offset = 1 / (2 * n_per_side)\n points_one_side = np.linspace(offset, 1 - offset, n_per_side)\n points_x = np.tile(points_one_side[None, :], (n_per_side, 1))\n points_y = np.tile(points_one_side[:, None], (1, n_per_side))\n points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2)\n return points","def coordinates_of(self, coord_index_list):\n return [self.transformed_coords[i] for i in coord_index_list]","def serialize(self):\n out_list = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n\n for num, (i, j) in self.num_to_pos.items():\n out_list[i][j] = num\n\n return out_list","def atom_idxs(self):\n\n return np.array([atom.atom_idxs for atom in self])","def open_xy(data):\n twotheta, intensity = [], []\n with open(data) as f:\n for line in f:\n row = line.split()\n twotheta.append(row[0])\n intensity.append(row[1])\n xyarray = list(zip(twotheta, intensity))\n xyarray = np.asarray(xyarray)\n xyarray = xyarray.astype(np.float)\n return xyarray","def get_positions(p_state, idx_image=-1, idx_chain=-1):\n nos = system.get_nos(p_state, idx_image, idx_chain)\n ArrayType = scalar*3*nos\n Data = _Get_Positions(ctypes.c_void_p(p_state), ctypes.c_int(idx_image), ctypes.c_int(idx_chain))\n array_pointer = ctypes.cast(Data, ctypes.POINTER(ArrayType))\n array = np.frombuffer(array_pointer.contents, dtype=scalar)\n array_view = array.view()\n array_view.shape = (nos, 3)\n return array_view","def get_all_coordinates(self):\n coordinates = []\n\n for relative_coordinate in self.shape:\n co = [self.coordinate[0] + relative_coordinate[0], self.coordinate[1] + relative_coordinate[1]]\n coordinates.append(co)\n return coordinates","def xy_to_idx(self, xs, ys, mask=None, mask_outside=False, nodata=-1):\n _, ncol = self.shape\n r, c = self.rowcol(xs, ys, mask=mask, mask_outside=mask_outside, nodata=nodata)\n mask = r != nodata\n idx = np.full(r.shape, nodata, dtype=int)\n idx[mask] = r[mask] * ncol + c[mask]\n return idx","def list_to_idx(lst, typecode):\n magicnumber = _build_magic_number(lst, typecode)\n dimension_sizes = _build_dimension_sizes(lst)\n data = _build_data(lst, typecode)\n\n return magicnumber + dimension_sizes + data","def toArray(parsedList):\n interpretCommand = {\n 'C' : lambda x, prevL : x[-2:], # bezier curve. Ignore the curve.\n 'L' : lambda x, prevL : x[0:2],\n 'M' : lambda x, prevL : x[0:2],\n 'Z' : lambda x, prevL : prevL[0],\n }\n\n points =[]\n for i,(c, arg) in enumerate(parsedList):\n #debug('toArray ', i, c , arg)\n newp = interpretCommand[c](arg, points)\n points.append( newp)\n a=numpy.array( points )\n\n # Some times we have points *very* close to each other\n # these do not bring any meaning full info, so we remove them\n #\n x,y, w,h = computeBox(a)\n sizeC = 0.5*(w+h)\n #deltas = numpy.zeros((len(a),2) )\n deltas = a[1:] - a[:-1] \n #deltas[-1] = a[0] - a[-1]\n deltaD = numpy.sqrt(numpy.sum( deltas**2, 1 ))\n sortedDind = numpy.argsort(deltaD)\n # expand longuest segments\n nexp = int(len(deltaD)*0.9)\n newpoints=[ None ]*len(a)\n medDelta = deltaD[sortedDind[len(deltaD)/2] ]\n for i,ind in enumerate(sortedDind):\n if deltaD[ind]/sizeC<0.005: continue\n if i>nexp:\n np = int(deltaD[ind]/medDelta)\n pL = [a[ind]]\n #print i,'=',ind,'adding ', np,' _ ', deltaD[ind], a[ind], a[ind+1]\n for j in range(np-1):\n f = float(j+1)/np\n #print '------> ', (1-f)*a[ind]+f*a[ind+1]\n pL.append( (1-f)*a[ind]+f*a[ind+1] )\n newpoints[ind] = pL\n else:\n newpoints[ind]=[a[ind]]\n if(D(a[0],a[-1])/sizeC > 0.005 ) :\n newpoints[-1]=[a[-1]]\n\n points = numpy.concatenate([p for p in newpoints if p!=None] )\n ## print ' medDelta ', medDelta, deltaD[sortedDind[-1]]\n ## print len(a) ,' ------> ', len(points)\n\n rel_norms = numpy.sqrt(numpy.sum( deltas**2, 1 )) / sizeC\n keep = numpy.concatenate([numpy.where( rel_norms >0.005 )[0],numpy.array([len(a)-1])])\n\n #return a[keep] , [ parsedList[i] for i in keep]\n #print len(a),' ',len(points)\n return points , []","def afficher_points_2D(set_points):\n X, Y = [p[0][0] for p in set_points], [p[0][1] for p in set_points]\n return(X, Y)","def vertices(self) -> list[Point]:\n a = Point(self.array[..., 0, :], copy=False)\n b = Point(self.array[..., 1, :], copy=False)\n return [a, b]","def _indarray(np_array):\n return skil_client.INDArray(\n ordering='c',\n shape=list(np_array.shape),\n data=np_array.reshape(-1).tolist()\n )","def ind2latlon(index, filePath):\n # Load georeferencing\n ds = gdal.Open(filePath)\n proj = ds.GetProjection()\n gt = ds.GetGeoTransform()\n srs = osr.SpatialReference()\n srs.ImportFromWkt(proj)\n\n x0 = gt[0] #top left longitude\n y0 = gt[3] #top left latitude\n dx = gt[1] #pixel width\n dy = gt[5] #pixel height\n\n # Convert row,col of array to projected coords\n row, col = index\n x = x0 + (col * dx)\n y = y0 + (row * dy)\n\n # Convert projected coords to latlon\n trs = osr.SpatialReference()\n trs.ImportFromEPSG(4326)\n ct = osr.CoordinateTransformation(srs, trs)\n\n (lon, lat, height) = ct.TransformPoint(x, y) #note could add elevation\n #gdal.DecToDMS(lat, 'Lat', 2)\n\n return lon, lat","def get_array_of_matching_points(size, triangles_list,\n intermediate_triangles_list):\n\n # initiate the 2D array\n matching_points_list = [[] for _ in range(size[1])]\n # run over each coordinate in the 2D array by the given size\n\n for i in range(0, size[1]):\n for j in range(0, size[0]):\n # search for the right intermediate triangle\n for k in range(0,len(intermediate_triangles_list)):\n # the current intermediate triangle\n inter_tri = intermediate_triangles_list[k]\n # the tuple containing if the point is inside and its\n # coefficients\n point_tuple = is_point_inside_triangle((j, i), inter_tri[0],\n inter_tri[1],\n inter_tri[2])\n if point_tuple[0]:\n # if the current point is inside the current intermediate\n # triangle append the converted point to the list\n matching_points_list[i].\\\n append(convert_point(triangles_list[k],point_tuple[1]))\n break\n return matching_points_list","def pt_index(*args):\n index = []\n x = check_pt_data(args[0])\n i = 0\n for line in args[0].Data.PTData.pt_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def get_coordinates_list(self):\n return [tweet['coordinates'][::-1] for tweet in self.tweets_data]","def GetPointToIncidentFacesArray(self, p_int):\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","def _make_coord_array(t,d):\n Nt,Nd = t.shape[0],d.shape[0]\n X = np.zeros([Nt,Nd,3],dtype=np.float64)\n for j in range(Nt):\n for k in range(Nd):\n X[j,k,0] = t[j]\n X[j,k,1:3] = d[k,:]\n X = np.reshape(X,(Nt*Nd,3))\n return X","def _update_imgs_and_pt_list(self, points, edge_points, segs, index):\n # index specifies whether to use the x or y coordinate in x_pts\n x_pts=[]\n for i in range(0, len(points)):\n pt=points[i]\n #edge_points[pt[0],pt[1]] = 255\n x_pts.append(pt[index])\n #segs[pt[0],pt[1]]=150\n\n return x_pts, segs, edge_points","def xy(self):\n xcol = self.xx.reshape(-1, 1)\n ycol = self.yy.reshape(-1, 1)\n return np.column_stack([xcol, ycol])","def _indices_to_coords(c,r):\n\n column = _index_to_column(c)\n row = r + 1\n\n return {'c': column, 'r': row, 'coord': f'{column}{row}'}","def create_points(number): \n\n # generate x and y coordinates:\n x = np.random.permutation(2*number)[:number] - number\n y = np.random.permutation(2*number)[:number] - number\n\n points = [ { 0 : float(x[i]), 1 : float(y[i]), \"index\" : i} for i in range(len(x)) ]\n\n return points\n\n # generate points as coordinate pairs of floats.\n # return zip(map(float,x),map(float,y))"],"string":"[\n \"def _point_array(self, objects, unique_id):\\n points = []\\n ids = []\\n for idx, row in tqdm(objects.iterrows(), total=objects.shape[0]):\\n if row[\\\"geometry\\\"].type in [\\\"Polygon\\\", \\\"MultiPolygon\\\"]:\\n poly_ext = row[\\\"geometry\\\"].boundary\\n else:\\n poly_ext = row[\\\"geometry\\\"]\\n if poly_ext is not None:\\n if poly_ext.type == \\\"MultiLineString\\\":\\n for line in poly_ext:\\n point_coords = line.coords\\n row_array = np.array(point_coords[:-1]).tolist()\\n for i, a in enumerate(row_array):\\n points.append(row_array[i])\\n ids.append(row[unique_id])\\n elif poly_ext.type == \\\"LineString\\\":\\n point_coords = poly_ext.coords\\n row_array = np.array(point_coords[:-1]).tolist()\\n for i, a in enumerate(row_array):\\n points.append(row_array[i])\\n ids.append(row[unique_id])\\n else:\\n raise Exception(\\\"Boundary type is {}\\\".format(poly_ext.type))\\n return points, ids\",\n \"def get_data_as_indices(self, file_name):\\n X, Y = [],[]\\n org_X, org_Y = [], []\\n\\n for (words, tags) in read_conll_file(file_name):\\n word_indices, word_char_indices = self.get_features(words)\\n tag_indices = [self.tag2idx.get(tag) for tag in tags]\\n X.append((word_indices,word_char_indices))\\n Y.append(tag_indices)\\n org_X.append(words)\\n org_Y.append(tags)\\n return X, Y #, org_X, org_Y - for now don't use\",\n \"def transform(self,list_array):\\n transformed_list = []\\n for instance in list_array:\\n transformed_list.append([self.notes_to_index[note] for note in instance])\\n return np.array(transformed_list, dtype=np.int32)\",\n \"def getIntArray2D(self) -> typing.List[typing.List[int]]:\\n ...\",\n \"def indices(self):\\n return tuple([slice(*r) for r in self.location])\",\n \"def Indexes(self, latitudes, longitudes):\\n res = self._transform.TransformPoints(\\n np.column_stack((longitudes, latitudes)))\\n res = list(zip(*res))\\n x, y = np.array(res[0]), np.array(res[1])\\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\\n return idx_row.astype(int), idx_col.astype(int)\",\n \"def convert_shapely_points_to_tuples(list_of_points) -> list:\\n return [(p.x, p.y) for p in list_of_points]\",\n \"def points(self):\\n return self._arr.T.ravel().view(\\n dtype=[('x', self.dtype), ('y', self.dtype), ('z', self.dtype)])\",\n \"def ind2coord(self, index):\\n\\n # assert (index >= 0)\\n # assert(index < self.n - 1)\\n\\n col = index // self.rows\\n row = index % self.rows\\n\\n return [row, col]\",\n \"def image_to_points(numpy_image):\\r\\n res = []\\r\\n for i in range(numpy_image.shape[0]):\\r\\n for j in range(numpy_image.shape[1]):\\r\\n if numpy_image[i,j]==0:\\r\\n res.append([i,j])\\r\\n return res\",\n \"def _idxs_postformat_array(self):\\n self.idxs = np.array(self.idxs)\",\n \"def makeIndexMap(self):\\n\\t\\tn = self.numRects\\n\\t\\thalfList = [[(j,n-1-i+j) for j in range(i+1)] for i in range(n)]\\n\\t\\tfullList = halfList + [[(j[1],j[0]) for j in i] for i in halfList[n-2::-1]]\\n\\t\\treturn fullList\",\n \"def convert(points):\\n distance = []\\n for i in points:\\n x = int(i[0])\\n y = int(i[1])\\n distance.append([x,y])\\n return distance\",\n \"def rasterize(x):\\n for i, y in enumerate(x):\\n for v in y:\\n yield i, v\",\n \"def getShortArray2D(self) -> typing.List[typing.List[int]]:\\n ...\",\n \"def cvt2array(tuples):\\n rc = []\\n for t in tuples:\\n rc.append(point3d(np.float32(t[X]), np.float32(t[Y]), np.float32(t[Z])))\\n return rc\",\n \"def array_coords(shape=(1, 1)):\\n indexes = np.arange(np.product(shape))\\n coords = [indexes % shape[1], indexes // shape[1]]\\n return np.transpose(coords).astype('float64')\",\n \"def coordinates(self, mask):\\n y,x = mask.nonzero()\\n return list(zip(x,y))\",\n \"def grid_coordinates(points: np.array, dtype = np.uint16) -> np.array:\\n xmin = np.min(points[:, 0])\\n xmax = np.max(points[:, 0]) + 1\\n ymin = np.min(points[:, 1])\\n ymax = np.max(points[:, 1]) + 1\\n return np.asarray([(x, y) for y in range(ymin, ymax)\\n for x in range(xmin, xmax)], dtype = dtype)\",\n \"def file_to_points():\\r\\n points = []\\r\\n file = open(sys.argv[1])\\r\\n # First line not needed for how .dat file is read into array, read to get out of way\\r\\n file.readline()\\r\\n for line in file:\\r\\n line = line.strip('\\\\n').split()\\r\\n line = (int(line[0]), int(line[1]))\\r\\n points.append(line)\\r\\n return points\",\n \"def convert_int_data(lines):\\n tagdict = load('help/tagsets/upenn_tagset.pickle')\\n list_tags = list(tagdict.keys()) # Get the list of all the tags.\\n X, Y = [], [] # Creation of the array\\n for j in range(len(lines)):\\n line = lines[j]\\n if len(line) >= 5: # We want the word in the middle of five words\\n index = np.random.random_integers(low=2, high=len(line) - 3) # Take the index of the word to be choosen\\n neighbours_words = [line[i] for i in (index - 2, index - 1, index + 1, index + 2)] # Extract the words\\n Y.append(one_hot_encoding(lines[j][index], list_tags)) # Append the target to the array\\n sample = []\\n for word in neighbours_words:\\n sample.append(one_hot_encoding(word, list_tags).tolist())\\n X.append(sample) # Append the 4 neighbouring words\\n\\n return np.array(X), np.array(Y)\",\n \"def coordinates(self):\\n return np.array([[f.x, f.y] for f in self])\",\n \"def getContents(self):\\r\\n cont=[]\\r\\n for i in range (len(self._indices)):\\r\\n cont.append(self._dataset.getPoint(self._indices[i]))\\r\\n return cont\",\n \"def indices(self):\\n slice_list = []\\n for axis in range(self.ndim):\\n if axis in self.displayed:\\n slice_list.append(slice(None))\\n else:\\n if self.clip:\\n p = np.clip(\\n self.point[axis],\\n np.round(self.range[axis][0]),\\n np.round(self.range[axis][1]) - 1,\\n )\\n else:\\n p = self.point[axis]\\n p = np.round(p / self.range[axis][2]).astype(int)\\n slice_list.append(p)\\n return tuple(slice_list)\",\n \"def _dense_point_array(self, geoms, distance, index):\\n # interpolate lines to represent them as points for Voronoi\\n points = []\\n ids = []\\n\\n if pygeos.get_type_id(geoms[0]) not in [1, 2, 5]:\\n lines = pygeos.boundary(geoms)\\n else:\\n lines = geoms\\n lengths = pygeos.length(lines)\\n for ix, line, length in zip(index, lines, lengths):\\n if length > distance: # some polygons might have collapsed\\n pts = pygeos.line_interpolate_point(\\n line,\\n np.linspace(0.1, length - 0.1, num=int((length - 0.1) // distance)),\\n ) # .1 offset to keep a gap between two segments\\n points.append(pygeos.get_coordinates(pts))\\n ids += [ix] * len(pts)\\n\\n points = np.vstack(points)\\n\\n return points, ids\\n\\n # here we might also want to append original coordinates of each line\\n # to get a higher precision on the corners\",\n \"def coord_indices_of(self, v_list):\\n return [self.coord_index_of(v) for v in v_list]\",\n \"def aind(x):\\n\\treturn tuple(x.T)\",\n \"def read_2d(fpath):\\n #check_isfile(fpath)\\n objs = []\\n ids = []\\n with open(fpath, 'r') as f:\\n for ff in f:\\n id_position, players_x, players_y = token_position(ff)\\n objs.append((players_x, players_y))\\n ids.append(id_position)\\n objs = np.array(objs)\\n ids = np.array(ids)\\n return ids, objs\",\n \"def morton_idx(pts):\\n lib = _initlib()\\n p = require(pts, dtype=float64, requirements=['C']) \\n inv_cell_width = 1.0/8192\\n npts = len(p)\\n out = empty(npts, dtype=int64)\\n lib.get_morton_idx(p, npts, inv_cell_width, out)\\n return out\",\n \"def getLongArray2D(self) -> typing.List[typing.List[int]]:\\n ...\",\n \"def point_location(tri, p): \\n simplex_index = tri.find_simplex(p)\\n bc = []\\n for id_, point in zip(simplex_index, p):\\n # Calculate the two first barycentric coordinates for the relevant\\n # simplex\\n b = tri.transform[id_, :2].dot(point-tri.transform[id_, 2])\\n bc.append(np.c_[np.atleast_2d(b), 1-b.sum()])\\n # Create the full array and squeeze the shit out of it\\n bc = np.array(bc).squeeze()\\n return simplex_index, bc\",\n \"def coord_list_t(connected_data, t):\\n coord_list = []\\n for spot_id in connected_data:\\n this_spot_data = connected_data[spot_id]\\n row = this_spot_data[this_spot_data[:,0] == t]\\n if (len(row) > 0):\\n row = list(row[0])\\n spot_coords = [spot_id] + row[2:5]\\n coord_list.append(spot_coords)\\n return coord_list\",\n \"def _xy_locs(mask):\\n y, x = mask.nonzero()\\n return list(zip(x, y))\",\n \"def arrays(pos, line):\\n list = []\\n num = line.shape[0]\\n for n in range(num):\\n list.append(line[n][pos])\\n list = np.asarray(list)\\n\\n return list\",\n \"def index_coords(data, origin=None):\\r\\n ny, nx = data.shape[:2]\\r\\n if origin is None :\\r\\n origin_x, origin_y = nx // 2, ny // 2\\r\\n else :\\r\\n origin_x, origin_y = origin\\r\\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\\r\\n x -= origin_x\\r\\n y -= origin_y\\r\\n return x, y\",\n \"def index_points(points, idx):\\n device = points.device\\n B = points.shape[0]\\n view_shape = list(idx.shape)\\n view_shape[1:] = [1] * (len(view_shape) - 1)\\n repeat_shape = list(idx.shape)\\n repeat_shape[0] = 1\\n batch_indices = torch.arange(B, dtype=torch.long).view(view_shape).repeat(repeat_shape)\\n new_points = points[batch_indices, idx, :]\\n return new_points\",\n \"def _sort_index(self):\\n\\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\\n\\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\\n\\n for i, traceItem in enumerate(self.data):\\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\\n for j, altPos in enumerate(allAltPos):\\n for k, aziPos in enumerate(allAziPos):\\n if alt==altPos and azi==aziPos:\\n if sign==1:\\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\\n else: indON[j][k]=i\\n\\n if sign==-1:\\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\\n else: indOFF[j][k]=i\\n\\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\\n\\n return indON,indOFF,allAltPos,allAziPos\",\n \"def index_to_xy(index):\\n x = index % columns\\n y = index // columns\\n return x, y\",\n \"def row_to_indices(row):\\r\\n return [(row, col) for col in range(0, 9)]\",\n \"def find_coord_indices(lon_array, lat_array, lon_points, lat_points, proj_str):\\n\\n proj = Proj(proj_str)\\n proj_lon, proj_lat = np.array(proj(lon_array, lat_array)) # transform to distances using specified projection\\n lonlat = np.column_stack(\\n (proj_lon.ravel(), proj_lat.ravel())) # Stack all coarse x, y distances for array shape (n, 2)\\n ll = np.array(proj(lon_points, lat_points)).T # transform lists of fine grid x, y to match shape (n, 2)\\n idx = cdist(lonlat, ll).argmin(0) # Calculate all distances and get index of minimum\\n\\n return np.column_stack((np.unravel_index(idx, lon_array.shape))).tolist()\",\n \"def get_arr_edge_indices(arr, res='4x5', extra_points_point_on_edge=None,\\n verbose=True, debug=False):\\n if verbose:\\n print(('get_arr_edge_indices for arr of shape: ', arr.shape))\\n\\n # initialise variables\\n lon_c, lat_c, NIU = get_latlonalt4res(res=res, centre=True)\\n lon_e, lat_e, NIU = get_latlonalt4res(res=res, centre=False)\\n lon_diff = lon_e[-5]-lon_e[-6]\\n lat_diff = lat_e[-5]-lat_e[-6]\\n nn, n, = 0, 0\\n last_lat_box = arr[nn, n]\\n coords = []\\n last_lon_box = arr[nn, n]\\n need_lon_outer_edge, need_lat_outer_edge = False, False\\n if debug:\\n print((lon_e, lat_e))\\n\\n # ---- Loop X dimension ( lon )\\n for nn, lon_ in enumerate(lon_c):\\n\\n # Loop Y dimension ( lat ) and store edges\\n for n, lat_ in enumerate(lat_c):\\n\\n if debug:\\n print((arr[nn, n], last_lat_box, last_lon_box,\\n arr[nn, n] == last_lat_box, arr[nn, n] == last_lon_box))\\n\\n if arr[nn, n] != last_lat_box:\\n\\n # If 1st lat, selct bottom of box\\n point_lon = lon_e[nn]+lon_diff/2\\n if need_lat_outer_edge:\\n point_lat = lat_e[n+1]\\n else:\\n point_lat = lat_e[n]\\n need_lat_outer_edge = True\\n need_lat_outer_edge = False\\n\\n # Add mid point to cordinates list\\n if isinstance(extra_points_point_on_edge, type(None)):\\n mid_point = [point_lon, point_lat]\\n coords += [mid_point]\\n\\n # Add given number of points along edge\\n else:\\n coords += [[lon_e[nn]+(lon_diff*i), point_lat] for i in\\n np.linspace(0, 1, extra_points_point_on_edge,\\n endpoint=True)]\\n\\n # temporally save the previous box's value\\n last_lat_box = arr[nn, n]\\n\\n # ---- Loop Y dimension ( lat )\\n for n, lat_ in enumerate(lat_c):\\n\\n if debug:\\n print((arr[nn, n], last_lat_box, last_lon_box,\\n arr[nn, n] == last_lat_box, arr[nn, n] == last_lon_box))\\n # Loop X dimension ( lon ) and store edges\\n for nn, lon_ in enumerate(lon_c):\\n\\n # If change in value at to list\\n if arr[nn, n] != last_lon_box:\\n point_lat = lat_e[n]+lat_diff/2\\n\\n # Make sure we select the edge lon\\n if need_lon_outer_edge:\\n point_lon = lon_e[nn+1]\\n else:\\n point_lon = lon_e[nn]\\n need_lon_outer_edge = True\\n need_lon_outer_edge = False\\n\\n # Add mid point to coordinates list\\n if isinstance(extra_points_point_on_edge, type(None)):\\n mid_point = [point_lon, point_lat]\\n coords += [mid_point]\\n\\n # Add given number of points along edge\\n else:\\n coords += [[point_lon, lat_e[n]+(lat_diff*i)] for i in\\n np.linspace(0, 1, extra_points_point_on_edge,\\n endpoint=True)]\\n\\n # temporally save the previous box's value\\n last_lon_box = arr[nn, n]\\n\\n return coords\",\n \"def index_coords(data, origin=None):\\n ny, nx = data.shape[:2]\\n if origin is None:\\n origin_x, origin_y = nx // 2, ny // 2\\n else:\\n origin_x, origin_y = origin\\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\\n x -= origin_x\\n y -= origin_y\\n return x, y\",\n \"def points(self):\\n return np.vstack((self.x(), self.y()))\",\n \"def createCoordTuples(data):\\n data['xy'] = None\\n for i, row in data.iterrows():\\n data['xy'][i] = [np.round(row['geometry'].x, decimals=5), np.round(row['geometry'].y, decimals=5)]\\n return data\",\n \"def coordinates(self, bin_indices):\\n indices = numpy.asarray(bin_indices).transpose()\\n coords = [numpy.interp(i, range(n), c)\\n for (i, n, c) in zip(indices, self.shape, self.centers)]\\n coords_arr = numpy.array(coords).transpose()\\n return numpy.atleast_2d(coords_arr)\",\n \"def idx_to_list(bytez):\\n # byte 0: 0\\n # byte 1: 0\\n if not (bytez[0] == 0 and bytez[1] == 0):\\n raise IOError(\\\"IDX file should start with two 0 bytes\\\")\\n\\n # byte 2: The number of dimensions\\n # byte 3: The type code\\n typebyte = bytez[2]\\n numdims = bytez[3]\\n\\n # 4 bytes for each dimension: size of dimensions\\n fmtstring = '>' + 'i'*numdims\\n dimension_sizes = struct.unpack(fmtstring, bytez[4:4+4*numdims])\\n\\n # Rest of the data starts here\\n startoffset = 4 + 4*numdims\\n\\n typedata = {\\n 0x08: ('B', 1),\\n 0x09: ('b', 1),\\n 0x0B: ('h', 2),\\n 0x0C: ('i', 4),\\n 0x0D: ('f', 4),\\n 0x0E: ('d', 8)\\n }\\n\\n typecode = typedata[typebyte][0]\\n flatarray = array.array(typecode, bytez[startoffset:])\\n if sys.byteorder == 'little':\\n flatarray.byteswap()\\n\\n if flatarray.itemsize != typedata[typebyte][1]:\\n raise EnvironmentError(\\\"It's assumed a C int is 4 bytes\\\")\\n\\n def _recursive(inputlst, dimsizes):\\n \\\"\\\"\\\"Recursively split the flat list into chunks and merge them back into a\\n nested list structure.\\\"\\\"\\\"\\n if len(dimsizes) == 1:\\n return list(inputlst)\\n\\n outerlist = []\\n chunksize = len(inputlst)//dimsizes[0]\\n for i in range(0, len(inputlst), chunksize):\\n chunk = inputlst[i:i+chunksize]\\n outerlist.append(_recursive(chunk, dimsizes[1:]))\\n\\n return outerlist\\n\\n return _recursive(flatarray, dimension_sizes)\",\n \"def entries(self):\\n out = []\\n for y,x in self.coords(False):\\n out.append((y,x,self.retrieve(y,x)))\\n return out\",\n \"def coords(self, point):\\n\\n ref_x, ref_y = point\\n index_row, index_col = self.index\\n fp_coords = []\\n for offset in self.offsets:\\n x_off = (offset[1] - index_col) * self.cell_size + ref_x\\n y_off = (index_row - offset[0]) * self.cell_size + ref_y\\n fp_coords.append((x_off, y_off))\\n return fp_coords\",\n \"def transform_points(transf_matrix, points):\\n if(type(points)==list):\\n temp_pts = [np.array([x[0],x[1],x[2],1]) for x in points]\\n newpts = []\\n for pt in temp_pts:\\n newpts.append((transf_matrix@pt)[:3])\\n else:\\n temp_pts = np.array([points[0],points[1],points[2],1])\\n newpts=(transf_matrix@temp_pts)[:3]\\n return newpts\",\n \"def cell_list(self):\\n lst_of_idx = []\\n height = self.__height\\n width = self.__width\\n for i in range(width):\\n for j in range(height):\\n lst_of_idx.append((i,j))\\n lst_of_idx.append((3,7))\\n return lst_of_idx\",\n \"def loc_data_idx(loc_idx):\\n retval = []\\n for i in as_tuple(loc_idx):\\n if isinstance(i, slice) and i.step is not None and i.step == -1:\\n if i.stop is None:\\n retval.append(slice(0, i.start+1, -i.step))\\n else:\\n retval.append(slice(i.stop+1, i.start+1, -i.step))\\n elif isinstance(i, slice) and i.step is not None and i.step < -1:\\n if i.stop is None:\\n lmin = i.start\\n while lmin >= 0:\\n lmin += i.step\\n retval.append(slice(lmin-i.step, i.start+1, -i.step))\\n else:\\n retval.append(slice(i.stop+1, i.start+1, -i.step))\\n elif is_integer(i):\\n retval.append(slice(i, i+1, 1))\\n else:\\n retval.append(i)\\n return as_tuple(retval)\",\n \"def mapping_to_indices(coords, batch_size):\\n h, w = coords.shape[:2]\\n indices_axis_0 = list(np.repeat(np.arange(batch_size), h * w))\\n indices_axis_1 = [0]\\n indices_axis_2 = list(np.tile(coords[:,:,0].reshape(-1), 2))\\n indices_axis_3 = list(np.tile(coords[:,:,1].reshape(-1), batch_size))\\n return [indices_axis_0, indices_axis_1, indices_axis_2, indices_axis_3]\",\n \"def cvt_points_to_vector(points):\\n\\n return numpy.hstack(points)\",\n \"def GetPointToOneRingPointsArray(self, p_int):\\n ...\",\n \"def xy_to_index(x, y):\\n index = y * columns + x\\n return index\",\n \"def point_to_coords(self, point: Sequence[float]) -> np.ndarray:\\n point = np.asarray(point)\\n result = np.asarray([axis.point_to_number(point) for axis in self.get_axes()])\\n if point.ndim == 2:\\n return result.T\\n return result\",\n \"def _build_points(self, xs, ys):\\n return np.hstack([xs, ys])\",\n \"def points_to_index(points, points_dict):\\r\\n index_locations = ''\\r\\n for point in points:\\r\\n index_locations += str(points_dict[point]) + ' '\\r\\n return index_locations\",\n \"def cell_verts(self, idx):\\r\\n coords = []\\r\\n xyz = [0, 0, 0]\\r\\n cell = self.grid.GetCell(idx[0] - 1, idx[1] - 1, idx[2] - 1)\\r\\n p_ids = cell.GetPointIds()\\r\\n n_ids = pointIds.GetNumberOfIds()\\r\\n for n in range(n_ids):\\r\\n p = p_ids.GetId(n)\\r\\n self.grid.GetPoint(p, xyz)\\r\\n coords.append(copy.deepcopy(xyz))\\r\\n return coords\",\n \"def points(self):\\n p = []\\n for v in self.iter():\\n p.append((v.x, v.y))\\n return p\",\n \"def arrayTo2DPts(direction: str, arr: np.ndarray, ij2xy_func: Callable) -> List[Point]:\\n\\n pts = []\\n for i in range(arr.shape[0]):\\n for j in range(arr.shape[1]):\\n val = arr[i, j]\\n if np.isfinite(val):\\n if direction == 'i':\\n i_int, j_int = i + val, j\\n elif direction == 'j':\\n i_int, j_int = i, j + val\\n else:\\n raise Exception('Unexpected array direction value: {}'.format(direction))\\n x, y = ij2xy_func(i_int, j_int)\\n pts.append(Point(x, y))\\n\\n return pts\",\n \"def generate_bitmap_to_linear_index_map(bladeTupList, firstIdx):\\n bitmap_map = np.zeros(len(bladeTupList), dtype=int)\\n for ind, blade in enumerate(bladeTupList):\\n bitmap_map[compute_bitmap_representation(blade, firstIdx)] = ind\\n return bitmap_map\",\n \"def trans_to_coordinates(T, pts):\\n p = []\\n for i in range(len(pts)):\\n \\n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\\n p_a = np.matmul(T, p_b).tolist()\\n p.append(p_a[0:3])\\n\\n return p\",\n \"def trans_to_coordinates(T, pts):\\n p = []\\n for i in range(len(pts)):\\n \\n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\\n p_a = np.matmul(T, p_b).tolist()\\n p.append(p_a[0:3])\\n\\n return p\",\n \"def get_data_by_indexes(indexes: list, data: np.ndarray) -> np.ndarray:\\n return np.asarray([data[i, j] for i, j in indexes])\",\n \"def reconstruct_input(self, ix):\",\n \"def coords_to_positions(self, coords):\\n return [self.to_position(x, y, i, j) for (x, y, i, j) in coords]\",\n \"def get_indices(min_lat, max_lat, min_lon, max_lon, lons, lats):\\n\\n distances1, distances2, indices = [], [], []\\n index = 1\\n for point in lats:\\n s1 = max_lat - point\\n s2 = min_lat - point\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index - 1))\\n index = index + 1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n distances1, distances2 = [], []\\n index = 1\\n for point in lons:\\n s1 = max_lon - point\\n s2 = min_lon - point\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index - 1))\\n index = index + 1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # max_lat_indices, min_lat_indices, max_lon_indices, min_lon_indices.\\n res = np.zeros((4), dtype=np.float64)\\n res[0] = indices[3][2]\\n res[1] = indices[2][2]\\n res[2] = indices[1][2]\\n res[3] = indices[0][2]\\n return res\",\n \"def _vertex_arrays_to_list(x_coords_metres, y_coords_metres):\\n\\n _check_polyline(\\n x_coords_metres=x_coords_metres, y_coords_metres=y_coords_metres)\\n\\n num_vertices = len(x_coords_metres)\\n vertex_list_xy_metres = []\\n for i in range(num_vertices):\\n vertex_list_xy_metres.append((x_coords_metres[i], y_coords_metres[i]))\\n\\n return vertex_list_xy_metres\",\n \"def GetPointToIncidentEdgesArray(self, p_int):\\n ...\",\n \"def site_indexes_to_coords(results, site_coords):\\n coords = []\\n for i in range(0,len(results)):\\n cursites = results[i]['coveringsites']\\n if len(cursites) > 0: #clean out empty end stages\\n tmpcoords = []\\n for ind in cursites:\\n tmpcoords.append(site_coords[ind])\\n coords.append(tmpcoords)\\n return coords\",\n \"def xy2ind(x, y, xdim):\\n if isinstance(x, np.ndarray):\\n return x + (y * xdim)\\n else:\\n return int(x) + int(y) * xdim\",\n \"def dlib_point_to_np_array(point: dlib.point):\\n return np.array([point.x, point.y])\",\n \"def _parse_points(self, scan_data):\\n \\n # check data\\n if not scan_data['mz_data'] or not scan_data['int_data']:\\n return []\\n \\n # decode data\\n mz_data = base64.b64decode(scan_data['mz_data'])\\n int_data = base64.b64decode(scan_data['int_data'])\\n \\n # decompress data\\n if scan_data['mz_compression'] == 'zlib':\\n mz_data = zlib.decompress(mz_data)\\n \\n if scan_data['int_compression'] == 'zlib':\\n int_data = zlib.decompress(int_data)\\n \\n # get precision\\n mz_precision = 'f'\\n if scan_data['mz_precision'] == 64:\\n mz_precision = 'd'\\n \\n int_precision = 'f'\\n if scan_data['int_precision'] == 64:\\n int_precision = 'd'\\n \\n # convert from binary\\n count = len(mz_data) // struct.calcsize('<' + mz_precision)\\n mz_data = struct.unpack('<' + mz_precision * count, mz_data[0:len(mz_data)])\\n \\n count = len(int_data) // struct.calcsize('<' + int_precision)\\n int_data = struct.unpack('<' + int_precision * count, int_data[0:len(int_data)])\\n \\n # format\\n if scan_data['spectrum_type'] == 'centroided':\\n points = map(list, zip(mz_data, int_data))\\n else:\\n mz_data = numpy.array(mz_data)\\n mz_data.shape = (-1, 1)\\n int_data = numpy.array(int_data)\\n int_data.shape = (-1, 1)\\n data = numpy.concatenate((mz_data,int_data), axis=1)\\n points = data.copy()\\n \\n return points\",\n \"def calcul_xy_array(img_x, img_y, tile_x, tile_y):\\n array = []\\n\\n modu_x = img_x % tile_x\\n modu_y = img_y % tile_y\\n div_x = img_x // tile_x\\n div_y = img_y // tile_y\\n current_x = 0\\n current_y = 0\\n\\n for i in range(div_y):\\n for j in range(div_x):\\n array.append((current_x, current_y))\\n current_x += tile_x\\n if modu_x:\\n array.append((img_x - tile_x, current_y))\\n current_y += tile_y\\n current_x = 0\\n\\n if modu_y:\\n current_y = img_y - tile_y\\n for j in range(div_x):\\n array.append((current_x, current_y))\\n current_x += tile_x\\n if modu_x:\\n array.append((img_x - tile_x, current_y))\\n\\n return array\",\n \"def as_numpy_array_2D(self):\\n wx = []\\n wy = []\\n for wp in self.waypoints:\\n wx.append(wp.location.x)\\n wy.append(wp.location.y)\\n return np.array([wx, wy])\",\n \"def extract_data(data_file):\\n\\n data_points = set()\\n points_to_coordinates = {}\\n x_coor_dict = {}\\n # need this since we need to iterate through the first point indices in a fixed order\\n first_point_indices = []\\n\\n with open(data_file) as input_file:\\n # consume the first line, it only tells us how many points there are\\n input_file.readline()\\n point_number = 0\\n current_x_coor = inf\\n # point that's used as the indexing point for a list of points with the same x coordinates\\n first_point_index = 1\\n\\n for line in input_file:\\n point_number += 1\\n line = line.strip('\\\\n')\\n split_line = line.split(\\\" \\\")\\n print(split_line)\\n x_coor = float(split_line[1])\\n # if we're seeing this x coordinate for the first time\\n if current_x_coor != x_coor:\\n first_point_index = point_number\\n first_point_indices.append(first_point_index)\\n x_coor_dict[first_point_index] = []\\n current_x_coor = x_coor\\n x_coor_dict[first_point_index].append(point_number)\\n new_point = Point(x_coor, float(split_line[2]))\\n points_to_coordinates[point_number] = new_point\\n data_points.add(point_number)\\n\\n return data_points, points_to_coordinates, x_coor_dict, first_point_indices\",\n \"def _build_point_grid(n_per_side: int) -> np.ndarray:\\n offset = 1 / (2 * n_per_side)\\n points_one_side = np.linspace(offset, 1 - offset, n_per_side)\\n points_x = np.tile(points_one_side[None, :], (n_per_side, 1))\\n points_y = np.tile(points_one_side[:, None], (1, n_per_side))\\n points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2)\\n return points\",\n \"def coordinates_of(self, coord_index_list):\\n return [self.transformed_coords[i] for i in coord_index_list]\",\n \"def serialize(self):\\n out_list = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\\n\\n for num, (i, j) in self.num_to_pos.items():\\n out_list[i][j] = num\\n\\n return out_list\",\n \"def atom_idxs(self):\\n\\n return np.array([atom.atom_idxs for atom in self])\",\n \"def open_xy(data):\\n twotheta, intensity = [], []\\n with open(data) as f:\\n for line in f:\\n row = line.split()\\n twotheta.append(row[0])\\n intensity.append(row[1])\\n xyarray = list(zip(twotheta, intensity))\\n xyarray = np.asarray(xyarray)\\n xyarray = xyarray.astype(np.float)\\n return xyarray\",\n \"def get_positions(p_state, idx_image=-1, idx_chain=-1):\\n nos = system.get_nos(p_state, idx_image, idx_chain)\\n ArrayType = scalar*3*nos\\n Data = _Get_Positions(ctypes.c_void_p(p_state), ctypes.c_int(idx_image), ctypes.c_int(idx_chain))\\n array_pointer = ctypes.cast(Data, ctypes.POINTER(ArrayType))\\n array = np.frombuffer(array_pointer.contents, dtype=scalar)\\n array_view = array.view()\\n array_view.shape = (nos, 3)\\n return array_view\",\n \"def get_all_coordinates(self):\\n coordinates = []\\n\\n for relative_coordinate in self.shape:\\n co = [self.coordinate[0] + relative_coordinate[0], self.coordinate[1] + relative_coordinate[1]]\\n coordinates.append(co)\\n return coordinates\",\n \"def xy_to_idx(self, xs, ys, mask=None, mask_outside=False, nodata=-1):\\n _, ncol = self.shape\\n r, c = self.rowcol(xs, ys, mask=mask, mask_outside=mask_outside, nodata=nodata)\\n mask = r != nodata\\n idx = np.full(r.shape, nodata, dtype=int)\\n idx[mask] = r[mask] * ncol + c[mask]\\n return idx\",\n \"def list_to_idx(lst, typecode):\\n magicnumber = _build_magic_number(lst, typecode)\\n dimension_sizes = _build_dimension_sizes(lst)\\n data = _build_data(lst, typecode)\\n\\n return magicnumber + dimension_sizes + data\",\n \"def toArray(parsedList):\\n interpretCommand = {\\n 'C' : lambda x, prevL : x[-2:], # bezier curve. Ignore the curve.\\n 'L' : lambda x, prevL : x[0:2],\\n 'M' : lambda x, prevL : x[0:2],\\n 'Z' : lambda x, prevL : prevL[0],\\n }\\n\\n points =[]\\n for i,(c, arg) in enumerate(parsedList):\\n #debug('toArray ', i, c , arg)\\n newp = interpretCommand[c](arg, points)\\n points.append( newp)\\n a=numpy.array( points )\\n\\n # Some times we have points *very* close to each other\\n # these do not bring any meaning full info, so we remove them\\n #\\n x,y, w,h = computeBox(a)\\n sizeC = 0.5*(w+h)\\n #deltas = numpy.zeros((len(a),2) )\\n deltas = a[1:] - a[:-1] \\n #deltas[-1] = a[0] - a[-1]\\n deltaD = numpy.sqrt(numpy.sum( deltas**2, 1 ))\\n sortedDind = numpy.argsort(deltaD)\\n # expand longuest segments\\n nexp = int(len(deltaD)*0.9)\\n newpoints=[ None ]*len(a)\\n medDelta = deltaD[sortedDind[len(deltaD)/2] ]\\n for i,ind in enumerate(sortedDind):\\n if deltaD[ind]/sizeC<0.005: continue\\n if i>nexp:\\n np = int(deltaD[ind]/medDelta)\\n pL = [a[ind]]\\n #print i,'=',ind,'adding ', np,' _ ', deltaD[ind], a[ind], a[ind+1]\\n for j in range(np-1):\\n f = float(j+1)/np\\n #print '------> ', (1-f)*a[ind]+f*a[ind+1]\\n pL.append( (1-f)*a[ind]+f*a[ind+1] )\\n newpoints[ind] = pL\\n else:\\n newpoints[ind]=[a[ind]]\\n if(D(a[0],a[-1])/sizeC > 0.005 ) :\\n newpoints[-1]=[a[-1]]\\n\\n points = numpy.concatenate([p for p in newpoints if p!=None] )\\n ## print ' medDelta ', medDelta, deltaD[sortedDind[-1]]\\n ## print len(a) ,' ------> ', len(points)\\n\\n rel_norms = numpy.sqrt(numpy.sum( deltas**2, 1 )) / sizeC\\n keep = numpy.concatenate([numpy.where( rel_norms >0.005 )[0],numpy.array([len(a)-1])])\\n\\n #return a[keep] , [ parsedList[i] for i in keep]\\n #print len(a),' ',len(points)\\n return points , []\",\n \"def afficher_points_2D(set_points):\\n X, Y = [p[0][0] for p in set_points], [p[0][1] for p in set_points]\\n return(X, Y)\",\n \"def vertices(self) -> list[Point]:\\n a = Point(self.array[..., 0, :], copy=False)\\n b = Point(self.array[..., 1, :], copy=False)\\n return [a, b]\",\n \"def _indarray(np_array):\\n return skil_client.INDArray(\\n ordering='c',\\n shape=list(np_array.shape),\\n data=np_array.reshape(-1).tolist()\\n )\",\n \"def ind2latlon(index, filePath):\\n # Load georeferencing\\n ds = gdal.Open(filePath)\\n proj = ds.GetProjection()\\n gt = ds.GetGeoTransform()\\n srs = osr.SpatialReference()\\n srs.ImportFromWkt(proj)\\n\\n x0 = gt[0] #top left longitude\\n y0 = gt[3] #top left latitude\\n dx = gt[1] #pixel width\\n dy = gt[5] #pixel height\\n\\n # Convert row,col of array to projected coords\\n row, col = index\\n x = x0 + (col * dx)\\n y = y0 + (row * dy)\\n\\n # Convert projected coords to latlon\\n trs = osr.SpatialReference()\\n trs.ImportFromEPSG(4326)\\n ct = osr.CoordinateTransformation(srs, trs)\\n\\n (lon, lat, height) = ct.TransformPoint(x, y) #note could add elevation\\n #gdal.DecToDMS(lat, 'Lat', 2)\\n\\n return lon, lat\",\n \"def get_array_of_matching_points(size, triangles_list,\\n intermediate_triangles_list):\\n\\n # initiate the 2D array\\n matching_points_list = [[] for _ in range(size[1])]\\n # run over each coordinate in the 2D array by the given size\\n\\n for i in range(0, size[1]):\\n for j in range(0, size[0]):\\n # search for the right intermediate triangle\\n for k in range(0,len(intermediate_triangles_list)):\\n # the current intermediate triangle\\n inter_tri = intermediate_triangles_list[k]\\n # the tuple containing if the point is inside and its\\n # coefficients\\n point_tuple = is_point_inside_triangle((j, i), inter_tri[0],\\n inter_tri[1],\\n inter_tri[2])\\n if point_tuple[0]:\\n # if the current point is inside the current intermediate\\n # triangle append the converted point to the list\\n matching_points_list[i].\\\\\\n append(convert_point(triangles_list[k],point_tuple[1]))\\n break\\n return matching_points_list\",\n \"def pt_index(*args):\\n index = []\\n x = check_pt_data(args[0])\\n i = 0\\n for line in args[0].Data.PTData.pt_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def get_coordinates_list(self):\\n return [tweet['coordinates'][::-1] for tweet in self.tweets_data]\",\n \"def GetPointToIncidentFacesArray(self, p_int):\\n ...\",\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 _make_coord_array(t,d):\\n Nt,Nd = t.shape[0],d.shape[0]\\n X = np.zeros([Nt,Nd,3],dtype=np.float64)\\n for j in range(Nt):\\n for k in range(Nd):\\n X[j,k,0] = t[j]\\n X[j,k,1:3] = d[k,:]\\n X = np.reshape(X,(Nt*Nd,3))\\n return X\",\n \"def _update_imgs_and_pt_list(self, points, edge_points, segs, index):\\n # index specifies whether to use the x or y coordinate in x_pts\\n x_pts=[]\\n for i in range(0, len(points)):\\n pt=points[i]\\n #edge_points[pt[0],pt[1]] = 255\\n x_pts.append(pt[index])\\n #segs[pt[0],pt[1]]=150\\n\\n return x_pts, segs, edge_points\",\n \"def xy(self):\\n xcol = self.xx.reshape(-1, 1)\\n ycol = self.yy.reshape(-1, 1)\\n return np.column_stack([xcol, ycol])\",\n \"def _indices_to_coords(c,r):\\n\\n column = _index_to_column(c)\\n row = r + 1\\n\\n return {'c': column, 'r': row, 'coord': f'{column}{row}'}\",\n \"def create_points(number): \\n\\n # generate x and y coordinates:\\n x = np.random.permutation(2*number)[:number] - number\\n y = np.random.permutation(2*number)[:number] - number\\n\\n points = [ { 0 : float(x[i]), 1 : float(y[i]), \\\"index\\\" : i} for i in range(len(x)) ]\\n\\n return points\\n\\n # generate points as coordinate pairs of floats.\\n # return zip(map(float,x),map(float,y))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62952024","0.6216155","0.6199011","0.60683894","0.6059465","0.6004489","0.5989433","0.5935704","0.5931404","0.59047157","0.5871109","0.58357066","0.58297163","0.5827456","0.58271873","0.582091","0.57979715","0.57417595","0.5718235","0.57016736","0.57009315","0.5683606","0.56678474","0.56647587","0.5660959","0.56494284","0.5643414","0.5623256","0.56187034","0.56158704","0.56146115","0.561147","0.55980796","0.5596219","0.55789185","0.55713177","0.5552025","0.5539148","0.5527089","0.5515693","0.5509251","0.5506674","0.5502662","0.54969364","0.5491584","0.54876804","0.5486213","0.54814285","0.5472609","0.54674566","0.5462716","0.54600966","0.5456542","0.54501927","0.54472977","0.5443693","0.5432634","0.5430563","0.5426187","0.54257363","0.5423638","0.5415404","0.54119265","0.54119265","0.5407222","0.54020983","0.54016757","0.5397038","0.5396884","0.5391305","0.5384995","0.53807735","0.5380004","0.5367482","0.53670347","0.53646183","0.5359596","0.53516483","0.5345103","0.5341541","0.53414553","0.5338869","0.5333934","0.5330773","0.53270125","0.532628","0.53203994","0.5318174","0.5315767","0.530858","0.5308253","0.5307003","0.53061825","0.53000003","0.52997756","0.5298242","0.529779","0.5297669","0.52957505","0.5293229","0.528944"],"string":"[\n \"0.62952024\",\n \"0.6216155\",\n \"0.6199011\",\n \"0.60683894\",\n \"0.6059465\",\n \"0.6004489\",\n \"0.5989433\",\n \"0.5935704\",\n \"0.5931404\",\n \"0.59047157\",\n \"0.5871109\",\n \"0.58357066\",\n \"0.58297163\",\n \"0.5827456\",\n \"0.58271873\",\n \"0.582091\",\n \"0.57979715\",\n \"0.57417595\",\n \"0.5718235\",\n \"0.57016736\",\n \"0.57009315\",\n \"0.5683606\",\n \"0.56678474\",\n \"0.56647587\",\n \"0.5660959\",\n \"0.56494284\",\n \"0.5643414\",\n \"0.5623256\",\n \"0.56187034\",\n \"0.56158704\",\n \"0.56146115\",\n \"0.561147\",\n \"0.55980796\",\n \"0.5596219\",\n \"0.55789185\",\n \"0.55713177\",\n \"0.5552025\",\n \"0.5539148\",\n \"0.5527089\",\n \"0.5515693\",\n \"0.5509251\",\n \"0.5506674\",\n \"0.5502662\",\n \"0.54969364\",\n \"0.5491584\",\n \"0.54876804\",\n \"0.5486213\",\n \"0.54814285\",\n \"0.5472609\",\n \"0.54674566\",\n \"0.5462716\",\n \"0.54600966\",\n \"0.5456542\",\n \"0.54501927\",\n \"0.54472977\",\n \"0.5443693\",\n \"0.5432634\",\n \"0.5430563\",\n \"0.5426187\",\n \"0.54257363\",\n \"0.5423638\",\n \"0.5415404\",\n \"0.54119265\",\n \"0.54119265\",\n \"0.5407222\",\n \"0.54020983\",\n \"0.54016757\",\n \"0.5397038\",\n \"0.5396884\",\n \"0.5391305\",\n \"0.5384995\",\n \"0.53807735\",\n \"0.5380004\",\n \"0.5367482\",\n \"0.53670347\",\n \"0.53646183\",\n \"0.5359596\",\n \"0.53516483\",\n \"0.5345103\",\n \"0.5341541\",\n \"0.53414553\",\n \"0.5338869\",\n \"0.5333934\",\n \"0.5330773\",\n \"0.53270125\",\n \"0.532628\",\n \"0.53203994\",\n \"0.5318174\",\n \"0.5315767\",\n \"0.530858\",\n \"0.5308253\",\n \"0.5307003\",\n \"0.53061825\",\n \"0.53000003\",\n \"0.52997756\",\n \"0.5298242\",\n \"0.529779\",\n \"0.5297669\",\n \"0.52957505\",\n \"0.5293229\",\n \"0.528944\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93484,"cells":{"query":{"kind":"string","value":"Tests whether ``limit_string_length`` works as intended."},"document":{"kind":"string","value":"def test__limit_string_length(string, max_length):\n return limit_string_length(string, max_length)"},"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 _validate_string_max_length(self, value):\n if self.max_length is not None:\n return len(str(value)) <= self.max_length\n else:\n return True","def _str_len_check(text, min_len, max_len):\n if not isinstance(text, str):\n raise ValueError(\"expected string type\")\n if not (min_len <= len(text) <= max_len):\n raise ValueError(f\"length should be between {min_len} and {max_len} characters\")\n return text","def check_length(length):\n if length > lengthLimit:\n err_str = \"The length value (%s) is higher than the \" % (length)\n err_str += \"limit length (%s)\" % (lengthLimit)\n raise ValueError(err_str)","def test_maxlength():\n assert has_max_length(None, 2) is None\n assert has_max_length('abcd1234', 2)\n assert has_max_length('a', 2) is None","def check_string_length(string):\n if len(string) > 255:\n sys.exit(\"ERROR: Max permitted string length is 255\")","def _validate_length(self, value):\n return (self.maximum_length is None) or (len(value) <= self.maximum_length)","def _validate_string_min_length(self, value):\n if self.min_length is not None:\n return len(str(value)) >= self.min_length\n else:\n return True","def test_max_length_validation(self):","def test_max_length_validation(self):","def test_truncates_to_correct_size(self):\n truncated = truncateFeedback(self.simpleTestString)\n self.assertTrue(len(truncated) < 16000)\n truncated = truncateFeedback(self.complicatedString)\n self.assertTrue(len(truncated) < 16000)","def _check_max_length(self, p: list) -> bool:\n\n return (\n len(p[0].split(\" \")) < self.max_length\n and len(p[1].split(\" \")) < self.max_length\n )","def max_length(verifield, required):\n if verifield is None: return True\n return len(verifield) <= required","def test_long_string_positive_length(self):\n self.failUnlessEqual(self.callFunc('encode_longstr', 'hello world'), '\\x00\\x00\\x00\\x0bhello world', 'positive length long string encoding FAILED...')","def test_long_message(self):\n message = \"few characters\"\n message_displayed = truncate_message(message, limit=5)\n\n self.assertLessEqual(len(message_displayed), 5)\n self.assertEqual(message_displayed, \"fe...\")","def test_max_length_option(assert_errors, assert_error_text, options):\n max_length = 55\n filename = 'very_long_name_that_should_not_pass_unless_changed_shorter.py'\n option_values = options(max_name_length=max_length)\n visitor = WrongModuleNameVisitor(option_values, filename=filename)\n visitor.run()\n\n assert_errors(visitor, [TooLongNameViolation])\n assert_error_text(\n visitor, filename.replace('.py', ''), option_values.max_name_length,\n )","def max_length(length):\n def validate(value):\n if len(value) <= length:\n return True\n raise Exception('%s must be at most %s characters long' % length)\n return validate","def test_too_short_limit(self):\n message = \"few characters\"\n\n with self.assertRaises(AssertionError) as error:\n truncate_message(message, limit=2)\n\n self.assertEqual(str(error.exception), \"Limit too short\")","def test_validate_max_length(self):\n test_strings = [\n 'thisloooooooooooooooongstring',\n True,\n 45,\n ]\n\n testrow = TestSchema()\n\n for test_string in test_strings:\n testrow.string_max_field = test_string\n self.assertRaises(Exception, testrow.save)","def filter_max_length(self, string):\n newstring = string\n length = len(newstring)\n max_length = 63\n if length > max_length:\n newstring = newstring[0:max_length]\n\n return newstring","def __size_restriction_inccorrect_string_string(self):\n\n strTestName = 'String size equal to the size of another string (incorrect)'\n RxCSObject = _RxCSobject()\n\n # Firstly, let us define a reference parameter\n RxCSObject.paramAddMan('strRefParameter1', 'Str ref. parameter')\n RxCSObject.paramType('strRefParameter1', str)\n\n # Now, let me define a string\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizEq('parameter1', 'strRefParameter1')\n\n RxCSObject.strRefParameter1 = 'bbbcca'\n RxCSObject.parameter1 = 'aaabb'\n\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)","def __size_restriction_correct_string_string(self):\n\n strTestName = 'String size lower or equal to the size of another string (correct)'\n RxCSObject = _RxCSobject()\n\n # Firstly, let us define a reference parameter\n RxCSObject.paramAddMan('strRefParameter1', 'Str ref. parameter')\n RxCSObject.paramType('strRefParameter1', str)\n\n # Now, let me define a string\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizLE('parameter1', 'strRefParameter1')\n\n RxCSObject.strRefParameter1 = 'bbbccc'\n RxCSObject.parameter1 = 'aaabb'\n\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)","def length_of_name(self, name):\n length = len(name)\n if length > 10:\n self.show_message_when_name_very_long()\n return length","def test_slugs_max_length(self):\n self.assertLessEqual(len(str(self.cat_short.slug)), 50)\n self.assertLessEqual(len(str(self.cat_long.slug)), 50)","def test_websites_name_max_length(self):\n max_length = self.website._meta.get_field('name').max_length\n self.assertEqual(max_length, 25)","def __size_restriction_correct_string_number(self):\n\n strTestName = 'String size equal to a string (correct)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizEq('parameter1', 4)\n\n RxCSObject.parameter1 = 'aaaa'\n\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)","def validate_length(string):\n if len(string) > 110:\n raise ValidationError('Tweet must be less than 110 characters')","def test_stringLiteralTooLong(self):\n self.server._literalStringLimit = 4\n self.server.lineReceived(b\"001 LOGIN {5}\\r\\n\")\n\n self.assertEqual(self.transport.value(),\n b\"001 BAD Illegal syntax: Literal too long!\"\n b\" I accept at most 4 octets\\r\\n\")","def _max_length(self):\n return self.__max_length","def is_name_length_valid(self) -> bool:\n return 2 < len(self.app_name) <= 35","def test_minlength():\n assert has_min_length(None, 8) is None\n assert has_min_length('abcd1234', 8) is None\n assert has_min_length('a', 8)","def test_websites_name_max_length(self):\n max_length = self.website._meta.get_field('className').max_length\n self.assertEqual(max_length, 25)","def test_small_message(self):\n message = \"few characters\"\n message_displayed = truncate_message(message, limit=50)\n\n self.assertLessEqual(len(message_displayed), 50)\n self.assertEqual(message_displayed, \"few characters\")","def test_slugs_max_length(self):\n self.assertLessEqual(len(str(self.art_short.slug)), 50)\n self.assertLessEqual(len(str(self.art_long.slug)), 50)","def __size_restriction_incorrect_string_parameter(self):\n\n strTestName = 'String size higher or equal to a parameter (incorrect)'\n RxCSObject = _RxCSobject()\n\n # Firstly, let us define a reference parameter\n RxCSObject.paramAddMan('iRefParameter1', 'Int parameter')\n RxCSObject.paramType('iRefParameter1', int)\n\n # Now, let me define a string\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizHE('parameter1', 'iRefParameter1', mul=2, add=3)\n\n RxCSObject.iRefParameter1 = 2\n RxCSObject.parameter1 = 'aaabb'\n\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)","def test_client_email_max_length(self):\n request = Request.objects.get(id=1)\n max_length = request._meta.get_field('client_email').max_length\n self.assertEquals(max_length, 100)","def _matchLength(self, length: int):\n return self._comparator['Length'] < length","def valid_message_length(self):\n if self.message_len() > 0:\n if self.message_len() <= self.max_msg_length:\n return True\n return False","def validate_max_length(cls, value: str, field: ModelField) -> str:\n if cls.max_length is not None and len(value) > cls.max_length:\n raise InvalidLengthValue(\n field_name=field.name, constraint=cls.max_length, operation='max'\n )\n return value","def test_client_ip_max_length(self):\n request = Request.objects.get(id=1)\n max_length = request._meta.get_field('client_ip').max_length\n self.assertEquals(max_length, 100)","def _model_string_maxlen():\n # hardcoded for convenience. Could be dynamically set in future.\n # the current longest is: BLOSUM62+I+G+X, i.e. 14 chars.\n # so we just over double it, for safety\n\n return 30","def test_search_terms_max_length(self):\n max_length = self.search._meta.get_field('terms_en').max_length\n self.assertEqual(max_length, 50)","def __size_restriction_correct_string_parameter(self):\n strTestName = 'String size higher than a parameter (correct)'\n RxCSObject = _RxCSobject()\n\n # Firstly, let us define a reference parameter\n RxCSObject.paramAddMan('iRefParameter1', 'Int parameter')\n RxCSObject.paramType('iRefParameter1', int)\n\n # Now, let me define a string\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizH('parameter1', 'iRefParameter1')\n\n RxCSObject.iRefParameter1 = 2\n RxCSObject.parameter1 = 'aaabbbab'\n\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)","def test_category_name_field_max_length(self):\n cat = Category.objects.get(id=1)\n max_length = cat._meta.get_field('name').max_length\n self.assertEqual(max_length, 20)","def validate(cls, **kwargs: Any) -> None:\n max_length = kwargs.get(\"max_length\", None)\n if max_length <= 0:\n raise ModelDefinitionError(\n \"Parameter max_length is required for field String\"\n )","def test_systemstatus_name_length(self):\n\n # get object\n systemstatus_1 = Systemstatus.objects.get(systemstatus_name='systemstatus_1')\n # get max length\n max_length = systemstatus_1._meta.get_field('systemstatus_name').max_length\n # compare\n self.assertEqual(max_length, 30)","def max_length(self):\n\t\treturn self._max_length","def check_len( string_key ) : \r\n\r\n if len( string_key ) != 4 :\r\n\r\n raise Eggog( \"'%s': EGI wants the key to be exactly four characters!\" % (string_key, ) ) \r\n \r\n else :\r\n \r\n return True","def TruncateString(raw_string, max_length):\n if len(raw_string) > max_length:\n return raw_string[:max_length]\n return raw_string","def __size_restriction_incorrect_string_number(self):\n\n strTestName = 'String size lower than a number (incorrect)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizHE('parameter1', 4, mul=2, add=3)\n\n RxCSObject.parameter1 = 'aaa'\n\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)","def test_limit(self):\n\t\tfor lim in [1, '234', -100, '-200']:\n\t\t\tself.filter.set_limit(lim)\n\t\t\tself.assertEqual(int(lim), self.filter.get_limit(), \"Limit mismatch: %s!=%s\" % (lim, self.filter.get_limit()))\n\t\tself.filter.set_limit('test')\n\t\tself.assertEqual('test', self.filter.get_limit(), \"String set failed for Filter limit.\")","def lim_str_len(string, length, end='...'):\n if len(string) <= length:\n return string\n else:\n return '{}{}'.format(string[:length - len(end)], end)","def test_length(self):\n form_data = self.form_data('c897B$eH@')\n form = self.form(data=form_data, user=self.u)\n self.assertFalse(form.is_valid())","def min_length(verifield, required):\n if verifield is None: return True\n return len(verifield) >= required","def _validate_length(data, min, max, err): # lint-amnesty, pylint: disable=redefined-builtin\n if len(data) < min or len(data) > max:\n raise errors.AccountDataBadLength(err)","def test_long_string_zero_length(self):\n self.failUnlessEqual(self.callFunc('encode_longstr', ''), '\\x00\\x00\\x00\\x00', '0 length long string encoding FAILED...')","def _checkString(inputstring, description, minlength=0, maxlength=None):\n # Type checking\n if not isinstance(description, str):\n raise TypeError('The description should be a string. Given: {0!r}'.format(description))\n\n if not isinstance(inputstring, str):\n raise TypeError('The {0} should be a string. Given: {1!r}'.format(description, inputstring))\n\n if not isinstance(maxlength, (int, type(None))):\n raise TypeError('The maxlength must be an integer or None. Given: {0!r}'.format(maxlength))\n\n # Check values\n _checkInt(minlength, minvalue=0, maxvalue=None, description='minlength')\n\n if len(inputstring) < minlength:\n raise ValueError('The {0} is too short: {1}, but minimum value is {2}. Given: {3!r}'.format( \\\n description, len(inputstring), minlength, inputstring))\n\n if not maxlength is None:\n if maxlength < 0:\n raise ValueError('The maxlength must be positive. Given: {0}'.format(maxlength))\n\n if maxlength < minlength:\n raise ValueError('The maxlength must not be smaller than minlength. Given: {0} and {1}'.format( \\\n maxlength, minlength))\n\n if len(inputstring) > maxlength:\n raise ValueError('The {0} is too long: {1}, but maximum value is {2}. Given: {3!r}'.format( \\\n description, len(inputstring), maxlength, inputstring))","def test_short_string_out_of_upper_range(self):\n self.failUnlessRaises(Exception, self.codec.encode_shortstr, 'x'*256)","def check_option(option, max_length):\n res = utils.string_to_num(option)\n if res is None:\n return None\n\n if res < 0 or res >= max_length:\n return None\n return res","def test_short_string_positive_length(self):\n self.failUnlessEqual(self.callFunc('encode_shortstr', 'hello world'), '\\x0bhello world', 'positive length short string encoding FAILED...')","def check_doc_string_len(fn):\r\n free_var_local_count = 50\r\n def check_doc_string_len_inner():\r\n '''This function returns True, if the docstring has minimum\r\n 50 characters else it returns false'''\r\n nonlocal free_var_local_count\r\n if len(fn.__doc__) >= free_var_local_count:\r\n return True\r\n else:\r\n return False\r\n return check_doc_string_len_inner","def test_utils_random_string(self, tcex, string_length):\n result = tcex.utils.random_string(string_length=string_length)\n assert (\n len(result) == string_length\n ), f'The length of the string {len(result)} != {string_length}'","def _stop(self):\n if self.char_limit is not None:\n return self.char_count > self.char_limit\n else:\n return False","def test_models_meetings_name_maxlength(self):\n MeetingFactory(name=\"a\" * 500)\n with self.assertRaises(ValidationError) as context:\n MeetingFactory(name=\"a\" * 501)\n\n self.assertEqual(\n context.exception.messages,\n [\"Ensure this value has at most 500 characters (it has 501).\"],\n )","def test_length_option(assert_errors, assert_error_text, options):\n filename = 'test.py'\n option_values = options(min_name_length=5)\n visitor = WrongModuleNameVisitor(option_values, filename=filename)\n visitor.run()\n\n assert_errors(visitor, [TooShortNameViolation])\n assert_error_text(\n visitor, filename.replace('.py', ''), option_values.min_name_length,\n )","def check_length(string):\n if 6 < len(string) < 12:\n return True\n\n print(\"Your password is not between 6 and 12 characters\")\n return False","def test_encodes_long_string(self):\n result = encode_run_length(\"RRRRRTTEEEQQQQCSDUUIRRTTT\")\n self.assertEqual(result, \"5R2T3E4Q1C1S1D2U1I2R3T\")","def max_length(self) -> int | None:\n return self._underlying.max_length","def test_check_name_is_3_parts():\n check_name_length()","def test_trim_too_long_filename(self):\n filename = 'filename'\n extension = '.jpg'\n long_filename = '{}{}'.format(filename * 10, extension)\n\n trimmed_filename = trim_long_filename(long_filename)\n \n self.assertEqual(len(trimmed_filename), FILENAME_MAX_LEN)\n self.assertTrue(trimmed_filename.startswith(filename))\n self.assertTrue(trimmed_filename.endswith(extension))","def test_more_than_max_length_invalid_password(self):\n pass_field = Field(\"\".join(['x' * (int(self.app.config['MAX_PWD_LEN']) + 1)]))\n\n with self.assertRaises(ValidationError):\n valid_password(None, pass_field)","def test_search_form_terms_max(self):\n form = SearchForm()\n max_length = form.fields['terms_en'].max_length\n min_length = form.fields['terms_en'].min_length\n self.assertEqual(max_length, 50)\n self.assertEqual(min_length, 1)","def test_utils_truncate_string(self, tcex, input_, length, append_chars, spaces, expected):\n result = tcex.utils.truncate_string(input_, length, append_chars, spaces)\n print('\\nstring', input_)\n print('result', result)\n print('expect', expected)\n assert result == expected, f'Input {input_} result of {result} != {expected}'","def within_length(flowgram, minlength=0, maxlength=400):\r\n seq = flowgram.toSeq()\r\n l = len(seq)\r\n return (l >= minlength and l <= maxlength)","def test_maxlength(self):\n val = DwcaValidator(yaml.load(self.yaml_length, Loader=yaml.FullLoader),\n error_handler=WhipErrorHandler)\n document = {'license_plate': 'AF8934'}\n self.assertTrue(val.validate(document))\n\n document = {'license_plate': '123456'}\n self.assertTrue(val.validate(document))\n\n document = {'license_plate': 'AF893'}\n self.assertTrue(val.validate(document))\n\n document = {'license_plate': 'AF8-934'}\n self.assertFalse(val.validate(document))\n\n document = {'license_plate': 'AF 934'}\n self.assertFalse(val.validate(document))","def test_rfc_nickkey_length(s):\n assert len(util.rfc_nickkey(s)) == len(s)","def test_max_str(self):\n self.assertEqual(max_integer(\"abcdef\"), \"f\")","def __get_max_length(self):\n\t\tif self.version == 1:\n\t\t\treturn 19\n\t\telif self.version == 2:\n\t\t\treturn 34\n\t\telif self.version == 3:\n\t\t\treturn 55\n\t\telif self.version == 4:\n\t\t\treturn 80\n\t\telif self.version == 5:\n\t\t\treturn 108\n\t\telif self.version == 6:\n\t\t\treturn 136\n\t\telse:\n\t\t\treturn \"Version number > 6 not supported\"","def test_field_len(self):\n client = self.base_scenario(\n frang_config=\"http_field_len 300;\",\n requests=[f\"POST /1234 HTTP/1.1\\r\\nHost: localhost\\r\\nX-Long: {'1' * 320}\\r\\n\\r\\n\"],\n )\n self.check_response(\n client,\n status_code=\"403\",\n warning_msg=\"frang: HTTP (in-progress )?field length exceeded for\",\n )","def checklength(config, tokenizer):\n\n # Unpack nested config, handles passing model directly\n if hasattr(config, \"config\"):\n config = config.config\n\n if (\n hasattr(config, \"max_position_embeddings\")\n and tokenizer\n and hasattr(tokenizer, \"model_max_length\")\n and tokenizer.model_max_length == int(1e30)\n ):\n tokenizer.model_max_length = config.max_position_embeddings","def test_long_name():\n expect_error(register, InputError,\n \"a\", \"abcdef\", \"a\" * (MAX_NAME + 1), \"a\", \"a\")\n expect_error(register, InputError,\n \"a\", \"abcdef\", \"a\", \"a\" * (MAX_NAME + 1), \"a\")","def clean_content_length(field_name, min_length=0, max_length=500):\n\n @check_field_is_empty(field_name)\n def wrapper(self):\n \"\"\"Decorator wrapper method.\n \"\"\"\n\n value = self.cleaned_data[field_name]\n value_length = len(value)\n\n if value_length < min_length:\n raise forms.ValidationError(DEF_MUST_BE_ABOVE_LIMIT_FMT %(\n min_length, value_length))\n\n if value_length > max_length:\n raise forms.ValidationError(DEF_MUST_BE_UNDER_LIMIT_FMT %(\n max_length, value_length))\n\n return value\n return wrapper","def test_uid_max_length(self):\n\n field = self.image._meta.get_field(\"uid\")\n self.assertEqual(field.max_length, 64)","def get_field_length_error_text(field_name):\n\n\treturn(\"Value entered for '{0}' exceeds character length limit of {1}\"\n\t\t .format(field_name, str(field_length_limit)))","def _truncate_string(cls, s1, s2, max_len):\n s1_len = len(s1.split(' '))\n s2_len = len(s2.split(' '))\n MIN_S2_LEN = 6\n if s1_len + s2_len <= max_len or s2_len < MIN_S2_LEN:\n return s2, False\n\n truncate_point = MIN_S2_LEN if s1_len > max_len else max_len - s1_len\n\n return ' '.join(s2.split(' ')[0:truncate_point]), True","def _check_blurb_length(self: SynopsisImpl, docstring: PetscDocStringImpl, cursor: Cursor, blurb_items: Synopsis.BlurbItemType) -> None:\n total_blurb = [line for _, line in blurb_items]\n word_count = sum(len(l.split()) for l in total_blurb)\n char_count = sum(map(len, total_blurb))\n\n max_char_count = 250\n max_word_count = 40\n if char_count > max_char_count and word_count > max_word_count:\n mess = f\"Synopsis for '{cursor.name}' is too long (must be at most {max_char_count} characters or {max_word_count} words), consider moving it to Notes. If you can't explain it simply, then you don't understand it well enough!\"\n docstring.add_diagnostic_from_source_range(\n Diagnostic.Kind.ERROR, self.diags.verbose_description, mess, self.extent, highlight=False\n )\n return","def test_lineLength(self):\n failures = []\n for line in self.output:\n if not len(line) <= lineWidth:\n failures.append(len(line))\n if failures:\n self.fail(\"%d of %d lines were too long.\\n\"\n \"%d < %s\" % (len(failures), len(self.output),\n lineWidth, failures))","def test01_password_length(self):\n self.set_complexity(length=13, numeric=0, upper=0, lower=0, special=0)\n\n invalid = (\n \"A\",\n \"Tr0ub4dor&3\",\n \"!!!!!!!!!!!!\",\n \"Password\",\n \"Password123!\",\n \"admin\",\n )\n self.assertPasswordsInvalid(invalid)\n\n valid = (\n \"correcthorsebatterystaple\",\n \"abcdefghijklmopqrstuvwxyz\",\n \"12345678901234567890\",\n \"!!!!!!!!!!!!!\" \"Password123!___\",\n )\n self.set_passwords(valid)","def test_minmaxlength(self):\n val = DwcaValidator(yaml.load(self.yaml_length, Loader=yaml.FullLoader),\n error_handler=WhipErrorHandler)\n document = {'code': 'AA'}\n self.assertTrue(val.validate(document))\n\n document = {'code': 'A'}\n self.assertFalse(val.validate(document))\n\n document = {'code': 'ABC'}\n self.assertFalse(val.validate(document))","def test_character_count(self):\r\n from chatterbot_corpus.corpus import DIALOG_MAXIMUM_CHARACTER_LENGTH\r\n\r\n corpora = corpus.load_corpus('chatterbot.corpus')\r\n\r\n for conversations in corpora:\r\n for conversation in conversations:\r\n for statement in conversation:\r\n if len(statement) > DIALOG_MAXIMUM_CHARACTER_LENGTH:\r\n self.fail(\r\n u'\"{}\" cannot be longer than {} characters'.format(\r\n statement,\r\n DIALOG_MAXIMUM_CHARACTER_LENGTH\r\n )\r\n )","def _check_field_length(self, field, value, options=None):\n options = options if options else field.GetOptions()\n for (option, setting) in options.ListFields():\n if option.name == \"length\":\n if self.__gt_by_type(value, setting):\n if hasattr(field, \"name\"):\n raise FieldTooLongException(\"The field '\" + field.name +\n \"' is bigger than the allowed \" + str(setting) + \" bytes\")\n else:\n raise FieldTooLongException(\"List element '\" + str(value) +\n \"' is bigger than the allowed \" + str(setting) + \" bytes\")","def is_too_long(file_name: str) -> bool:\n return len(file_name + REPORT_FILE_EXT) > 255","def test_prep_charfield_size(self):\n pass","def _truncate_string(self, text, max_size):\n import textwrap\n\n if len(text) <= max_size:\n return text\n return textwrap.wrap(text, max_size-3)[0] + \"...\"","def validate_length(column_name, value, length):\n valuelength = len(value)\n if valuelength > int(length) >= 0:\n return \"{0} : value '{1}' is greater than the specified length {2}\".format(column_name, value, length)\n elif valuelength < int(length) and int(length) >= 0:\n return \"{0} : value '{1}' is less than the specified length {2}\".format(column_name, value, length)\n\n return None","def test_len(self):\n self.assertEqual(len(self.tester), 30)","def validate_min_max_length(column_name, value, min_length, max_length):\n valuelength = len(value)\n if (valuelength < int(min_length) or valuelength > int(max_length) and (\n int(min_length) >= 0 and int(max_length) >= 0)):\n return \"{0} : Length of value '{1}' is not in range of {2}-{3}\".format(column_name, value, min_length,\n max_length)\n return None","def check_this_input(self, inp, max_len):\n\t\tst = inp.get()\n\t\tst = st.strip()\n\t\treturn st if len(st) > 0 and len(st) < max_len else None","def test_uri_len_on_the_limit(self):\n client = self.base_scenario(\n frang_config=\"http_uri_len 5;\",\n requests=[\"POST /1234 HTTP/1.1\\r\\nHost: localhost\\r\\n\\r\\n\"],\n )\n self.check_response(\n client, status_code=\"200\", warning_msg=\"frang: HTTP URI length exceeded for\"\n )","def longer_than_9(value):\n if len(value) < 10:\n raise forms.ValidationError('must be 10 characters or longer')","def supportedLength(self):\n raise NotImplementedError"],"string":"[\n \"def _validate_string_max_length(self, value):\\n if self.max_length is not None:\\n return len(str(value)) <= self.max_length\\n else:\\n return True\",\n \"def _str_len_check(text, min_len, max_len):\\n if not isinstance(text, str):\\n raise ValueError(\\\"expected string type\\\")\\n if not (min_len <= len(text) <= max_len):\\n raise ValueError(f\\\"length should be between {min_len} and {max_len} characters\\\")\\n return text\",\n \"def check_length(length):\\n if length > lengthLimit:\\n err_str = \\\"The length value (%s) is higher than the \\\" % (length)\\n err_str += \\\"limit length (%s)\\\" % (lengthLimit)\\n raise ValueError(err_str)\",\n \"def test_maxlength():\\n assert has_max_length(None, 2) is None\\n assert has_max_length('abcd1234', 2)\\n assert has_max_length('a', 2) is None\",\n \"def check_string_length(string):\\n if len(string) > 255:\\n sys.exit(\\\"ERROR: Max permitted string length is 255\\\")\",\n \"def _validate_length(self, value):\\n return (self.maximum_length is None) or (len(value) <= self.maximum_length)\",\n \"def _validate_string_min_length(self, value):\\n if self.min_length is not None:\\n return len(str(value)) >= self.min_length\\n else:\\n return True\",\n \"def test_max_length_validation(self):\",\n \"def test_max_length_validation(self):\",\n \"def test_truncates_to_correct_size(self):\\n truncated = truncateFeedback(self.simpleTestString)\\n self.assertTrue(len(truncated) < 16000)\\n truncated = truncateFeedback(self.complicatedString)\\n self.assertTrue(len(truncated) < 16000)\",\n \"def _check_max_length(self, p: list) -> bool:\\n\\n return (\\n len(p[0].split(\\\" \\\")) < self.max_length\\n and len(p[1].split(\\\" \\\")) < self.max_length\\n )\",\n \"def max_length(verifield, required):\\n if verifield is None: return True\\n return len(verifield) <= required\",\n \"def test_long_string_positive_length(self):\\n self.failUnlessEqual(self.callFunc('encode_longstr', 'hello world'), '\\\\x00\\\\x00\\\\x00\\\\x0bhello world', 'positive length long string encoding FAILED...')\",\n \"def test_long_message(self):\\n message = \\\"few characters\\\"\\n message_displayed = truncate_message(message, limit=5)\\n\\n self.assertLessEqual(len(message_displayed), 5)\\n self.assertEqual(message_displayed, \\\"fe...\\\")\",\n \"def test_max_length_option(assert_errors, assert_error_text, options):\\n max_length = 55\\n filename = 'very_long_name_that_should_not_pass_unless_changed_shorter.py'\\n option_values = options(max_name_length=max_length)\\n visitor = WrongModuleNameVisitor(option_values, filename=filename)\\n visitor.run()\\n\\n assert_errors(visitor, [TooLongNameViolation])\\n assert_error_text(\\n visitor, filename.replace('.py', ''), option_values.max_name_length,\\n )\",\n \"def max_length(length):\\n def validate(value):\\n if len(value) <= length:\\n return True\\n raise Exception('%s must be at most %s characters long' % length)\\n return validate\",\n \"def test_too_short_limit(self):\\n message = \\\"few characters\\\"\\n\\n with self.assertRaises(AssertionError) as error:\\n truncate_message(message, limit=2)\\n\\n self.assertEqual(str(error.exception), \\\"Limit too short\\\")\",\n \"def test_validate_max_length(self):\\n test_strings = [\\n 'thisloooooooooooooooongstring',\\n True,\\n 45,\\n ]\\n\\n testrow = TestSchema()\\n\\n for test_string in test_strings:\\n testrow.string_max_field = test_string\\n self.assertRaises(Exception, testrow.save)\",\n \"def filter_max_length(self, string):\\n newstring = string\\n length = len(newstring)\\n max_length = 63\\n if length > max_length:\\n newstring = newstring[0:max_length]\\n\\n return newstring\",\n \"def __size_restriction_inccorrect_string_string(self):\\n\\n strTestName = 'String size equal to the size of another string (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n # Firstly, let us define a reference parameter\\n RxCSObject.paramAddMan('strRefParameter1', 'Str ref. parameter')\\n RxCSObject.paramType('strRefParameter1', str)\\n\\n # Now, let me define a string\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizEq('parameter1', 'strRefParameter1')\\n\\n RxCSObject.strRefParameter1 = 'bbbcca'\\n RxCSObject.parameter1 = 'aaabb'\\n\\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)\",\n \"def __size_restriction_correct_string_string(self):\\n\\n strTestName = 'String size lower or equal to the size of another string (correct)'\\n RxCSObject = _RxCSobject()\\n\\n # Firstly, let us define a reference parameter\\n RxCSObject.paramAddMan('strRefParameter1', 'Str ref. parameter')\\n RxCSObject.paramType('strRefParameter1', str)\\n\\n # Now, let me define a string\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizLE('parameter1', 'strRefParameter1')\\n\\n RxCSObject.strRefParameter1 = 'bbbccc'\\n RxCSObject.parameter1 = 'aaabb'\\n\\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)\",\n \"def length_of_name(self, name):\\n length = len(name)\\n if length > 10:\\n self.show_message_when_name_very_long()\\n return length\",\n \"def test_slugs_max_length(self):\\n self.assertLessEqual(len(str(self.cat_short.slug)), 50)\\n self.assertLessEqual(len(str(self.cat_long.slug)), 50)\",\n \"def test_websites_name_max_length(self):\\n max_length = self.website._meta.get_field('name').max_length\\n self.assertEqual(max_length, 25)\",\n \"def __size_restriction_correct_string_number(self):\\n\\n strTestName = 'String size equal to a string (correct)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizEq('parameter1', 4)\\n\\n RxCSObject.parameter1 = 'aaaa'\\n\\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)\",\n \"def validate_length(string):\\n if len(string) > 110:\\n raise ValidationError('Tweet must be less than 110 characters')\",\n \"def test_stringLiteralTooLong(self):\\n self.server._literalStringLimit = 4\\n self.server.lineReceived(b\\\"001 LOGIN {5}\\\\r\\\\n\\\")\\n\\n self.assertEqual(self.transport.value(),\\n b\\\"001 BAD Illegal syntax: Literal too long!\\\"\\n b\\\" I accept at most 4 octets\\\\r\\\\n\\\")\",\n \"def _max_length(self):\\n return self.__max_length\",\n \"def is_name_length_valid(self) -> bool:\\n return 2 < len(self.app_name) <= 35\",\n \"def test_minlength():\\n assert has_min_length(None, 8) is None\\n assert has_min_length('abcd1234', 8) is None\\n assert has_min_length('a', 8)\",\n \"def test_websites_name_max_length(self):\\n max_length = self.website._meta.get_field('className').max_length\\n self.assertEqual(max_length, 25)\",\n \"def test_small_message(self):\\n message = \\\"few characters\\\"\\n message_displayed = truncate_message(message, limit=50)\\n\\n self.assertLessEqual(len(message_displayed), 50)\\n self.assertEqual(message_displayed, \\\"few characters\\\")\",\n \"def test_slugs_max_length(self):\\n self.assertLessEqual(len(str(self.art_short.slug)), 50)\\n self.assertLessEqual(len(str(self.art_long.slug)), 50)\",\n \"def __size_restriction_incorrect_string_parameter(self):\\n\\n strTestName = 'String size higher or equal to a parameter (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n # Firstly, let us define a reference parameter\\n RxCSObject.paramAddMan('iRefParameter1', 'Int parameter')\\n RxCSObject.paramType('iRefParameter1', int)\\n\\n # Now, let me define a string\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizHE('parameter1', 'iRefParameter1', mul=2, add=3)\\n\\n RxCSObject.iRefParameter1 = 2\\n RxCSObject.parameter1 = 'aaabb'\\n\\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)\",\n \"def test_client_email_max_length(self):\\n request = Request.objects.get(id=1)\\n max_length = request._meta.get_field('client_email').max_length\\n self.assertEquals(max_length, 100)\",\n \"def _matchLength(self, length: int):\\n return self._comparator['Length'] < length\",\n \"def valid_message_length(self):\\n if self.message_len() > 0:\\n if self.message_len() <= self.max_msg_length:\\n return True\\n return False\",\n \"def validate_max_length(cls, value: str, field: ModelField) -> str:\\n if cls.max_length is not None and len(value) > cls.max_length:\\n raise InvalidLengthValue(\\n field_name=field.name, constraint=cls.max_length, operation='max'\\n )\\n return value\",\n \"def test_client_ip_max_length(self):\\n request = Request.objects.get(id=1)\\n max_length = request._meta.get_field('client_ip').max_length\\n self.assertEquals(max_length, 100)\",\n \"def _model_string_maxlen():\\n # hardcoded for convenience. Could be dynamically set in future.\\n # the current longest is: BLOSUM62+I+G+X, i.e. 14 chars.\\n # so we just over double it, for safety\\n\\n return 30\",\n \"def test_search_terms_max_length(self):\\n max_length = self.search._meta.get_field('terms_en').max_length\\n self.assertEqual(max_length, 50)\",\n \"def __size_restriction_correct_string_parameter(self):\\n strTestName = 'String size higher than a parameter (correct)'\\n RxCSObject = _RxCSobject()\\n\\n # Firstly, let us define a reference parameter\\n RxCSObject.paramAddMan('iRefParameter1', 'Int parameter')\\n RxCSObject.paramType('iRefParameter1', int)\\n\\n # Now, let me define a string\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizH('parameter1', 'iRefParameter1')\\n\\n RxCSObject.iRefParameter1 = 2\\n RxCSObject.parameter1 = 'aaabbbab'\\n\\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)\",\n \"def test_category_name_field_max_length(self):\\n cat = Category.objects.get(id=1)\\n max_length = cat._meta.get_field('name').max_length\\n self.assertEqual(max_length, 20)\",\n \"def validate(cls, **kwargs: Any) -> None:\\n max_length = kwargs.get(\\\"max_length\\\", None)\\n if max_length <= 0:\\n raise ModelDefinitionError(\\n \\\"Parameter max_length is required for field String\\\"\\n )\",\n \"def test_systemstatus_name_length(self):\\n\\n # get object\\n systemstatus_1 = Systemstatus.objects.get(systemstatus_name='systemstatus_1')\\n # get max length\\n max_length = systemstatus_1._meta.get_field('systemstatus_name').max_length\\n # compare\\n self.assertEqual(max_length, 30)\",\n \"def max_length(self):\\n\\t\\treturn self._max_length\",\n \"def check_len( string_key ) : \\r\\n\\r\\n if len( string_key ) != 4 :\\r\\n\\r\\n raise Eggog( \\\"'%s': EGI wants the key to be exactly four characters!\\\" % (string_key, ) ) \\r\\n \\r\\n else :\\r\\n \\r\\n return True\",\n \"def TruncateString(raw_string, max_length):\\n if len(raw_string) > max_length:\\n return raw_string[:max_length]\\n return raw_string\",\n \"def __size_restriction_incorrect_string_number(self):\\n\\n strTestName = 'String size lower than a number (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizHE('parameter1', 4, mul=2, add=3)\\n\\n RxCSObject.parameter1 = 'aaa'\\n\\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)\",\n \"def test_limit(self):\\n\\t\\tfor lim in [1, '234', -100, '-200']:\\n\\t\\t\\tself.filter.set_limit(lim)\\n\\t\\t\\tself.assertEqual(int(lim), self.filter.get_limit(), \\\"Limit mismatch: %s!=%s\\\" % (lim, self.filter.get_limit()))\\n\\t\\tself.filter.set_limit('test')\\n\\t\\tself.assertEqual('test', self.filter.get_limit(), \\\"String set failed for Filter limit.\\\")\",\n \"def lim_str_len(string, length, end='...'):\\n if len(string) <= length:\\n return string\\n else:\\n return '{}{}'.format(string[:length - len(end)], end)\",\n \"def test_length(self):\\n form_data = self.form_data('c897B$eH@')\\n form = self.form(data=form_data, user=self.u)\\n self.assertFalse(form.is_valid())\",\n \"def min_length(verifield, required):\\n if verifield is None: return True\\n return len(verifield) >= required\",\n \"def _validate_length(data, min, max, err): # lint-amnesty, pylint: disable=redefined-builtin\\n if len(data) < min or len(data) > max:\\n raise errors.AccountDataBadLength(err)\",\n \"def test_long_string_zero_length(self):\\n self.failUnlessEqual(self.callFunc('encode_longstr', ''), '\\\\x00\\\\x00\\\\x00\\\\x00', '0 length long string encoding FAILED...')\",\n \"def _checkString(inputstring, description, minlength=0, maxlength=None):\\n # Type checking\\n if not isinstance(description, str):\\n raise TypeError('The description should be a string. Given: {0!r}'.format(description))\\n\\n if not isinstance(inputstring, str):\\n raise TypeError('The {0} should be a string. Given: {1!r}'.format(description, inputstring))\\n\\n if not isinstance(maxlength, (int, type(None))):\\n raise TypeError('The maxlength must be an integer or None. Given: {0!r}'.format(maxlength))\\n\\n # Check values\\n _checkInt(minlength, minvalue=0, maxvalue=None, description='minlength')\\n\\n if len(inputstring) < minlength:\\n raise ValueError('The {0} is too short: {1}, but minimum value is {2}. Given: {3!r}'.format( \\\\\\n description, len(inputstring), minlength, inputstring))\\n\\n if not maxlength is None:\\n if maxlength < 0:\\n raise ValueError('The maxlength must be positive. Given: {0}'.format(maxlength))\\n\\n if maxlength < minlength:\\n raise ValueError('The maxlength must not be smaller than minlength. Given: {0} and {1}'.format( \\\\\\n maxlength, minlength))\\n\\n if len(inputstring) > maxlength:\\n raise ValueError('The {0} is too long: {1}, but maximum value is {2}. Given: {3!r}'.format( \\\\\\n description, len(inputstring), maxlength, inputstring))\",\n \"def test_short_string_out_of_upper_range(self):\\n self.failUnlessRaises(Exception, self.codec.encode_shortstr, 'x'*256)\",\n \"def check_option(option, max_length):\\n res = utils.string_to_num(option)\\n if res is None:\\n return None\\n\\n if res < 0 or res >= max_length:\\n return None\\n return res\",\n \"def test_short_string_positive_length(self):\\n self.failUnlessEqual(self.callFunc('encode_shortstr', 'hello world'), '\\\\x0bhello world', 'positive length short string encoding FAILED...')\",\n \"def check_doc_string_len(fn):\\r\\n free_var_local_count = 50\\r\\n def check_doc_string_len_inner():\\r\\n '''This function returns True, if the docstring has minimum\\r\\n 50 characters else it returns false'''\\r\\n nonlocal free_var_local_count\\r\\n if len(fn.__doc__) >= free_var_local_count:\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n return check_doc_string_len_inner\",\n \"def test_utils_random_string(self, tcex, string_length):\\n result = tcex.utils.random_string(string_length=string_length)\\n assert (\\n len(result) == string_length\\n ), f'The length of the string {len(result)} != {string_length}'\",\n \"def _stop(self):\\n if self.char_limit is not None:\\n return self.char_count > self.char_limit\\n else:\\n return False\",\n \"def test_models_meetings_name_maxlength(self):\\n MeetingFactory(name=\\\"a\\\" * 500)\\n with self.assertRaises(ValidationError) as context:\\n MeetingFactory(name=\\\"a\\\" * 501)\\n\\n self.assertEqual(\\n context.exception.messages,\\n [\\\"Ensure this value has at most 500 characters (it has 501).\\\"],\\n )\",\n \"def test_length_option(assert_errors, assert_error_text, options):\\n filename = 'test.py'\\n option_values = options(min_name_length=5)\\n visitor = WrongModuleNameVisitor(option_values, filename=filename)\\n visitor.run()\\n\\n assert_errors(visitor, [TooShortNameViolation])\\n assert_error_text(\\n visitor, filename.replace('.py', ''), option_values.min_name_length,\\n )\",\n \"def check_length(string):\\n if 6 < len(string) < 12:\\n return True\\n\\n print(\\\"Your password is not between 6 and 12 characters\\\")\\n return False\",\n \"def test_encodes_long_string(self):\\n result = encode_run_length(\\\"RRRRRTTEEEQQQQCSDUUIRRTTT\\\")\\n self.assertEqual(result, \\\"5R2T3E4Q1C1S1D2U1I2R3T\\\")\",\n \"def max_length(self) -> int | None:\\n return self._underlying.max_length\",\n \"def test_check_name_is_3_parts():\\n check_name_length()\",\n \"def test_trim_too_long_filename(self):\\n filename = 'filename'\\n extension = '.jpg'\\n long_filename = '{}{}'.format(filename * 10, extension)\\n\\n trimmed_filename = trim_long_filename(long_filename)\\n \\n self.assertEqual(len(trimmed_filename), FILENAME_MAX_LEN)\\n self.assertTrue(trimmed_filename.startswith(filename))\\n self.assertTrue(trimmed_filename.endswith(extension))\",\n \"def test_more_than_max_length_invalid_password(self):\\n pass_field = Field(\\\"\\\".join(['x' * (int(self.app.config['MAX_PWD_LEN']) + 1)]))\\n\\n with self.assertRaises(ValidationError):\\n valid_password(None, pass_field)\",\n \"def test_search_form_terms_max(self):\\n form = SearchForm()\\n max_length = form.fields['terms_en'].max_length\\n min_length = form.fields['terms_en'].min_length\\n self.assertEqual(max_length, 50)\\n self.assertEqual(min_length, 1)\",\n \"def test_utils_truncate_string(self, tcex, input_, length, append_chars, spaces, expected):\\n result = tcex.utils.truncate_string(input_, length, append_chars, spaces)\\n print('\\\\nstring', input_)\\n print('result', result)\\n print('expect', expected)\\n assert result == expected, f'Input {input_} result of {result} != {expected}'\",\n \"def within_length(flowgram, minlength=0, maxlength=400):\\r\\n seq = flowgram.toSeq()\\r\\n l = len(seq)\\r\\n return (l >= minlength and l <= maxlength)\",\n \"def test_maxlength(self):\\n val = DwcaValidator(yaml.load(self.yaml_length, Loader=yaml.FullLoader),\\n error_handler=WhipErrorHandler)\\n document = {'license_plate': 'AF8934'}\\n self.assertTrue(val.validate(document))\\n\\n document = {'license_plate': '123456'}\\n self.assertTrue(val.validate(document))\\n\\n document = {'license_plate': 'AF893'}\\n self.assertTrue(val.validate(document))\\n\\n document = {'license_plate': 'AF8-934'}\\n self.assertFalse(val.validate(document))\\n\\n document = {'license_plate': 'AF 934'}\\n self.assertFalse(val.validate(document))\",\n \"def test_rfc_nickkey_length(s):\\n assert len(util.rfc_nickkey(s)) == len(s)\",\n \"def test_max_str(self):\\n self.assertEqual(max_integer(\\\"abcdef\\\"), \\\"f\\\")\",\n \"def __get_max_length(self):\\n\\t\\tif self.version == 1:\\n\\t\\t\\treturn 19\\n\\t\\telif self.version == 2:\\n\\t\\t\\treturn 34\\n\\t\\telif self.version == 3:\\n\\t\\t\\treturn 55\\n\\t\\telif self.version == 4:\\n\\t\\t\\treturn 80\\n\\t\\telif self.version == 5:\\n\\t\\t\\treturn 108\\n\\t\\telif self.version == 6:\\n\\t\\t\\treturn 136\\n\\t\\telse:\\n\\t\\t\\treturn \\\"Version number > 6 not supported\\\"\",\n \"def test_field_len(self):\\n client = self.base_scenario(\\n frang_config=\\\"http_field_len 300;\\\",\\n requests=[f\\\"POST /1234 HTTP/1.1\\\\r\\\\nHost: localhost\\\\r\\\\nX-Long: {'1' * 320}\\\\r\\\\n\\\\r\\\\n\\\"],\\n )\\n self.check_response(\\n client,\\n status_code=\\\"403\\\",\\n warning_msg=\\\"frang: HTTP (in-progress )?field length exceeded for\\\",\\n )\",\n \"def checklength(config, tokenizer):\\n\\n # Unpack nested config, handles passing model directly\\n if hasattr(config, \\\"config\\\"):\\n config = config.config\\n\\n if (\\n hasattr(config, \\\"max_position_embeddings\\\")\\n and tokenizer\\n and hasattr(tokenizer, \\\"model_max_length\\\")\\n and tokenizer.model_max_length == int(1e30)\\n ):\\n tokenizer.model_max_length = config.max_position_embeddings\",\n \"def test_long_name():\\n expect_error(register, InputError,\\n \\\"a\\\", \\\"abcdef\\\", \\\"a\\\" * (MAX_NAME + 1), \\\"a\\\", \\\"a\\\")\\n expect_error(register, InputError,\\n \\\"a\\\", \\\"abcdef\\\", \\\"a\\\", \\\"a\\\" * (MAX_NAME + 1), \\\"a\\\")\",\n \"def clean_content_length(field_name, min_length=0, max_length=500):\\n\\n @check_field_is_empty(field_name)\\n def wrapper(self):\\n \\\"\\\"\\\"Decorator wrapper method.\\n \\\"\\\"\\\"\\n\\n value = self.cleaned_data[field_name]\\n value_length = len(value)\\n\\n if value_length < min_length:\\n raise forms.ValidationError(DEF_MUST_BE_ABOVE_LIMIT_FMT %(\\n min_length, value_length))\\n\\n if value_length > max_length:\\n raise forms.ValidationError(DEF_MUST_BE_UNDER_LIMIT_FMT %(\\n max_length, value_length))\\n\\n return value\\n return wrapper\",\n \"def test_uid_max_length(self):\\n\\n field = self.image._meta.get_field(\\\"uid\\\")\\n self.assertEqual(field.max_length, 64)\",\n \"def get_field_length_error_text(field_name):\\n\\n\\treturn(\\\"Value entered for '{0}' exceeds character length limit of {1}\\\"\\n\\t\\t .format(field_name, str(field_length_limit)))\",\n \"def _truncate_string(cls, s1, s2, max_len):\\n s1_len = len(s1.split(' '))\\n s2_len = len(s2.split(' '))\\n MIN_S2_LEN = 6\\n if s1_len + s2_len <= max_len or s2_len < MIN_S2_LEN:\\n return s2, False\\n\\n truncate_point = MIN_S2_LEN if s1_len > max_len else max_len - s1_len\\n\\n return ' '.join(s2.split(' ')[0:truncate_point]), True\",\n \"def _check_blurb_length(self: SynopsisImpl, docstring: PetscDocStringImpl, cursor: Cursor, blurb_items: Synopsis.BlurbItemType) -> None:\\n total_blurb = [line for _, line in blurb_items]\\n word_count = sum(len(l.split()) for l in total_blurb)\\n char_count = sum(map(len, total_blurb))\\n\\n max_char_count = 250\\n max_word_count = 40\\n if char_count > max_char_count and word_count > max_word_count:\\n mess = f\\\"Synopsis for '{cursor.name}' is too long (must be at most {max_char_count} characters or {max_word_count} words), consider moving it to Notes. If you can't explain it simply, then you don't understand it well enough!\\\"\\n docstring.add_diagnostic_from_source_range(\\n Diagnostic.Kind.ERROR, self.diags.verbose_description, mess, self.extent, highlight=False\\n )\\n return\",\n \"def test_lineLength(self):\\n failures = []\\n for line in self.output:\\n if not len(line) <= lineWidth:\\n failures.append(len(line))\\n if failures:\\n self.fail(\\\"%d of %d lines were too long.\\\\n\\\"\\n \\\"%d < %s\\\" % (len(failures), len(self.output),\\n lineWidth, failures))\",\n \"def test01_password_length(self):\\n self.set_complexity(length=13, numeric=0, upper=0, lower=0, special=0)\\n\\n invalid = (\\n \\\"A\\\",\\n \\\"Tr0ub4dor&3\\\",\\n \\\"!!!!!!!!!!!!\\\",\\n \\\"Password\\\",\\n \\\"Password123!\\\",\\n \\\"admin\\\",\\n )\\n self.assertPasswordsInvalid(invalid)\\n\\n valid = (\\n \\\"correcthorsebatterystaple\\\",\\n \\\"abcdefghijklmopqrstuvwxyz\\\",\\n \\\"12345678901234567890\\\",\\n \\\"!!!!!!!!!!!!!\\\" \\\"Password123!___\\\",\\n )\\n self.set_passwords(valid)\",\n \"def test_minmaxlength(self):\\n val = DwcaValidator(yaml.load(self.yaml_length, Loader=yaml.FullLoader),\\n error_handler=WhipErrorHandler)\\n document = {'code': 'AA'}\\n self.assertTrue(val.validate(document))\\n\\n document = {'code': 'A'}\\n self.assertFalse(val.validate(document))\\n\\n document = {'code': 'ABC'}\\n self.assertFalse(val.validate(document))\",\n \"def test_character_count(self):\\r\\n from chatterbot_corpus.corpus import DIALOG_MAXIMUM_CHARACTER_LENGTH\\r\\n\\r\\n corpora = corpus.load_corpus('chatterbot.corpus')\\r\\n\\r\\n for conversations in corpora:\\r\\n for conversation in conversations:\\r\\n for statement in conversation:\\r\\n if len(statement) > DIALOG_MAXIMUM_CHARACTER_LENGTH:\\r\\n self.fail(\\r\\n u'\\\"{}\\\" cannot be longer than {} characters'.format(\\r\\n statement,\\r\\n DIALOG_MAXIMUM_CHARACTER_LENGTH\\r\\n )\\r\\n )\",\n \"def _check_field_length(self, field, value, options=None):\\n options = options if options else field.GetOptions()\\n for (option, setting) in options.ListFields():\\n if option.name == \\\"length\\\":\\n if self.__gt_by_type(value, setting):\\n if hasattr(field, \\\"name\\\"):\\n raise FieldTooLongException(\\\"The field '\\\" + field.name +\\n \\\"' is bigger than the allowed \\\" + str(setting) + \\\" bytes\\\")\\n else:\\n raise FieldTooLongException(\\\"List element '\\\" + str(value) +\\n \\\"' is bigger than the allowed \\\" + str(setting) + \\\" bytes\\\")\",\n \"def is_too_long(file_name: str) -> bool:\\n return len(file_name + REPORT_FILE_EXT) > 255\",\n \"def test_prep_charfield_size(self):\\n pass\",\n \"def _truncate_string(self, text, max_size):\\n import textwrap\\n\\n if len(text) <= max_size:\\n return text\\n return textwrap.wrap(text, max_size-3)[0] + \\\"...\\\"\",\n \"def validate_length(column_name, value, length):\\n valuelength = len(value)\\n if valuelength > int(length) >= 0:\\n return \\\"{0} : value '{1}' is greater than the specified length {2}\\\".format(column_name, value, length)\\n elif valuelength < int(length) and int(length) >= 0:\\n return \\\"{0} : value '{1}' is less than the specified length {2}\\\".format(column_name, value, length)\\n\\n return None\",\n \"def test_len(self):\\n self.assertEqual(len(self.tester), 30)\",\n \"def validate_min_max_length(column_name, value, min_length, max_length):\\n valuelength = len(value)\\n if (valuelength < int(min_length) or valuelength > int(max_length) and (\\n int(min_length) >= 0 and int(max_length) >= 0)):\\n return \\\"{0} : Length of value '{1}' is not in range of {2}-{3}\\\".format(column_name, value, min_length,\\n max_length)\\n return None\",\n \"def check_this_input(self, inp, max_len):\\n\\t\\tst = inp.get()\\n\\t\\tst = st.strip()\\n\\t\\treturn st if len(st) > 0 and len(st) < max_len else None\",\n \"def test_uri_len_on_the_limit(self):\\n client = self.base_scenario(\\n frang_config=\\\"http_uri_len 5;\\\",\\n requests=[\\\"POST /1234 HTTP/1.1\\\\r\\\\nHost: localhost\\\\r\\\\n\\\\r\\\\n\\\"],\\n )\\n self.check_response(\\n client, status_code=\\\"200\\\", warning_msg=\\\"frang: HTTP URI length exceeded for\\\"\\n )\",\n \"def longer_than_9(value):\\n if len(value) < 10:\\n raise forms.ValidationError('must be 10 characters or longer')\",\n \"def supportedLength(self):\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7828164","0.74206644","0.7354528","0.73487365","0.730151","0.7263644","0.721242","0.7049977","0.7049977","0.696591","0.69547063","0.6921804","0.68282324","0.68267554","0.6825206","0.6779123","0.67705727","0.66442156","0.66199005","0.65304154","0.65274286","0.65127283","0.64801705","0.6459444","0.6452045","0.64303344","0.6425927","0.6425912","0.6421402","0.6416978","0.6392585","0.6387409","0.6360606","0.6339292","0.633535","0.63328046","0.63264954","0.6322512","0.63036466","0.6298775","0.6288464","0.6242109","0.62408847","0.62390786","0.6238518","0.6236665","0.62157065","0.6185665","0.6173723","0.61716473","0.61689544","0.6168172","0.6161754","0.61566734","0.613109","0.6126284","0.61165726","0.611573","0.6110555","0.6098911","0.6098251","0.60909766","0.6063299","0.6062838","0.6058234","0.60406244","0.6040447","0.60315204","0.6029302","0.6025305","0.6006459","0.5975522","0.59738433","0.5970666","0.59640884","0.596064","0.5931286","0.5920348","0.5919534","0.5915742","0.5876002","0.5870105","0.58692145","0.5868241","0.5865549","0.58596426","0.58580536","0.58537775","0.5846289","0.5832739","0.5830314","0.5824823","0.5797583","0.57905746","0.5787069","0.57811856","0.57676154","0.5765416","0.57551485","0.57477236"],"string":"[\n \"0.7828164\",\n \"0.74206644\",\n \"0.7354528\",\n \"0.73487365\",\n \"0.730151\",\n \"0.7263644\",\n \"0.721242\",\n \"0.7049977\",\n \"0.7049977\",\n \"0.696591\",\n \"0.69547063\",\n \"0.6921804\",\n \"0.68282324\",\n \"0.68267554\",\n \"0.6825206\",\n \"0.6779123\",\n \"0.67705727\",\n \"0.66442156\",\n \"0.66199005\",\n \"0.65304154\",\n \"0.65274286\",\n \"0.65127283\",\n \"0.64801705\",\n \"0.6459444\",\n \"0.6452045\",\n \"0.64303344\",\n \"0.6425927\",\n \"0.6425912\",\n \"0.6421402\",\n \"0.6416978\",\n \"0.6392585\",\n \"0.6387409\",\n \"0.6360606\",\n \"0.6339292\",\n \"0.633535\",\n \"0.63328046\",\n \"0.63264954\",\n \"0.6322512\",\n \"0.63036466\",\n \"0.6298775\",\n \"0.6288464\",\n \"0.6242109\",\n \"0.62408847\",\n \"0.62390786\",\n \"0.6238518\",\n \"0.6236665\",\n \"0.62157065\",\n \"0.6185665\",\n \"0.6173723\",\n \"0.61716473\",\n \"0.61689544\",\n \"0.6168172\",\n \"0.6161754\",\n \"0.61566734\",\n \"0.613109\",\n \"0.6126284\",\n \"0.61165726\",\n \"0.611573\",\n \"0.6110555\",\n \"0.6098911\",\n \"0.6098251\",\n \"0.60909766\",\n \"0.6063299\",\n \"0.6062838\",\n \"0.6058234\",\n \"0.60406244\",\n \"0.6040447\",\n \"0.60315204\",\n \"0.6029302\",\n \"0.6025305\",\n \"0.6006459\",\n \"0.5975522\",\n \"0.59738433\",\n \"0.5970666\",\n \"0.59640884\",\n \"0.596064\",\n \"0.5931286\",\n \"0.5920348\",\n \"0.5919534\",\n \"0.5915742\",\n \"0.5876002\",\n \"0.5870105\",\n \"0.58692145\",\n \"0.5868241\",\n \"0.5865549\",\n \"0.58596426\",\n \"0.58580536\",\n \"0.58537775\",\n \"0.5846289\",\n \"0.5832739\",\n \"0.5830314\",\n \"0.5824823\",\n \"0.5797583\",\n \"0.57905746\",\n \"0.5787069\",\n \"0.57811856\",\n \"0.57676154\",\n \"0.5765416\",\n \"0.57551485\",\n \"0.57477236\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.87113315"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93485,"cells":{"query":{"kind":"string","value":"Makes sure that an element is only once in a set"},"document":{"kind":"string","value":"def making_sets(lists):\n empty_set = []\n lists =lists.split()\n for elements in lists:\n if elements == \" \":\n next\n else:\n if elements not in empty_set:\n empty_set.append(elements) \n return empty_set"},"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 has_duplicates_set(L):\r\n return len(L) != len(set(L))","def is_unique(x):\n return len(set(x)) == len(x)","def contains_duplicate_fast_set(self, nums: List[int]) -> bool:\n visited = set()\n for i in nums:\n if i in visited:\n return True\n visited.add(i)","def contains_duplicate_full_slow_set(self, nums: List[int]) -> bool:\n return len(nums) != len(set(nums))","def containsDuplicateSet(self, nums):\n distinct_nums = set()\n for number in nums:\n if number in distinct_nums:\n return True\n distinct_nums.add(number)\n return False","def find_duplicates(lst):\n \"*** YOUR CODE HERE ***\"\n return len( set(lst) ) != len(lst)","def check_if_duplicates_list(list_of_elems):\n set_of_elems = set()\n for elem in list_of_elems:\n if elem in set_of_elems:\n return True\n else:\n set_of_elems.add(elem)\n return False","def has_duplicates(lst):\n\n return len(lst) != len(set(lst))","def has_duplicates(l):\r\n return len(set(l)) < len(l)","def test_contains(self):\n s = djset()\n s.add([1, 2, 3])\n s.add([4, 5, 6])\n self.assertTrue(2 in s)\n self.assertTrue(5 in s)","def SetFunction():\r\n s2 = []\r\n s3 = []\r\n s4 = []\r\n s2 = { i for i in range(21) if i%2 == 0}\r\n s3 = { i for i in range(21) if i%3 == 0}\r\n s4 = { i for i in range(21) if i%4 == 0}\r\n s2 = set(s2)\r\n s3 = set(s3)\r\n s4 = set(s4)\r\n print s3.issubset(s2)\r\n print s4.issubset(s2)","def check_no_duplicates(examples):\n return len(examples) == len(set(examples))","def _unique_everseen(iterable, key=None):\n seen = set()\n seen_add = seen.add\n if key is None:\n for element in itertools.filterfalse(seen.__contains__, iterable):\n seen_add(element)\n yield element\n else:\n for element in iterable:\n k = key(element)\n if k not in seen:\n seen_add(k)\n yield element","def deleteduplicates(iterable):\n seen = []\n for x in iterable:\n if x not in seen:\n yield x\n seen.append(x)","def has_duplicates(L):\r\n unique = []\r\n for e in L:\r\n if e in unique:\r\n return True\r\n unique.append(e)\r\n return False","def isdistinct(seq):\n return len(seq) == len(set(seq))","def uniqueCheckSet(aList):\r\n check = set()\r\n for v in aList:\r\n if v in check:\r\n return True\r\n check.add(v)\r\n return False","def tuple_has_duplicates(my_tuple):\n\n duplicates = []\n for i in my_tuple:\n if my_tuple.count(i) > 1 and i not in duplicates:\n duplicates.append(i)\n counter = 0\n # for k in my_tuple:\n # if i == k:\n # counter += 1\n # if counter > 1 and i not in duplicates:\n # duplicates.append(i)\n if duplicates:\n return duplicates\n else:\n return False","def UniqueIterator(iterator):\r\n so_far = set()\r\n def no_dups(x):\r\n if x in so_far:\r\n return False\r\n else:\r\n so_far.add(x)\r\n return True\r\n\r\n return IteratorFilter(iterator, no_dups)","def duplicate_check(method):\n\n def predicate(entry):\n entry_hash = predicate.unique(entry)\n if entry_hash not in predicate.state:\n predicate.state.add(entry_hash)\n return False\n return True\n\n predicate.unique = method\n predicate.state = set()\n return predicate","def all_unique_set(string):\n return len(string) == len(set(string))","def set(x):\n pass","def test_exclusive(self):\n s = djset()\n s.add([1, 2, 3])\n s.add([4, 5, 6])\n self.assertEquals({1, 2, 3}, s.data[1])\n self.assertEquals({4, 5, 6}, s.data[4])","def isUnique(collection):\n\n # Implemented using a hash table:\n memo = set()\n for element in collection:\n if element in memo:\n return False\n memo.add(element)\n\n return True\n\n # Time Complexity: O(n)\n # Space Complexity: O(m), where m is the number of unique elements. If this is a string with alphabetical letters, then it is going to be either 26 or 52 elements long depending on if we care about case sensitivity.\n\n\n # Implemented without additional structures\n end = len(collection)\n for i in range(end-1):\n temp_base = collection[i]\n for j in range(i + 1, end):\n if temp_base == collection[j]:\n return False\n\n return True\n\n # Time Complexity: O(n^2)\n # Space Complexity: O(1)","def unique(iterable):\n seen = set()\n return [i for i in iterable if not (i in seen or seen.add(i))]","def all_in_set(the_set, the_list):\n return True","def unique(iterable):\n seen_items = set()\n for item in iterable:\n if item not in seen_items:\n yield item\n seen_items.add(item)","def check_unique(self):\n pass","def unique(iterable):\n seen = set()\n return [x for x in iterable if x not in seen and not seen.add(x)]","def uniq(elements):\n us = set()\n ret = []\n for e in elements:\n if e not in us:\n ret.append(e)\n us.add(e)\n return ret","def set():","def is_unique_n_set(string: str) -> bool:\n\n return len(set(string)) == len(string)","def is_unique_value(x: List[dict], key):\n return len(x) == len(set([v[key] for v in x]))","def uniq(seq):\r\n seen = set()\r\n seen_add = seen.add\r\n return [x for x in seq if x not in seen and not seen_add(x)]","def _find_element_not_in_set(self, already_used: set) -> int:\n new_element = random.randint(a=self.min_value, b=self.max_value)\n while new_element in already_used:\n new_element = random.randint(a=self.min_value, b=self.max_value)\n return new_element","def unique(li):\r\n seen = set()\r\n seen_add = seen.add\r\n return [x for x in li if not (x in seen or seen_add(x))]","def unique_everseen(iterable, key = None):\n seen = set()\n seen_add = seen.add\n if key is None:\n for element in ifilterfalse(seen.__contains__, iterable):\n seen_add(element)\n yield element\n else:\n for element in iterable:\n k = key(element)\n if k not in seen:\n seen_add(k)\n yield element","def set_of(element: Type) -> SetType:\n return SetType(element)","def has_duplicates_dict(L):\r\n unique = {}\r\n for e in L:\r\n if e in unique:\r\n return True\r\n unique[e] = 0\r\n return False","def remove_duplicates(somelist):\n return set(somelist)","def unique(iterable, filterfalse=filterfalse):\n seen = set()\n add = seen.add\n for element in filterfalse(seen.__contains__, iterable):\n add(element)\n yield element","def unique_everseen(iterable, key=None):\n seen = set()\n seen_add = seen.add\n if key is None:\n for element in itertools.ifilterfalse(seen.__contains__, iterable):\n seen_add(element)\n yield element\n else:\n for element in iterable:\n k = key(element)\n if k not in seen:\n seen_add(k)\n yield element","def uniquify(seq):\n seen = set()\n seen_add = seen.add\n return [ x for x in seq if x not in seen and not seen_add(x)]","def uniq_stable(elems):\r\n unique = []\r\n unique_set = set()\r\n for nn in elems:\r\n if nn not in unique_set:\r\n unique.append(nn)\r\n unique_set.add(nn)\r\n return unique","def checkUniqueness_(self, list):\n\n uniqueList = []\n # use a list comprehension statement (takes a while to understand) \n\n [uniqueList.append(it) for it in list if not uniqueList.count(it)]\n\n return (len(list)==len(uniqueList))","def test_set(self):\n a = set()\n a.add('b')\n a.add('c')\n a.add('a')\n b = list(a)\n b.sort()\n self.assertEqual(b, ['a', 'b', 'c'])\n a.remove('b')\n b = list(a)\n b.sort()\n self.assertEqual(b, ['a', 'c'])\n\n a.discard('d')\n\n b = set(['r', 's'])\n d = a.union(b)\n b = list(d)\n b.sort()\n self.assertEqual(b, ['a', 'c', 'r', 's'])","def is_set(obj):\n return type(obj) is set","def list_should_not_contain_duplicates(self,list_,msg=None):\r\n if not isinstance(list_,list):\r\n list_= list(list_)\r\n dupes = []\r\n for item in list_:\r\n if item not in dupes:\r\n count = list_.count(item)\r\n if count >1:\r\n logger.info(\" '%s' found %d times\" %(item,count))\r\n dupes.append(item)\r\n if dupes:\r\n raise AssertionError(msg or '%s found multiple times' %seq2str(dupes))","def findSetWithElement(self, element, \n is_present=True):\n sets = [s for s in self.sets if element in s]\n if len(sets) > 1:\n raise RuntimeError(\"Should have at most instance of values.\")\n if len(sets) == 0:\n if is_present:\n raise ValueError(\"%s is not present\" % str(element))\n result = cn.NULL_SET \n else:\n result = sets[0]\n return result","def list_set(seq):\n seen = set()\n seen_add = seen.add\n return [x for x in seq if not (x in seen or seen_add(x))]","def remove_duplicates_badSolution( li ):\n newli=[]\n seen = set()\n for item in li:\n if item not in seen:\n seen.add( item )\n newli.append(item)\n\n return newli","def unique_list(var):\n return len([x for x in set(var)]) == len(var)","def test_identify_duplicates_3(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"L5\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 1\n ticket2.type = \"replace\"\n ticket2.phage_id = \"Trixie\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 1)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 0)","def test_single(self):\n s = djset()\n s.add([1, 2, 3])\n self.assertEquals({1, 2, 3}, s.data[1])","def unique_elem(o: list[str]) -> bool:\n return True if len(Counter(remove_spaces(o))) == len(o) else False","def has_duplicates(t):\n\n\t# Each element will check each following elements for its duplicate\n\t# An element looking for duplicates before itself is redundant\n\tfor i in range(len(t)):\n\t\tfor n in t[i + 1:]:\n\t\t\tif t[i] == n:\n\t\t\t\treturn True\n\treturn False","def test_identify_duplicates_4(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"Trixie\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 2\n ticket2.type = \"replace\"\n ticket2.phage_id = \"Trixie\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 0)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 1)","def _raise_if_duplicates(counts: Dict[str, int]) -> None:\n duplicates: List[str] = []\n for nickname, count in counts.items():\n if count > 1:\n duplicates.append(nickname)\n if len(duplicates) > 0:\n # TODO This is not always nickname\n raise ValueError(f'\\'nickname\\' not unique {duplicates}')","def clean_duplicate(self):\r\n self.elements = list(set(self.elements))\r\n self.elements = [e for e in self.elements if e != '']","def is_unique(self):\r\n return self._unique","def test_identify_duplicates_6(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"Trixie\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 1\n ticket2.type = \"replace\"\n ticket2.phage_id = \"Trixie\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 1)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 1)","def getSet(unique_name):","def getSet(unique_name):","def unique(iterable, key=None):\n\n\tif key is None:\n\t\tkey = identity\n\n\tseen = set()\n\tseen_add = seen.add\n\tfor v in iterable:\n\t\tk = key(v)\n\t\tif k not in seen:\n\t\t\tyield v\n\t\t\tseen_add(k)","def distinct(iterable):\n\n def distincting(iterable_):\n set_of_distinct_values = set()\n for i in iterable_:\n if i not in set_of_distinct_values:\n set_of_distinct_values.add(i)\n yield i\n\n return distincting(iterable)","def _test_sampdup(t):\n return t.shape[1] != len(set(t.ids(axis='sample')))","def unique_justseen(iterable, key = None):\n return imap(next, imap(operator.itemgetter(1), groupby(iterable, key)))","def test_identify_duplicates_1(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"Trixie\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 2\n ticket2.type = \"replace\"\n ticket2.phage_id = \"L5\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n\n with self.subTest():\n self.assertEqual(len(id_dupes), 0)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 0)","def unique(iterable, key=None):\n # type: (Iterable[T], Optional[Callable[[T], Hashable]]) -> Iterable[T]\n seen = set()\n if key is None:\n key = lambda t: t\n for el in iterable:\n el_k = key(el)\n if el_k not in seen:\n seen.add(el_k)\n yield el","def test_identify_duplicates_2(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = \"none\"\n ticket1.type = \"replace\"\n ticket1.phage_id = \"none\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = \"none\"\n ticket2.type = \"replace\"\n ticket2.phage_id = \"none\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 0)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 0)","def unique(combo, out):\n # This lets us find only minimally covering payments (you should never add cards to a payment that already\n # satisfies the charge)\n for el in out:\n if set(el).issubset(combo):\n return False\n return True","def removeDuplicates(list):\n\treturn Set((item for item in list))","def testDuplicate(self,permutations=True):\n # This algorithm is faster than encode,\n # but for nplex=2 enmagic2 would probably still be faster.\n if permutations:\n C = self.copy()\n C.sort(axis=1)\n else:\n C = self\n ind = sortByColumns(C)\n C = C.take(ind,axis=0)\n ok = (C != roll(C,1,axis=0)).any(axis=1)\n if not ok[0]: # all duplicates -> should result in one unique element\n ok[0] = True\n return ind,ok","def removeDuplicates(list):\n\treturn set((item for item in list))","def uniq(seq):\r\n #TODO: consider building a set out of seq so that the if condition\r\n #is constant time -JB\r\n return [x for i, x in enumerate(seq) if seq.index(x) == i]","def unique(seen, *iterables):\n _add = seen.add\n # return a generator of the unique items and the set of the seen items\n # the seen set will mutate when the generator is iterated over\n return (i for i in chain(*iterables) if i not in seen and not _add(i))","def test_repeated_calls_different_quotes(self):\n quoteSet = set()\n for i in range(5):\n quoteSet.add(getRandomJoke()[\"joke\"])\n self.assertEqual(len(quoteSet) > 1, True)","def ensure_unique(iterable, max_skips=float('inf')):\n old = set()\n iterator = iter(iterable)\n try:\n while True:\n i = 0\n while i <= max_skips:\n x = next(iterator)\n if x not in old:\n yield x\n old.add(x)\n break\n i += 1\n else:\n break\n except StopIteration:\n pass","def unique(self):\n return frozenset(self)","def unique(arr):\n seen = set()\n for elem in arr:\n if elem not in seen:\n yield elem\n seen.add(elem)","def equal_sets(S):\n s0 = S[0]\n res = True\n for i in range(1, len(S)):\n res = res and s0 == S[i]\n return res","def equal_sets(S):\n s0 = S[0]\n res = True\n for i in range(1, len(S)):\n res = res and s0 == S[i]\n return res","def has_duplicates(list):\n for i in list:\n if list.count(i) > 1:\n return True\n else:\n return False","def check_duplicate(self, state):\n pass","def only_once(self) -> bool:\n return self.times == 1","def has_duplicates(some_list):\n # This function will take a list and check is some element appears more than 1 time return True, If not return False.\n check = False\n for e in some_list:\n for i in range(len(some_list)):\n #print(\"{0:>3} {1:<3}\".format(f\"{e}\",f\"{some_list[i]}\"),end=\"\")\n if e == some_list[i] and some_list.index(e) != i:\n check = True\n else:\n pass\n #print(\"\")\n return check","def distinct(self):\n memory = set()\n\n def _distinct(iterator):\n while True:\n item = next(iterator)\n if item in memory:\n continue\n memory.add(item)\n return item\n return self.__class__(self, _distinct)","def removeDuplicates(seq):\r\n seen = set()\r\n seen_add = seen.add\r\n return [x for x in seq if not (x in seen or seen_add(x))]","def sum_in_set_linear(array, x):\n\n s = set() \n for i in range(len(array)):\n diff = x - array[i]\n if diff in s:\n return True\n s.add(array[i])\n return False","def first_identity_law(x):\n return first(id_, x) == id_(x)","def unique(L):\r\n if len(L) == 0:\r\n return True\r\n elif L[0] in L[1:]:\r\n return False\r\n else:\r\n return unique(L[1:]) # recursion is OK in this function!\r","def __init__(self):\n self.set = set()","def test_phonebook_with_duplicate_entries_is_inconsostent(self):\n self.phonebook.add(\"Bob\", \"12345\")\n self.phonebook.add(\"Mary\", \"12345\")\n self.assertFalse(self.phonebook.is_consistent())","def shares_at_least_one_element_with(self, other_value):\n value = self._to_frozenset(self.value)\n other_value: frozenset = self._to_frozenset(other_value)\n if value & other_value:\n return True\n return False","def part_one(inp: defaultdict) -> int:\n result = set()\n color_queue = deque([\"shiny gold\"])\n while color_queue:\n for value in inp[color_queue.popleft()]:\n if value not in result:\n result.add(value)\n color_queue.append(value)\n return len(result)","def get_one(_set):\r\n assert _set # _set is not empty\r\n return next(iter(_set))","def test():\n # Check all numbers are unique\n from collections import defaultdict\n a = defaultdict()\n for i in range(SIZE+1):\n if encode(i) in a:\n return False\n a[encode(i)] = i","def commonSetElementPredicate(field_set: Sequence[Any]) -> FrozenSet[str]:\n\n return frozenset(str(item) for item in field_set)","def test_set_creation():\r\n test_list = [1, 2, 1, 3] # it is alist\r\n set1 = set(test_list)\r\n assert {1,2,3} == set1 # randomly arranged and don't allow duplicates\r\n\r\n test_string = \"apple\"\r\n set2 = set(test_string)\r\n assert {'a','p','l','e'} == set2\r\n\r\n test_dict = { 1: \"one\", 2 : \"two\"}\r\n set3 = set(test_dict)\r\n assert {1,2} == set3 #only keys are considered\r\n\r\n set4 = set(test_dict.values())\r\n assert {\"one\",\"two\"} == set4\r\n\r\n set5 = set(test_dict.items())\r\n assert set([(2, 'two'), (1, 'one')]) == set5 ######################DOUBT\r","def search_not_uniq(list):\n\n not_uniq = {}\n for i in set(list):\n count = list.count(i)\n if count != 1:\n not_uniq[i] = count\n return not_uniq","def unique(seq, key=identity):\n seen = set()\n for item in seq:\n tag = key(item)\n if tag not in seen:\n seen.add(tag)\n yield item"],"string":"[\n \"def has_duplicates_set(L):\\r\\n return len(L) != len(set(L))\",\n \"def is_unique(x):\\n return len(set(x)) == len(x)\",\n \"def contains_duplicate_fast_set(self, nums: List[int]) -> bool:\\n visited = set()\\n for i in nums:\\n if i in visited:\\n return True\\n visited.add(i)\",\n \"def contains_duplicate_full_slow_set(self, nums: List[int]) -> bool:\\n return len(nums) != len(set(nums))\",\n \"def containsDuplicateSet(self, nums):\\n distinct_nums = set()\\n for number in nums:\\n if number in distinct_nums:\\n return True\\n distinct_nums.add(number)\\n return False\",\n \"def find_duplicates(lst):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return len( set(lst) ) != len(lst)\",\n \"def check_if_duplicates_list(list_of_elems):\\n set_of_elems = set()\\n for elem in list_of_elems:\\n if elem in set_of_elems:\\n return True\\n else:\\n set_of_elems.add(elem)\\n return False\",\n \"def has_duplicates(lst):\\n\\n return len(lst) != len(set(lst))\",\n \"def has_duplicates(l):\\r\\n return len(set(l)) < len(l)\",\n \"def test_contains(self):\\n s = djset()\\n s.add([1, 2, 3])\\n s.add([4, 5, 6])\\n self.assertTrue(2 in s)\\n self.assertTrue(5 in s)\",\n \"def SetFunction():\\r\\n s2 = []\\r\\n s3 = []\\r\\n s4 = []\\r\\n s2 = { i for i in range(21) if i%2 == 0}\\r\\n s3 = { i for i in range(21) if i%3 == 0}\\r\\n s4 = { i for i in range(21) if i%4 == 0}\\r\\n s2 = set(s2)\\r\\n s3 = set(s3)\\r\\n s4 = set(s4)\\r\\n print s3.issubset(s2)\\r\\n print s4.issubset(s2)\",\n \"def check_no_duplicates(examples):\\n return len(examples) == len(set(examples))\",\n \"def _unique_everseen(iterable, key=None):\\n seen = set()\\n seen_add = seen.add\\n if key is None:\\n for element in itertools.filterfalse(seen.__contains__, iterable):\\n seen_add(element)\\n yield element\\n else:\\n for element in iterable:\\n k = key(element)\\n if k not in seen:\\n seen_add(k)\\n yield element\",\n \"def deleteduplicates(iterable):\\n seen = []\\n for x in iterable:\\n if x not in seen:\\n yield x\\n seen.append(x)\",\n \"def has_duplicates(L):\\r\\n unique = []\\r\\n for e in L:\\r\\n if e in unique:\\r\\n return True\\r\\n unique.append(e)\\r\\n return False\",\n \"def isdistinct(seq):\\n return len(seq) == len(set(seq))\",\n \"def uniqueCheckSet(aList):\\r\\n check = set()\\r\\n for v in aList:\\r\\n if v in check:\\r\\n return True\\r\\n check.add(v)\\r\\n return False\",\n \"def tuple_has_duplicates(my_tuple):\\n\\n duplicates = []\\n for i in my_tuple:\\n if my_tuple.count(i) > 1 and i not in duplicates:\\n duplicates.append(i)\\n counter = 0\\n # for k in my_tuple:\\n # if i == k:\\n # counter += 1\\n # if counter > 1 and i not in duplicates:\\n # duplicates.append(i)\\n if duplicates:\\n return duplicates\\n else:\\n return False\",\n \"def UniqueIterator(iterator):\\r\\n so_far = set()\\r\\n def no_dups(x):\\r\\n if x in so_far:\\r\\n return False\\r\\n else:\\r\\n so_far.add(x)\\r\\n return True\\r\\n\\r\\n return IteratorFilter(iterator, no_dups)\",\n \"def duplicate_check(method):\\n\\n def predicate(entry):\\n entry_hash = predicate.unique(entry)\\n if entry_hash not in predicate.state:\\n predicate.state.add(entry_hash)\\n return False\\n return True\\n\\n predicate.unique = method\\n predicate.state = set()\\n return predicate\",\n \"def all_unique_set(string):\\n return len(string) == len(set(string))\",\n \"def set(x):\\n pass\",\n \"def test_exclusive(self):\\n s = djset()\\n s.add([1, 2, 3])\\n s.add([4, 5, 6])\\n self.assertEquals({1, 2, 3}, s.data[1])\\n self.assertEquals({4, 5, 6}, s.data[4])\",\n \"def isUnique(collection):\\n\\n # Implemented using a hash table:\\n memo = set()\\n for element in collection:\\n if element in memo:\\n return False\\n memo.add(element)\\n\\n return True\\n\\n # Time Complexity: O(n)\\n # Space Complexity: O(m), where m is the number of unique elements. If this is a string with alphabetical letters, then it is going to be either 26 or 52 elements long depending on if we care about case sensitivity.\\n\\n\\n # Implemented without additional structures\\n end = len(collection)\\n for i in range(end-1):\\n temp_base = collection[i]\\n for j in range(i + 1, end):\\n if temp_base == collection[j]:\\n return False\\n\\n return True\\n\\n # Time Complexity: O(n^2)\\n # Space Complexity: O(1)\",\n \"def unique(iterable):\\n seen = set()\\n return [i for i in iterable if not (i in seen or seen.add(i))]\",\n \"def all_in_set(the_set, the_list):\\n return True\",\n \"def unique(iterable):\\n seen_items = set()\\n for item in iterable:\\n if item not in seen_items:\\n yield item\\n seen_items.add(item)\",\n \"def check_unique(self):\\n pass\",\n \"def unique(iterable):\\n seen = set()\\n return [x for x in iterable if x not in seen and not seen.add(x)]\",\n \"def uniq(elements):\\n us = set()\\n ret = []\\n for e in elements:\\n if e not in us:\\n ret.append(e)\\n us.add(e)\\n return ret\",\n \"def set():\",\n \"def is_unique_n_set(string: str) -> bool:\\n\\n return len(set(string)) == len(string)\",\n \"def is_unique_value(x: List[dict], key):\\n return len(x) == len(set([v[key] for v in x]))\",\n \"def uniq(seq):\\r\\n seen = set()\\r\\n seen_add = seen.add\\r\\n return [x for x in seq if x not in seen and not seen_add(x)]\",\n \"def _find_element_not_in_set(self, already_used: set) -> int:\\n new_element = random.randint(a=self.min_value, b=self.max_value)\\n while new_element in already_used:\\n new_element = random.randint(a=self.min_value, b=self.max_value)\\n return new_element\",\n \"def unique(li):\\r\\n seen = set()\\r\\n seen_add = seen.add\\r\\n return [x for x in li if not (x in seen or seen_add(x))]\",\n \"def unique_everseen(iterable, key = None):\\n seen = set()\\n seen_add = seen.add\\n if key is None:\\n for element in ifilterfalse(seen.__contains__, iterable):\\n seen_add(element)\\n yield element\\n else:\\n for element in iterable:\\n k = key(element)\\n if k not in seen:\\n seen_add(k)\\n yield element\",\n \"def set_of(element: Type) -> SetType:\\n return SetType(element)\",\n \"def has_duplicates_dict(L):\\r\\n unique = {}\\r\\n for e in L:\\r\\n if e in unique:\\r\\n return True\\r\\n unique[e] = 0\\r\\n return False\",\n \"def remove_duplicates(somelist):\\n return set(somelist)\",\n \"def unique(iterable, filterfalse=filterfalse):\\n seen = set()\\n add = seen.add\\n for element in filterfalse(seen.__contains__, iterable):\\n add(element)\\n yield element\",\n \"def unique_everseen(iterable, key=None):\\n seen = set()\\n seen_add = seen.add\\n if key is None:\\n for element in itertools.ifilterfalse(seen.__contains__, iterable):\\n seen_add(element)\\n yield element\\n else:\\n for element in iterable:\\n k = key(element)\\n if k not in seen:\\n seen_add(k)\\n yield element\",\n \"def uniquify(seq):\\n seen = set()\\n seen_add = seen.add\\n return [ x for x in seq if x not in seen and not seen_add(x)]\",\n \"def uniq_stable(elems):\\r\\n unique = []\\r\\n unique_set = set()\\r\\n for nn in elems:\\r\\n if nn not in unique_set:\\r\\n unique.append(nn)\\r\\n unique_set.add(nn)\\r\\n return unique\",\n \"def checkUniqueness_(self, list):\\n\\n uniqueList = []\\n # use a list comprehension statement (takes a while to understand) \\n\\n [uniqueList.append(it) for it in list if not uniqueList.count(it)]\\n\\n return (len(list)==len(uniqueList))\",\n \"def test_set(self):\\n a = set()\\n a.add('b')\\n a.add('c')\\n a.add('a')\\n b = list(a)\\n b.sort()\\n self.assertEqual(b, ['a', 'b', 'c'])\\n a.remove('b')\\n b = list(a)\\n b.sort()\\n self.assertEqual(b, ['a', 'c'])\\n\\n a.discard('d')\\n\\n b = set(['r', 's'])\\n d = a.union(b)\\n b = list(d)\\n b.sort()\\n self.assertEqual(b, ['a', 'c', 'r', 's'])\",\n \"def is_set(obj):\\n return type(obj) is set\",\n \"def list_should_not_contain_duplicates(self,list_,msg=None):\\r\\n if not isinstance(list_,list):\\r\\n list_= list(list_)\\r\\n dupes = []\\r\\n for item in list_:\\r\\n if item not in dupes:\\r\\n count = list_.count(item)\\r\\n if count >1:\\r\\n logger.info(\\\" '%s' found %d times\\\" %(item,count))\\r\\n dupes.append(item)\\r\\n if dupes:\\r\\n raise AssertionError(msg or '%s found multiple times' %seq2str(dupes))\",\n \"def findSetWithElement(self, element, \\n is_present=True):\\n sets = [s for s in self.sets if element in s]\\n if len(sets) > 1:\\n raise RuntimeError(\\\"Should have at most instance of values.\\\")\\n if len(sets) == 0:\\n if is_present:\\n raise ValueError(\\\"%s is not present\\\" % str(element))\\n result = cn.NULL_SET \\n else:\\n result = sets[0]\\n return result\",\n \"def list_set(seq):\\n seen = set()\\n seen_add = seen.add\\n return [x for x in seq if not (x in seen or seen_add(x))]\",\n \"def remove_duplicates_badSolution( li ):\\n newli=[]\\n seen = set()\\n for item in li:\\n if item not in seen:\\n seen.add( item )\\n newli.append(item)\\n\\n return newli\",\n \"def unique_list(var):\\n return len([x for x in set(var)]) == len(var)\",\n \"def test_identify_duplicates_3(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"L5\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 1\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"Trixie\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 1)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 0)\",\n \"def test_single(self):\\n s = djset()\\n s.add([1, 2, 3])\\n self.assertEquals({1, 2, 3}, s.data[1])\",\n \"def unique_elem(o: list[str]) -> bool:\\n return True if len(Counter(remove_spaces(o))) == len(o) else False\",\n \"def has_duplicates(t):\\n\\n\\t# Each element will check each following elements for its duplicate\\n\\t# An element looking for duplicates before itself is redundant\\n\\tfor i in range(len(t)):\\n\\t\\tfor n in t[i + 1:]:\\n\\t\\t\\tif t[i] == n:\\n\\t\\t\\t\\treturn True\\n\\treturn False\",\n \"def test_identify_duplicates_4(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"Trixie\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 2\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"Trixie\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 0)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 1)\",\n \"def _raise_if_duplicates(counts: Dict[str, int]) -> None:\\n duplicates: List[str] = []\\n for nickname, count in counts.items():\\n if count > 1:\\n duplicates.append(nickname)\\n if len(duplicates) > 0:\\n # TODO This is not always nickname\\n raise ValueError(f'\\\\'nickname\\\\' not unique {duplicates}')\",\n \"def clean_duplicate(self):\\r\\n self.elements = list(set(self.elements))\\r\\n self.elements = [e for e in self.elements if e != '']\",\n \"def is_unique(self):\\r\\n return self._unique\",\n \"def test_identify_duplicates_6(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"Trixie\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 1\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"Trixie\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 1)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 1)\",\n \"def getSet(unique_name):\",\n \"def getSet(unique_name):\",\n \"def unique(iterable, key=None):\\n\\n\\tif key is None:\\n\\t\\tkey = identity\\n\\n\\tseen = set()\\n\\tseen_add = seen.add\\n\\tfor v in iterable:\\n\\t\\tk = key(v)\\n\\t\\tif k not in seen:\\n\\t\\t\\tyield v\\n\\t\\t\\tseen_add(k)\",\n \"def distinct(iterable):\\n\\n def distincting(iterable_):\\n set_of_distinct_values = set()\\n for i in iterable_:\\n if i not in set_of_distinct_values:\\n set_of_distinct_values.add(i)\\n yield i\\n\\n return distincting(iterable)\",\n \"def _test_sampdup(t):\\n return t.shape[1] != len(set(t.ids(axis='sample')))\",\n \"def unique_justseen(iterable, key = None):\\n return imap(next, imap(operator.itemgetter(1), groupby(iterable, key)))\",\n \"def test_identify_duplicates_1(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"Trixie\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 2\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"L5\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 0)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 0)\",\n \"def unique(iterable, key=None):\\n # type: (Iterable[T], Optional[Callable[[T], Hashable]]) -> Iterable[T]\\n seen = set()\\n if key is None:\\n key = lambda t: t\\n for el in iterable:\\n el_k = key(el)\\n if el_k not in seen:\\n seen.add(el_k)\\n yield el\",\n \"def test_identify_duplicates_2(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = \\\"none\\\"\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"none\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = \\\"none\\\"\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"none\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 0)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 0)\",\n \"def unique(combo, out):\\n # This lets us find only minimally covering payments (you should never add cards to a payment that already\\n # satisfies the charge)\\n for el in out:\\n if set(el).issubset(combo):\\n return False\\n return True\",\n \"def removeDuplicates(list):\\n\\treturn Set((item for item in list))\",\n \"def testDuplicate(self,permutations=True):\\n # This algorithm is faster than encode,\\n # but for nplex=2 enmagic2 would probably still be faster.\\n if permutations:\\n C = self.copy()\\n C.sort(axis=1)\\n else:\\n C = self\\n ind = sortByColumns(C)\\n C = C.take(ind,axis=0)\\n ok = (C != roll(C,1,axis=0)).any(axis=1)\\n if not ok[0]: # all duplicates -> should result in one unique element\\n ok[0] = True\\n return ind,ok\",\n \"def removeDuplicates(list):\\n\\treturn set((item for item in list))\",\n \"def uniq(seq):\\r\\n #TODO: consider building a set out of seq so that the if condition\\r\\n #is constant time -JB\\r\\n return [x for i, x in enumerate(seq) if seq.index(x) == i]\",\n \"def unique(seen, *iterables):\\n _add = seen.add\\n # return a generator of the unique items and the set of the seen items\\n # the seen set will mutate when the generator is iterated over\\n return (i for i in chain(*iterables) if i not in seen and not _add(i))\",\n \"def test_repeated_calls_different_quotes(self):\\n quoteSet = set()\\n for i in range(5):\\n quoteSet.add(getRandomJoke()[\\\"joke\\\"])\\n self.assertEqual(len(quoteSet) > 1, True)\",\n \"def ensure_unique(iterable, max_skips=float('inf')):\\n old = set()\\n iterator = iter(iterable)\\n try:\\n while True:\\n i = 0\\n while i <= max_skips:\\n x = next(iterator)\\n if x not in old:\\n yield x\\n old.add(x)\\n break\\n i += 1\\n else:\\n break\\n except StopIteration:\\n pass\",\n \"def unique(self):\\n return frozenset(self)\",\n \"def unique(arr):\\n seen = set()\\n for elem in arr:\\n if elem not in seen:\\n yield elem\\n seen.add(elem)\",\n \"def equal_sets(S):\\n s0 = S[0]\\n res = True\\n for i in range(1, len(S)):\\n res = res and s0 == S[i]\\n return res\",\n \"def equal_sets(S):\\n s0 = S[0]\\n res = True\\n for i in range(1, len(S)):\\n res = res and s0 == S[i]\\n return res\",\n \"def has_duplicates(list):\\n for i in list:\\n if list.count(i) > 1:\\n return True\\n else:\\n return False\",\n \"def check_duplicate(self, state):\\n pass\",\n \"def only_once(self) -> bool:\\n return self.times == 1\",\n \"def has_duplicates(some_list):\\n # This function will take a list and check is some element appears more than 1 time return True, If not return False.\\n check = False\\n for e in some_list:\\n for i in range(len(some_list)):\\n #print(\\\"{0:>3} {1:<3}\\\".format(f\\\"{e}\\\",f\\\"{some_list[i]}\\\"),end=\\\"\\\")\\n if e == some_list[i] and some_list.index(e) != i:\\n check = True\\n else:\\n pass\\n #print(\\\"\\\")\\n return check\",\n \"def distinct(self):\\n memory = set()\\n\\n def _distinct(iterator):\\n while True:\\n item = next(iterator)\\n if item in memory:\\n continue\\n memory.add(item)\\n return item\\n return self.__class__(self, _distinct)\",\n \"def removeDuplicates(seq):\\r\\n seen = set()\\r\\n seen_add = seen.add\\r\\n return [x for x in seq if not (x in seen or seen_add(x))]\",\n \"def sum_in_set_linear(array, x):\\n\\n s = set() \\n for i in range(len(array)):\\n diff = x - array[i]\\n if diff in s:\\n return True\\n s.add(array[i])\\n return False\",\n \"def first_identity_law(x):\\n return first(id_, x) == id_(x)\",\n \"def unique(L):\\r\\n if len(L) == 0:\\r\\n return True\\r\\n elif L[0] in L[1:]:\\r\\n return False\\r\\n else:\\r\\n return unique(L[1:]) # recursion is OK in this function!\\r\",\n \"def __init__(self):\\n self.set = set()\",\n \"def test_phonebook_with_duplicate_entries_is_inconsostent(self):\\n self.phonebook.add(\\\"Bob\\\", \\\"12345\\\")\\n self.phonebook.add(\\\"Mary\\\", \\\"12345\\\")\\n self.assertFalse(self.phonebook.is_consistent())\",\n \"def shares_at_least_one_element_with(self, other_value):\\n value = self._to_frozenset(self.value)\\n other_value: frozenset = self._to_frozenset(other_value)\\n if value & other_value:\\n return True\\n return False\",\n \"def part_one(inp: defaultdict) -> int:\\n result = set()\\n color_queue = deque([\\\"shiny gold\\\"])\\n while color_queue:\\n for value in inp[color_queue.popleft()]:\\n if value not in result:\\n result.add(value)\\n color_queue.append(value)\\n return len(result)\",\n \"def get_one(_set):\\r\\n assert _set # _set is not empty\\r\\n return next(iter(_set))\",\n \"def test():\\n # Check all numbers are unique\\n from collections import defaultdict\\n a = defaultdict()\\n for i in range(SIZE+1):\\n if encode(i) in a:\\n return False\\n a[encode(i)] = i\",\n \"def commonSetElementPredicate(field_set: Sequence[Any]) -> FrozenSet[str]:\\n\\n return frozenset(str(item) for item in field_set)\",\n \"def test_set_creation():\\r\\n test_list = [1, 2, 1, 3] # it is alist\\r\\n set1 = set(test_list)\\r\\n assert {1,2,3} == set1 # randomly arranged and don't allow duplicates\\r\\n\\r\\n test_string = \\\"apple\\\"\\r\\n set2 = set(test_string)\\r\\n assert {'a','p','l','e'} == set2\\r\\n\\r\\n test_dict = { 1: \\\"one\\\", 2 : \\\"two\\\"}\\r\\n set3 = set(test_dict)\\r\\n assert {1,2} == set3 #only keys are considered\\r\\n\\r\\n set4 = set(test_dict.values())\\r\\n assert {\\\"one\\\",\\\"two\\\"} == set4\\r\\n\\r\\n set5 = set(test_dict.items())\\r\\n assert set([(2, 'two'), (1, 'one')]) == set5 ######################DOUBT\\r\",\n \"def search_not_uniq(list):\\n\\n not_uniq = {}\\n for i in set(list):\\n count = list.count(i)\\n if count != 1:\\n not_uniq[i] = count\\n return not_uniq\",\n \"def unique(seq, key=identity):\\n seen = set()\\n for item in seq:\\n tag = key(item)\\n if tag not in seen:\\n seen.add(tag)\\n yield item\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7018525","0.69216627","0.6786688","0.67724","0.65951574","0.6533579","0.6502767","0.6317338","0.62912786","0.6264362","0.6228308","0.62009895","0.61905575","0.61454374","0.6141629","0.6129668","0.61090344","0.6108465","0.6100084","0.6098274","0.6094932","0.60907483","0.6076937","0.60700774","0.6053664","0.6051744","0.6051705","0.60514486","0.6040108","0.60387385","0.602929","0.60221016","0.60182554","0.60167634","0.60068405","0.59960264","0.599582","0.59948707","0.59790903","0.5973878","0.5959725","0.59516805","0.5928378","0.5915146","0.5899542","0.58861345","0.58772105","0.5861164","0.58603084","0.58583933","0.5850202","0.5845001","0.5828397","0.58274853","0.582682","0.5816741","0.5814643","0.5804382","0.5803657","0.5802051","0.57865334","0.5784532","0.5784532","0.5782898","0.57823217","0.5781371","0.5772374","0.5769382","0.5763823","0.5756273","0.5754743","0.57496244","0.57495034","0.5746207","0.5743401","0.57366806","0.5729933","0.5728244","0.5728163","0.57260334","0.57165444","0.57165444","0.5707654","0.5699519","0.5696188","0.56861573","0.5682054","0.5681369","0.56767887","0.56696373","0.56630105","0.5652484","0.5648354","0.5631386","0.56308854","0.5626293","0.562417","0.5623516","0.5618388","0.5610421","0.5601203"],"string":"[\n \"0.7018525\",\n \"0.69216627\",\n \"0.6786688\",\n \"0.67724\",\n \"0.65951574\",\n \"0.6533579\",\n \"0.6502767\",\n \"0.6317338\",\n \"0.62912786\",\n \"0.6264362\",\n \"0.6228308\",\n \"0.62009895\",\n \"0.61905575\",\n \"0.61454374\",\n \"0.6141629\",\n \"0.6129668\",\n \"0.61090344\",\n \"0.6108465\",\n \"0.6100084\",\n \"0.6098274\",\n \"0.6094932\",\n \"0.60907483\",\n \"0.6076937\",\n \"0.60700774\",\n \"0.6053664\",\n \"0.6051744\",\n \"0.6051705\",\n \"0.60514486\",\n \"0.6040108\",\n \"0.60387385\",\n \"0.602929\",\n \"0.60221016\",\n \"0.60182554\",\n \"0.60167634\",\n \"0.60068405\",\n \"0.59960264\",\n \"0.599582\",\n \"0.59948707\",\n \"0.59790903\",\n \"0.5973878\",\n \"0.5959725\",\n \"0.59516805\",\n \"0.5928378\",\n \"0.5915146\",\n \"0.5899542\",\n \"0.58861345\",\n \"0.58772105\",\n \"0.5861164\",\n \"0.58603084\",\n \"0.58583933\",\n \"0.5850202\",\n \"0.5845001\",\n \"0.5828397\",\n \"0.58274853\",\n \"0.582682\",\n \"0.5816741\",\n \"0.5814643\",\n \"0.5804382\",\n \"0.5803657\",\n \"0.5802051\",\n \"0.57865334\",\n \"0.5784532\",\n \"0.5784532\",\n \"0.5782898\",\n \"0.57823217\",\n \"0.5781371\",\n \"0.5772374\",\n \"0.5769382\",\n \"0.5763823\",\n \"0.5756273\",\n \"0.5754743\",\n \"0.57496244\",\n \"0.57495034\",\n \"0.5746207\",\n \"0.5743401\",\n \"0.57366806\",\n \"0.5729933\",\n \"0.5728244\",\n \"0.5728163\",\n \"0.57260334\",\n \"0.57165444\",\n \"0.57165444\",\n \"0.5707654\",\n \"0.5699519\",\n \"0.5696188\",\n \"0.56861573\",\n \"0.5682054\",\n \"0.5681369\",\n \"0.56767887\",\n \"0.56696373\",\n \"0.56630105\",\n \"0.5652484\",\n \"0.5648354\",\n \"0.5631386\",\n \"0.56308854\",\n \"0.5626293\",\n \"0.562417\",\n \"0.5623516\",\n \"0.5618388\",\n \"0.5610421\",\n \"0.5601203\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93486,"cells":{"query":{"kind":"string","value":"Creates the intersection for both sets"},"document":{"kind":"string","value":"def intersection(A,B):\n set_A = A\n set_B = B\n sorted_intersection = []\n for elements in set_A:\n if elements in set_B:\n sorted_intersection.append(elements)\n return sorted_intersection"},"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 set_intersection(set_a, set_b):\n \n intersection = set_b & set_a\n \n return intersection","def intersection(self, *other):\n new_ordered_set = OrderedSet()\n\n for element in self:\n for obj in other:\n if element not in obj:\n break\n else:\n new_ordered_set.add(element)\n\n return new_ordered_set","def intersection(set_1, set_2):\n intersection_list = []\n\n for number in set_1:\n if number in set_2:\n intersection_list.append(number)\n \n print(\"Intersection:\", intersection_list)\n return set_1, set_2","def intersection(self, s2):\n s1 = self\n if s1.is_full:\n return s2\n if s2.is_full:\n return s1\n return IdSet(s1._set.intersection(s2._set))","def intersection(a, b):\n return list(set(a) & set(b))","def intersection(A, B, *C):\n return setutils(\"intersection\", A, B, *C)","def intersection(self, other):\n intersection_set = Set()\n\n for bucket in self.buckets:\n for element in bucket.iterate():\n if other.contains(element):\n intersection_set.add(element)\n return intersection_set","def intersect(a, b):\r\n return list(set(a) & set(b))","def intersect_set(list1, list2):\n return (set(list1) & set(list2))","def intersect(a,b):\n\treturn list(set(a) & set(b))","def intersect(a, b):\n return(list(set(a) & set(b)))","def intersect(self, left=[], right=[]):\n return list(set(left).intersection(right))","def intersect(self, other):\n result = IntSet()\n map(result.insert, [e for e in self.vals if e in other.vals])\n return result","def intersect(a, b):\n return list(set(a) & set(b))","def intersect(self, other):\n # Initialize a new intSet \n commonValueSet = intSet()\n # Go through the values in this set\n for val in self.vals:\n # Check if each value is a member of the other set \n if other.member(val):\n commonValueSet.insert(val)\n return commonValueSet","def intersection(stack):\n assertArity(stack, 2)\n rhs, lhs = stack.pop(), stack.pop()\n assertType(lhs, Set)\n assertType(rhs, Set)\n return Set(lhs & rhs)","def intersection(sets):\n return functools.reduce(set.intersection, [s for s in sets])","def __intersect(a, b):\n a = [elem.lower() for elem in a]\n b = [elem.lower() for elem in b]\n return list(set(a) & set(b))","def intersection(self, *lists):\n if self.is_a(set):\n return _(self._.intersection(*lists))\n return _(_intersection(self._, *lists))","def intersection(sets):\n return reduce(set.intersection, [s for s in sets])","def intersect(self, *args, **kwargs): # real signature unknown\n pass","def __intersect(self, a, b):\n a = [elem.lower() for elem in a]\n b = [elem.lower() for elem in b]\n return list(set(a) & set(b))","def __and__(self, other):\n return intersect(self, other)","def intersection_signature(*sets):\n return reduce(operator.and_, sets)","def intersection(p1: Iterator[Posting], p2: Iterator[Posting]) -> Iterator[Posting]:\n raise NotImplementedError(\"You need to implement this as part of the assignment.\")","def intersection(s1, s2):\n \"*** YOUR CODE HERE ***\"\n return s1.intersection(s2) # ...","def union(set1, set2):","def find_intersection(set_1, set_2):\n\n # PyTorch auto-broadcasts singleton dimensions\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)","def find_intersection(set_1, set_2):\n\n # PyTorch auto-broadcasts singleton dimensions\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)","def find_intersection(set_1, set_2):\n\n # PyTorch auto-broadcasts singleton dimensions\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)","def find_intersection(set_1, set_2):\n\n # PyTorch auto-broadcasts singleton dimensions\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)","def intersect(t1,t2):\n result=()\n for e in t1:\n if e in t2:\n result += (e,)\n return result","def intersection(self, other):\n new_ieqs = []\n new_ieqs.extend(self.inequalities())\n new_ieqs.extend(other.inequalities())\n\n new_eqns = []\n new_eqns.extend(self.equations())\n new_eqns.extend(other.equations())\n\n return Polyhedron(ieqs = new_ieqs, eqns = new_eqns, \n field=self.coerce_field(other))","def intersect(self, other_list):\n assert type(other_list) == type(self)\n \n# if len(self.vals) >= len(other_list.vals):\n# big = self.vals\n# small = other_list.vals\n# else:\n# small = self.vals\n# big = other_list.vals\n# \n# common_list = intSet()\n# for e in big:\n# if e in small:\n# common_list.insert(e)\n# return common_list\n\n common_list = intSet() \n for e in self.vals:\n if other_list.member(e): #if the current e is a member of other_list\n common_list.insert(e)\n return common_list","def find_intersection(set_1, set_2):\n # PyTorch auto-broadcasts singleton dimensions\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)","def intersect(self, other):\n return Intersection(self, other)","def intersect(a, b): \n # print(len(list(set(a) & set(b))), 'unique and matching names between FPL and Understat')\n return list(set(a) & set(b))","def intersection(self, other):\n return self._geomgen(capi.geom_intersection, other)","def intersection(cls, forms):\n result = forms[0]\n for form in forms[1:]:\n result = cls.intersectionTwoForms(result, form)\n return result","def intersection(self, *others):\r\n return self.r.sinter(self.r_key, *[o.r_key for o in others])","def intersection(self, other): # -> BaseGeometry:\n ...","def _exclusive_intersect(self, keys):\n #inc_s = reduce(lambda x, y: x.intersection(y), \n # (self[x] for x in keys))\n inc_s = self[keys[0]].copy()\n for other_key in self:\n if other_key in keys:\n inc_s.intersection_update(self[other_key])\n else:\n inc_s.difference_update(self[other_key])\n\n return inc_s","def find_intersection(nums1, nums2)->list:\n set1 = set(nums1)\n set2 = set(nums2)\n intersection = set()\n\n for i in set1:\n if i in set2: # The item is in both lists\n intersection.add(i)\n return list(intersection)","def intersect(iterable, other):\n return 0","def find_intersection(self, other):\n newcls = self.__class__(None)\n mlist = newcls._find_members(self.members + other.members)\n poly = self.intersection(other)\n newcls.set_members(mlist, poly)\n return newcls","def intersection(self):\n return Intersection(self.source, self)","def intersection(llist_1 : LinkedList, llist_2 : LinkedList) -> LinkedList:\n # Convert to set to remove repeated entries in each list\n lset_1 = list_to_set(llist_1)\n lset_2 = list_to_set(llist_2)\n\n # Initialize empty intersec_list\n intersec_list = LinkedList()\n \n # Populate list_of_candidates with all elements from lset_1\n list_of_candidates = []\n for item in lset_1:\n list_of_candidates.append(item)\n\n # Only add to intersec_list the items from lset_2 available in list_of_candidates\n for item in lset_2:\n if item in list_of_candidates:\n intersec_list.append(item)\n\n return intersec_list","def __and__(self, other):\n return self.intersection(other)","def intersection(self, other):\n return _binary_geo(arctern.ST_Intersection, self, other)","def simplify_intersection(args):\n\n # ===== Global Rules =====\n if not args:\n return S.UniversalSet\n\n for arg in args:\n if not isinstance(arg, Set):\n raise TypeError(\"Input args to Union must be Sets\")\n\n # If any EmptySets return EmptySet\n if S.EmptySet in args:\n return S.EmptySet\n\n # Handle Finite sets\n rv = Intersection._handle_finite_sets(args)\n\n if rv is not None:\n return rv\n\n # If any of the sets are unions, return a Union of Intersections\n for s in args:\n if s.is_Union:\n other_sets = set(args) - {s}\n if len(other_sets) > 0:\n other = Intersection(*other_sets)\n return Union(*(Intersection(arg, other) for arg in s.args))\n else:\n return Union(*s.args)\n\n for s in args:\n if s.is_Complement:\n args.remove(s)\n other_sets = args + [s.args[0]]\n return Complement(Intersection(*other_sets), s.args[1])\n\n from sympy.sets.handlers.intersection import intersection_sets\n\n # At this stage we are guaranteed not to have any\n # EmptySets, FiniteSets, or Unions in the intersection\n\n # ===== Pair-wise Rules =====\n # Here we depend on rules built into the constituent sets\n args = set(args)\n new_args = True\n while new_args:\n for s in args:\n new_args = False\n for t in args - {s}:\n new_set = intersection_sets(s, t)\n # This returns None if s does not know how to intersect\n # with t. Returns the newly intersected set otherwise\n\n if new_set is not None:\n new_args = (args - {s, t}).union({new_set})\n break\n if new_args:\n args = new_args\n break\n\n if len(args) == 1:\n return args.pop()\n else:\n return Intersection(*args, evaluate=False)","def intersection(self, axis2):","def intersect(t1, t2):\n\n result = ()\n for e in t1:\n if e in t2:\n result += (e,) # signifies tuple\n\n return (result)","def union(self, other):\n # initialize new Set from the elements in the first Set\n union_set = Set(self.get_elements())\n\n # add every element in the second Set to a new Set and return it\n for element in other.get_elements():\n union_set.add(element)\n return union_set","def intersection(self):\n self._intersection = list(set(self.origin.columns[:]).intersection(self.destination.columns[:]))\n self._intersection.sort()\n return self._intersection","def __listintersect(self, c1, c2):\n s2 = {}\n for delta in c2:\n s2[delta] = 1\n\n\tc = []\n\tfor delta in c1:\n if s2.has_key(delta):\n\t\tc.append(delta)\n\n\treturn c","def intersection(\n cls, *availabilitysets: List[\"Availability\"]\n ) -> List[\"Availability\"]:\n\n # get rid of any overlaps and unmerged ranges in each set\n availabilitysets = [cls.union(avialset) for avialset in availabilitysets]\n # bail out for obvious cases (there are no sets given, one of the sets is empty)\n if not availabilitysets:\n return []\n if not all(availabilitysets):\n return []\n # start with the very first set ...\n result = availabilitysets[0]\n for availset in availabilitysets[1:]:\n # ... subtract each of the other sets\n result = cls._pair_intersection(result, availset)\n return result","def intersection(x, y, f, p):","def intersect(nums1: List[int], nums2: List[int]) -> List[int]:\n if not nums1 or not nums2:\n return False\n if len(nums1) == 1 and len(nums2) == 1:\n if nums1[0] == nums2[0]:\n return nums1\n\n intersection = list()\n\n for x in nums1:\n if x in nums2:\n nums2.remove(x)\n intersection.append(x)\n return intersection","def intersection(self, *others):\n other_contexts = [o.get_contexts() for o in others]\n return ContextSet(self._contexts.intersection(*other_contexts))","def intersect_sets(S):\n res = S[0]\n for s in S:\n res &= s\n return res","def intersection(lst1, lst2):\n temp = set(lst2)\n lst3 = [value for value in lst1 if value in temp]\n return lst3","def get_jurisdiction_common_members(a: List[int], b: List[int]) -> Set[int]:\n a_set = set(a)\n b_set = set(b)\n\n if a_set & b_set:\n return a_set & b_set\n else:\n return set()","def intersection(self, other):\n if other.size() != self.size():\n raise ValueError(\"Intersections are only possible on interval-posets of the same size.\")\n try:\n return TamariIntervalPoset(self.size(), self._cover_relations + other._cover_relations)\n except ValueError:\n raise ValueError(\"This intersection is empty, it does not correspond to an interval-poset.\")","def intersection(self, *others):\n other_sents = [o.get_sentences() for o in others]\n return SentenceSet(self._sentences.intersection(*other_sents))","def __mul__(self, other):\n if not isinstance(other, (Set, list)):\n raise TypeError(f\"could not intersect set and {type(other)}\")\n\n return Set(x for x in other if x in self)","def intersection(A, B):\n\n if max(0, min(A[1], B[1]) - max(A[0], B[0])):\n # intersection is not empty!\n if A[0] < B[0]:\n return [B[0], A[1]]\n else:\n return [A[0], B[1]]\n else:\n print 'Warning: intersection is an empty set!'\n return [np.nan, np.nan]","def intersect_set(n):\n set_a = set(range(n))\n set_b = set(range(n-3, 2 * n))\n start = timeit.default_timer()\n in_both = set_a.intersection(set_b)\n run_time = timeit.default_timer() - start\n return run_time, in_both","def _any_intersect(line_set_1, line_set_2, h_set_1=None, h_set_2=None):\n # try to speed this one up by reducing the number of comparisons\n # necessary. About half the time is spent in here, incl. subroutines.\n h_set_1 = [_homogenous_line(*segment) for segment in line_set_1] if h_set_1 is None else h_set_1\n h_set_2 = [_homogenous_line(*segment) for segment in line_set_2] if h_set_2 is None else h_set_2\n for h1, l1 in zip(h_set_1, line_set_1):\n for h2, l2 in zip(h_set_2, line_set_2):\n P = _intersection_homogenous(h1, h2)\n if P==(None, None): continue\n if _point_within_bounds(l1,P) and _point_within_bounds(l2,P):\n return True\n return False","def action_intersection(s1, s2):\n isect = s1 & s2\n L1 = [ ( (a.oid, a.index_oid), a) for a in s1 ]\n L2 = [ ( (a.oid, a.index_oid), a) for a in s2 ]\n ds1 = dict(L1)\n ds2 = dict(L2)\n for k1, action1 in ds1.items():\n action2 = ds2.get(k1)\n if action2 is not None:\n # replace action in union with correct one or conflict\n isect.add(which_action(action1, action2))\n return isect","def intersect(a, b):\r\n #print(a, b)\r\n #first case, we have , in gs a and gs b\r\n try:\r\n b_a = a.split(',')\r\n b_b = b.split(',')\r\n return list(set(b_a) & set(b_b))\r\n except:\r\n pass","def synonymIntersection(self, wSet1, wSet2, idf):\n intersection = wSet1.intersection(wSet2)\n w1 = wSet1 - intersection\n w2 = wSet2 - intersection\n if len(intersection) == 0:\n return set([])\n\n synonyms1 = self.getSynonyms(w1)\n synonyms2 = self.getSynonyms(w2)\n defaultIDF = idf['unknownToken']\n \n while len(w1) > 0:\n word1 = w1.pop()\n if word1 not in synonyms1:\n continue # no synonyms for this word\n \n for word2 in w2:\n if word2 not in synonyms2:\n continue # no synonyms for this word\n sharedSynsets = synonyms1[word1].intersection(synonyms2[word2])\n if len(sharedSynsets) > 0:\n # the two have at least one synset in common, consider them synonyms\n w2.remove(word2)\n if idf.get(word1, defaultIDF) > idf.get(word2, defaultIDF):\n intersection.add(word1)\n else:\n intersection.add(word2)\n break\n \n return intersection","def listops_intersect(list_a,list_b):\r\n\r\n retlist = []\r\n for item in list_a:\r\n if item in list_b:\r\n retlist.append(item)\r\n\r\n # ensure that a duplicated item in list_a is only listed once\r\n return listops_uniq(retlist)","def insercionListas(L1,L2):\n return set(L1) & set(L2)","def intersection(*entities):\n from entity import GeometryEntity\n\n entities = GeometryEntity.extract_entities(entities, False)\n if len(entities) <= 1:\n return []\n\n res = GeometryEntity.do_intersection(entities[0], entities[1])\n for entity in entities[2:]:\n newres = []\n for x in res:\n newres.extend(GeometryEntity.do_intersection(x, entity))\n res = newres\n return res","def find_intersection(wire_one_map, wire_two_map):\n return set(wire_one_map.keys()) & set(wire_two_map.keys())","def _intersect(\n series_1: TimeSeries,\n series_2: TimeSeries,\n) -> Tuple[TimeSeries, TimeSeries]:\n\n new_series_1 = series_1.slice_intersect(series_2)\n raise_if(\n len(new_series_1) == 0,\n \"Time intersection between the two series must be non empty.\",\n )\n\n return new_series_1, series_2.slice_intersect(series_1)","def intersection(self, other, bypassInclusionTest=False):\n # poly1 = copy.deepcopy(self)\n # poly2 = copy.deepcopy(other)\n poly1 = self\n poly2 = other\n noneF = []\n assert self.pnFacesInPoly()\n polyInter = polyIntersection.fromPolyhedron(poly1, poly2)\n assert all(all(v in polyInter.poly1.vertices for v in f.vertices) for f in polyInter.poly1.faces)\n assert all(all(v in polyInter.poly2.vertices for v in f.vertices) for f in polyInter.poly2.faces)\n # This handles the case of one polyhedron inside the other\n if not bypassInclusionTest:\n if len(polyInter.inter1) + len(polyInter.inter2) == 0:\n if all(f.isOnInteriorSide(poly1.vertices[0]) for f in poly2.faces):\n return poly1\n elif all(f.isOnInteriorSide(poly2.vertices[0]) for f in poly1.faces):\n return poly2\n else:\n return polyhedron([], [], [])\n assert self.pnFacesInPoly() and self.pnFacesInPoly()\n # print('step 1')\n assert polyInter.nonDoubleIntersectors()\n polyInter.createIntersectorVertices()\n # print('step 2')\n polyInter.buildEdges()\n # print('step 3')\n polyInter.buildFaces()\n return polyInter.result","def findIntersection(lOne, lTwo):\n\tsOne = set(lOne)\n\tsTwo = set(lTwo)\n\tsInt = sOne.intersection(sTwo)\n\treturn list(sInt)","def common_elements(s1, s2):\n\n return set(s1 & s2)","def intersect(self, other, abs_tol=ABS_TOL):\n if isinstance(other, Polytope):\n other = [other]\n P = Region()\n for poly0 in self:\n for poly1 in other:\n isect = poly0.intersect(poly1, abs_tol)\n rp, xp = isect.cheby\n if rp > abs_tol:\n P = union(P, isect, check_convex=True)\n return P","def intersection(list1, list2):\r\n\r\n list3 = []\r\n\r\n if not list1 and not list2: # Both lists passed as arguments are empty\r\n return list3\r\n\r\n elif not list1 and list2: # The first list passed as argument is empty\r\n return list2\r\n\r\n elif list1 and not list2: # The second list passed as argument is empty\r\n return list1\r\n\r\n else:\r\n list3 = [value for value in list1 if value in list2] # Getting only the common values of the two lists\r\n return list3","def intersection(list1, list2):\n list3 = [value for value in list1 if value in list2]\n return list3","def test_multi_intersect():\r\n\r\n arr1 = np.array(np.arange(1000).reshape(2,500))\r\n arr2 = np.array([[1,0.1,0.2],[0.3,0.4, 0.5]])\r\n arr3 = np.array(1)\r\n npt.assert_equal(1, utils.multi_intersect([arr1, arr2, arr3]))","def intersecting_entries(self, other):\n self_keys = set(self._entries.keys())\n other_keys = set(other._entries.keys())\n common_keys = self_keys.intersection(other_keys)\n return ([(self._entries[key], other._entries[key])\n for key in common_keys])","def intersect(self, rays):\n raise NotImplementedError","def intersect(*d):\n sets = iter(map(set, d))\n result = sets.next()\n for s in sets:\n result = result.intersection(s)\n return result","def intersection(self, other: Catalog) -> Catalog:\n cat1 = self.copy()\n cat2 = other.copy()\n\n new_cat = Catalog()\n for k in cat1.keys():\n for ver_id, version in cat1[k].versions.items():\n if k in cat2 and ver_id in cat2[k].versions:\n assert cat1[k][ver_id] == cat2[k][ver_id]\n new_cat[k][ver_id] = version\n return new_cat","def test_intersection(self):\n instance = QuerySetModel.objects.create(\n other=self.other\n )\n queryset = QuerySetModel.objects.filter(id=instance.id)\n self.assertEqual(\n queryset.intersection(\n QuerySetModel.objects.all()\n ).count(),\n 1\n )\n\n queryset = QuerySetModel.all_objects.all()\n self.assertEqual(\n queryset.intersection(\n QuerySetModel.objects.all()\n ).count(),\n 1\n )\n self.assertEqual(\n queryset.intersection(\n QuerySetModel.all_objects.all()\n ).count(),\n 2\n )","def list_intersection(listA, listB):\n # create empty intersection\n intersection = []\n\n # for each item a of listA\n for a in listA:\n # is any b of listB the same as a? \n for b in listB:\n if a == b:\n # found a, add it to intersection\n intersection.append(a)\n\n # all loops done, return intersection\n return intersection","def Intersect(self, *args):\n return _BRepAlgo.BRepAlgo_DSAccess_Intersect(self, *args)","def intersection(lst1, lst2):\n lst3 = [value for value in lst1 if value in lst2]\n return lst3","def dict_sets_intersection_test(self, data):\n\n data_info = self.get_data_info(data)\n finished = []\n\n for part in data:\n for union_part in data:\n if part != union_part and union_part not in finished:\n data[part].intersection(data[union_part])\n finished.append(part)\n\n return data_info","def intersects(a, b, **kwargs):\n return lib.intersects(a, b, **kwargs)","def intersection(eqn0, eqn1):\n x = (eqn1[1] - eqn0[1]) / (eqn0[0] - eqn1[0])\n return (x, apply_eqn(eqn0, x))","def intersections(boxes0, boxes1):\n intersections = []\n for box0 in boxes0:\n current_intersections = [intersection(box0, box1) for box1 in boxes1]\n intersections.extend([i for i in current_intersections if i is not None])\n return intersections","def get_intersect(a1, a2, b1, b2):\n s = np.vstack((a1, a2, b1, b2)) # s for stacked\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\n l1 = np.cross(h[0], h[1]) # get first line\n l2 = np.cross(h[2], h[3]) # get second line\n x, y, z = np.cross(l1, l2) # point of intersection\n if z == 0: # lines are parallel\n return None\n return np.array([x / z, y / z])","def _op_and_(self, left: Any, right: Any) -> Any:\n if isinstance(left, list):\n # induce an intersect with Collection\n return Intersect(left, right)\n\n left, right = _recycle_left_right(left, right)\n left = Series(left).fillna(False)\n right = Series(right).fillna(False)\n return left & right","def union(s1, s2):\n \"*** YOUR CODE HERE ***\"\n s = set()\n for member in s1:\n s.add(member)\n for member in s2:\n s.add(member)\n return s","def get_alphanumeric_intersection(set1, set2):\n set1_clean = [x.upper() for x in set1]\n set2_clean = [x.upper() for x in set2]\n set1_clean = set([re.sub('[\\W_]', '', x) for x in set1_clean])\n set2_clean = set([re.sub('[\\W_]', '', x) for x in set2_clean])\n return set.intersection(set1_clean, set2_clean)","def common(input1, input2):\r\n return set(input1)&set(input2) # write a single line of code\r"],"string":"[\n \"def set_intersection(set_a, set_b):\\n \\n intersection = set_b & set_a\\n \\n return intersection\",\n \"def intersection(self, *other):\\n new_ordered_set = OrderedSet()\\n\\n for element in self:\\n for obj in other:\\n if element not in obj:\\n break\\n else:\\n new_ordered_set.add(element)\\n\\n return new_ordered_set\",\n \"def intersection(set_1, set_2):\\n intersection_list = []\\n\\n for number in set_1:\\n if number in set_2:\\n intersection_list.append(number)\\n \\n print(\\\"Intersection:\\\", intersection_list)\\n return set_1, set_2\",\n \"def intersection(self, s2):\\n s1 = self\\n if s1.is_full:\\n return s2\\n if s2.is_full:\\n return s1\\n return IdSet(s1._set.intersection(s2._set))\",\n \"def intersection(a, b):\\n return list(set(a) & set(b))\",\n \"def intersection(A, B, *C):\\n return setutils(\\\"intersection\\\", A, B, *C)\",\n \"def intersection(self, other):\\n intersection_set = Set()\\n\\n for bucket in self.buckets:\\n for element in bucket.iterate():\\n if other.contains(element):\\n intersection_set.add(element)\\n return intersection_set\",\n \"def intersect(a, b):\\r\\n return list(set(a) & set(b))\",\n \"def intersect_set(list1, list2):\\n return (set(list1) & set(list2))\",\n \"def intersect(a,b):\\n\\treturn list(set(a) & set(b))\",\n \"def intersect(a, b):\\n return(list(set(a) & set(b)))\",\n \"def intersect(self, left=[], right=[]):\\n return list(set(left).intersection(right))\",\n \"def intersect(self, other):\\n result = IntSet()\\n map(result.insert, [e for e in self.vals if e in other.vals])\\n return result\",\n \"def intersect(a, b):\\n return list(set(a) & set(b))\",\n \"def intersect(self, other):\\n # Initialize a new intSet \\n commonValueSet = intSet()\\n # Go through the values in this set\\n for val in self.vals:\\n # Check if each value is a member of the other set \\n if other.member(val):\\n commonValueSet.insert(val)\\n return commonValueSet\",\n \"def intersection(stack):\\n assertArity(stack, 2)\\n rhs, lhs = stack.pop(), stack.pop()\\n assertType(lhs, Set)\\n assertType(rhs, Set)\\n return Set(lhs & rhs)\",\n \"def intersection(sets):\\n return functools.reduce(set.intersection, [s for s in sets])\",\n \"def __intersect(a, b):\\n a = [elem.lower() for elem in a]\\n b = [elem.lower() for elem in b]\\n return list(set(a) & set(b))\",\n \"def intersection(self, *lists):\\n if self.is_a(set):\\n return _(self._.intersection(*lists))\\n return _(_intersection(self._, *lists))\",\n \"def intersection(sets):\\n return reduce(set.intersection, [s for s in sets])\",\n \"def intersect(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def __intersect(self, a, b):\\n a = [elem.lower() for elem in a]\\n b = [elem.lower() for elem in b]\\n return list(set(a) & set(b))\",\n \"def __and__(self, other):\\n return intersect(self, other)\",\n \"def intersection_signature(*sets):\\n return reduce(operator.and_, sets)\",\n \"def intersection(p1: Iterator[Posting], p2: Iterator[Posting]) -> Iterator[Posting]:\\n raise NotImplementedError(\\\"You need to implement this as part of the assignment.\\\")\",\n \"def intersection(s1, s2):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return s1.intersection(s2) # ...\",\n \"def union(set1, set2):\",\n \"def find_intersection(set_1, set_2):\\n\\n # PyTorch auto-broadcasts singleton dimensions\\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)\",\n \"def find_intersection(set_1, set_2):\\n\\n # PyTorch auto-broadcasts singleton dimensions\\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)\",\n \"def find_intersection(set_1, set_2):\\n\\n # PyTorch auto-broadcasts singleton dimensions\\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)\",\n \"def find_intersection(set_1, set_2):\\n\\n # PyTorch auto-broadcasts singleton dimensions\\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)\",\n \"def intersect(t1,t2):\\n result=()\\n for e in t1:\\n if e in t2:\\n result += (e,)\\n return result\",\n \"def intersection(self, other):\\n new_ieqs = []\\n new_ieqs.extend(self.inequalities())\\n new_ieqs.extend(other.inequalities())\\n\\n new_eqns = []\\n new_eqns.extend(self.equations())\\n new_eqns.extend(other.equations())\\n\\n return Polyhedron(ieqs = new_ieqs, eqns = new_eqns, \\n field=self.coerce_field(other))\",\n \"def intersect(self, other_list):\\n assert type(other_list) == type(self)\\n \\n# if len(self.vals) >= len(other_list.vals):\\n# big = self.vals\\n# small = other_list.vals\\n# else:\\n# small = self.vals\\n# big = other_list.vals\\n# \\n# common_list = intSet()\\n# for e in big:\\n# if e in small:\\n# common_list.insert(e)\\n# return common_list\\n\\n common_list = intSet() \\n for e in self.vals:\\n if other_list.member(e): #if the current e is a member of other_list\\n common_list.insert(e)\\n return common_list\",\n \"def find_intersection(set_1, set_2):\\n # PyTorch auto-broadcasts singleton dimensions\\n lower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)\\n upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)\\n intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)\\n return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)\",\n \"def intersect(self, other):\\n return Intersection(self, other)\",\n \"def intersect(a, b): \\n # print(len(list(set(a) & set(b))), 'unique and matching names between FPL and Understat')\\n return list(set(a) & set(b))\",\n \"def intersection(self, other):\\n return self._geomgen(capi.geom_intersection, other)\",\n \"def intersection(cls, forms):\\n result = forms[0]\\n for form in forms[1:]:\\n result = cls.intersectionTwoForms(result, form)\\n return result\",\n \"def intersection(self, *others):\\r\\n return self.r.sinter(self.r_key, *[o.r_key for o in others])\",\n \"def intersection(self, other): # -> BaseGeometry:\\n ...\",\n \"def _exclusive_intersect(self, keys):\\n #inc_s = reduce(lambda x, y: x.intersection(y), \\n # (self[x] for x in keys))\\n inc_s = self[keys[0]].copy()\\n for other_key in self:\\n if other_key in keys:\\n inc_s.intersection_update(self[other_key])\\n else:\\n inc_s.difference_update(self[other_key])\\n\\n return inc_s\",\n \"def find_intersection(nums1, nums2)->list:\\n set1 = set(nums1)\\n set2 = set(nums2)\\n intersection = set()\\n\\n for i in set1:\\n if i in set2: # The item is in both lists\\n intersection.add(i)\\n return list(intersection)\",\n \"def intersect(iterable, other):\\n return 0\",\n \"def find_intersection(self, other):\\n newcls = self.__class__(None)\\n mlist = newcls._find_members(self.members + other.members)\\n poly = self.intersection(other)\\n newcls.set_members(mlist, poly)\\n return newcls\",\n \"def intersection(self):\\n return Intersection(self.source, self)\",\n \"def intersection(llist_1 : LinkedList, llist_2 : LinkedList) -> LinkedList:\\n # Convert to set to remove repeated entries in each list\\n lset_1 = list_to_set(llist_1)\\n lset_2 = list_to_set(llist_2)\\n\\n # Initialize empty intersec_list\\n intersec_list = LinkedList()\\n \\n # Populate list_of_candidates with all elements from lset_1\\n list_of_candidates = []\\n for item in lset_1:\\n list_of_candidates.append(item)\\n\\n # Only add to intersec_list the items from lset_2 available in list_of_candidates\\n for item in lset_2:\\n if item in list_of_candidates:\\n intersec_list.append(item)\\n\\n return intersec_list\",\n \"def __and__(self, other):\\n return self.intersection(other)\",\n \"def intersection(self, other):\\n return _binary_geo(arctern.ST_Intersection, self, other)\",\n \"def simplify_intersection(args):\\n\\n # ===== Global Rules =====\\n if not args:\\n return S.UniversalSet\\n\\n for arg in args:\\n if not isinstance(arg, Set):\\n raise TypeError(\\\"Input args to Union must be Sets\\\")\\n\\n # If any EmptySets return EmptySet\\n if S.EmptySet in args:\\n return S.EmptySet\\n\\n # Handle Finite sets\\n rv = Intersection._handle_finite_sets(args)\\n\\n if rv is not None:\\n return rv\\n\\n # If any of the sets are unions, return a Union of Intersections\\n for s in args:\\n if s.is_Union:\\n other_sets = set(args) - {s}\\n if len(other_sets) > 0:\\n other = Intersection(*other_sets)\\n return Union(*(Intersection(arg, other) for arg in s.args))\\n else:\\n return Union(*s.args)\\n\\n for s in args:\\n if s.is_Complement:\\n args.remove(s)\\n other_sets = args + [s.args[0]]\\n return Complement(Intersection(*other_sets), s.args[1])\\n\\n from sympy.sets.handlers.intersection import intersection_sets\\n\\n # At this stage we are guaranteed not to have any\\n # EmptySets, FiniteSets, or Unions in the intersection\\n\\n # ===== Pair-wise Rules =====\\n # Here we depend on rules built into the constituent sets\\n args = set(args)\\n new_args = True\\n while new_args:\\n for s in args:\\n new_args = False\\n for t in args - {s}:\\n new_set = intersection_sets(s, t)\\n # This returns None if s does not know how to intersect\\n # with t. Returns the newly intersected set otherwise\\n\\n if new_set is not None:\\n new_args = (args - {s, t}).union({new_set})\\n break\\n if new_args:\\n args = new_args\\n break\\n\\n if len(args) == 1:\\n return args.pop()\\n else:\\n return Intersection(*args, evaluate=False)\",\n \"def intersection(self, axis2):\",\n \"def intersect(t1, t2):\\n\\n result = ()\\n for e in t1:\\n if e in t2:\\n result += (e,) # signifies tuple\\n\\n return (result)\",\n \"def union(self, other):\\n # initialize new Set from the elements in the first Set\\n union_set = Set(self.get_elements())\\n\\n # add every element in the second Set to a new Set and return it\\n for element in other.get_elements():\\n union_set.add(element)\\n return union_set\",\n \"def intersection(self):\\n self._intersection = list(set(self.origin.columns[:]).intersection(self.destination.columns[:]))\\n self._intersection.sort()\\n return self._intersection\",\n \"def __listintersect(self, c1, c2):\\n s2 = {}\\n for delta in c2:\\n s2[delta] = 1\\n\\n\\tc = []\\n\\tfor delta in c1:\\n if s2.has_key(delta):\\n\\t\\tc.append(delta)\\n\\n\\treturn c\",\n \"def intersection(\\n cls, *availabilitysets: List[\\\"Availability\\\"]\\n ) -> List[\\\"Availability\\\"]:\\n\\n # get rid of any overlaps and unmerged ranges in each set\\n availabilitysets = [cls.union(avialset) for avialset in availabilitysets]\\n # bail out for obvious cases (there are no sets given, one of the sets is empty)\\n if not availabilitysets:\\n return []\\n if not all(availabilitysets):\\n return []\\n # start with the very first set ...\\n result = availabilitysets[0]\\n for availset in availabilitysets[1:]:\\n # ... subtract each of the other sets\\n result = cls._pair_intersection(result, availset)\\n return result\",\n \"def intersection(x, y, f, p):\",\n \"def intersect(nums1: List[int], nums2: List[int]) -> List[int]:\\n if not nums1 or not nums2:\\n return False\\n if len(nums1) == 1 and len(nums2) == 1:\\n if nums1[0] == nums2[0]:\\n return nums1\\n\\n intersection = list()\\n\\n for x in nums1:\\n if x in nums2:\\n nums2.remove(x)\\n intersection.append(x)\\n return intersection\",\n \"def intersection(self, *others):\\n other_contexts = [o.get_contexts() for o in others]\\n return ContextSet(self._contexts.intersection(*other_contexts))\",\n \"def intersect_sets(S):\\n res = S[0]\\n for s in S:\\n res &= s\\n return res\",\n \"def intersection(lst1, lst2):\\n temp = set(lst2)\\n lst3 = [value for value in lst1 if value in temp]\\n return lst3\",\n \"def get_jurisdiction_common_members(a: List[int], b: List[int]) -> Set[int]:\\n a_set = set(a)\\n b_set = set(b)\\n\\n if a_set & b_set:\\n return a_set & b_set\\n else:\\n return set()\",\n \"def intersection(self, other):\\n if other.size() != self.size():\\n raise ValueError(\\\"Intersections are only possible on interval-posets of the same size.\\\")\\n try:\\n return TamariIntervalPoset(self.size(), self._cover_relations + other._cover_relations)\\n except ValueError:\\n raise ValueError(\\\"This intersection is empty, it does not correspond to an interval-poset.\\\")\",\n \"def intersection(self, *others):\\n other_sents = [o.get_sentences() for o in others]\\n return SentenceSet(self._sentences.intersection(*other_sents))\",\n \"def __mul__(self, other):\\n if not isinstance(other, (Set, list)):\\n raise TypeError(f\\\"could not intersect set and {type(other)}\\\")\\n\\n return Set(x for x in other if x in self)\",\n \"def intersection(A, B):\\n\\n if max(0, min(A[1], B[1]) - max(A[0], B[0])):\\n # intersection is not empty!\\n if A[0] < B[0]:\\n return [B[0], A[1]]\\n else:\\n return [A[0], B[1]]\\n else:\\n print 'Warning: intersection is an empty set!'\\n return [np.nan, np.nan]\",\n \"def intersect_set(n):\\n set_a = set(range(n))\\n set_b = set(range(n-3, 2 * n))\\n start = timeit.default_timer()\\n in_both = set_a.intersection(set_b)\\n run_time = timeit.default_timer() - start\\n return run_time, in_both\",\n \"def _any_intersect(line_set_1, line_set_2, h_set_1=None, h_set_2=None):\\n # try to speed this one up by reducing the number of comparisons\\n # necessary. About half the time is spent in here, incl. subroutines.\\n h_set_1 = [_homogenous_line(*segment) for segment in line_set_1] if h_set_1 is None else h_set_1\\n h_set_2 = [_homogenous_line(*segment) for segment in line_set_2] if h_set_2 is None else h_set_2\\n for h1, l1 in zip(h_set_1, line_set_1):\\n for h2, l2 in zip(h_set_2, line_set_2):\\n P = _intersection_homogenous(h1, h2)\\n if P==(None, None): continue\\n if _point_within_bounds(l1,P) and _point_within_bounds(l2,P):\\n return True\\n return False\",\n \"def action_intersection(s1, s2):\\n isect = s1 & s2\\n L1 = [ ( (a.oid, a.index_oid), a) for a in s1 ]\\n L2 = [ ( (a.oid, a.index_oid), a) for a in s2 ]\\n ds1 = dict(L1)\\n ds2 = dict(L2)\\n for k1, action1 in ds1.items():\\n action2 = ds2.get(k1)\\n if action2 is not None:\\n # replace action in union with correct one or conflict\\n isect.add(which_action(action1, action2))\\n return isect\",\n \"def intersect(a, b):\\r\\n #print(a, b)\\r\\n #first case, we have , in gs a and gs b\\r\\n try:\\r\\n b_a = a.split(',')\\r\\n b_b = b.split(',')\\r\\n return list(set(b_a) & set(b_b))\\r\\n except:\\r\\n pass\",\n \"def synonymIntersection(self, wSet1, wSet2, idf):\\n intersection = wSet1.intersection(wSet2)\\n w1 = wSet1 - intersection\\n w2 = wSet2 - intersection\\n if len(intersection) == 0:\\n return set([])\\n\\n synonyms1 = self.getSynonyms(w1)\\n synonyms2 = self.getSynonyms(w2)\\n defaultIDF = idf['unknownToken']\\n \\n while len(w1) > 0:\\n word1 = w1.pop()\\n if word1 not in synonyms1:\\n continue # no synonyms for this word\\n \\n for word2 in w2:\\n if word2 not in synonyms2:\\n continue # no synonyms for this word\\n sharedSynsets = synonyms1[word1].intersection(synonyms2[word2])\\n if len(sharedSynsets) > 0:\\n # the two have at least one synset in common, consider them synonyms\\n w2.remove(word2)\\n if idf.get(word1, defaultIDF) > idf.get(word2, defaultIDF):\\n intersection.add(word1)\\n else:\\n intersection.add(word2)\\n break\\n \\n return intersection\",\n \"def listops_intersect(list_a,list_b):\\r\\n\\r\\n retlist = []\\r\\n for item in list_a:\\r\\n if item in list_b:\\r\\n retlist.append(item)\\r\\n\\r\\n # ensure that a duplicated item in list_a is only listed once\\r\\n return listops_uniq(retlist)\",\n \"def insercionListas(L1,L2):\\n return set(L1) & set(L2)\",\n \"def intersection(*entities):\\n from entity import GeometryEntity\\n\\n entities = GeometryEntity.extract_entities(entities, False)\\n if len(entities) <= 1:\\n return []\\n\\n res = GeometryEntity.do_intersection(entities[0], entities[1])\\n for entity in entities[2:]:\\n newres = []\\n for x in res:\\n newres.extend(GeometryEntity.do_intersection(x, entity))\\n res = newres\\n return res\",\n \"def find_intersection(wire_one_map, wire_two_map):\\n return set(wire_one_map.keys()) & set(wire_two_map.keys())\",\n \"def _intersect(\\n series_1: TimeSeries,\\n series_2: TimeSeries,\\n) -> Tuple[TimeSeries, TimeSeries]:\\n\\n new_series_1 = series_1.slice_intersect(series_2)\\n raise_if(\\n len(new_series_1) == 0,\\n \\\"Time intersection between the two series must be non empty.\\\",\\n )\\n\\n return new_series_1, series_2.slice_intersect(series_1)\",\n \"def intersection(self, other, bypassInclusionTest=False):\\n # poly1 = copy.deepcopy(self)\\n # poly2 = copy.deepcopy(other)\\n poly1 = self\\n poly2 = other\\n noneF = []\\n assert self.pnFacesInPoly()\\n polyInter = polyIntersection.fromPolyhedron(poly1, poly2)\\n assert all(all(v in polyInter.poly1.vertices for v in f.vertices) for f in polyInter.poly1.faces)\\n assert all(all(v in polyInter.poly2.vertices for v in f.vertices) for f in polyInter.poly2.faces)\\n # This handles the case of one polyhedron inside the other\\n if not bypassInclusionTest:\\n if len(polyInter.inter1) + len(polyInter.inter2) == 0:\\n if all(f.isOnInteriorSide(poly1.vertices[0]) for f in poly2.faces):\\n return poly1\\n elif all(f.isOnInteriorSide(poly2.vertices[0]) for f in poly1.faces):\\n return poly2\\n else:\\n return polyhedron([], [], [])\\n assert self.pnFacesInPoly() and self.pnFacesInPoly()\\n # print('step 1')\\n assert polyInter.nonDoubleIntersectors()\\n polyInter.createIntersectorVertices()\\n # print('step 2')\\n polyInter.buildEdges()\\n # print('step 3')\\n polyInter.buildFaces()\\n return polyInter.result\",\n \"def findIntersection(lOne, lTwo):\\n\\tsOne = set(lOne)\\n\\tsTwo = set(lTwo)\\n\\tsInt = sOne.intersection(sTwo)\\n\\treturn list(sInt)\",\n \"def common_elements(s1, s2):\\n\\n return set(s1 & s2)\",\n \"def intersect(self, other, abs_tol=ABS_TOL):\\n if isinstance(other, Polytope):\\n other = [other]\\n P = Region()\\n for poly0 in self:\\n for poly1 in other:\\n isect = poly0.intersect(poly1, abs_tol)\\n rp, xp = isect.cheby\\n if rp > abs_tol:\\n P = union(P, isect, check_convex=True)\\n return P\",\n \"def intersection(list1, list2):\\r\\n\\r\\n list3 = []\\r\\n\\r\\n if not list1 and not list2: # Both lists passed as arguments are empty\\r\\n return list3\\r\\n\\r\\n elif not list1 and list2: # The first list passed as argument is empty\\r\\n return list2\\r\\n\\r\\n elif list1 and not list2: # The second list passed as argument is empty\\r\\n return list1\\r\\n\\r\\n else:\\r\\n list3 = [value for value in list1 if value in list2] # Getting only the common values of the two lists\\r\\n return list3\",\n \"def intersection(list1, list2):\\n list3 = [value for value in list1 if value in list2]\\n return list3\",\n \"def test_multi_intersect():\\r\\n\\r\\n arr1 = np.array(np.arange(1000).reshape(2,500))\\r\\n arr2 = np.array([[1,0.1,0.2],[0.3,0.4, 0.5]])\\r\\n arr3 = np.array(1)\\r\\n npt.assert_equal(1, utils.multi_intersect([arr1, arr2, arr3]))\",\n \"def intersecting_entries(self, other):\\n self_keys = set(self._entries.keys())\\n other_keys = set(other._entries.keys())\\n common_keys = self_keys.intersection(other_keys)\\n return ([(self._entries[key], other._entries[key])\\n for key in common_keys])\",\n \"def intersect(self, rays):\\n raise NotImplementedError\",\n \"def intersect(*d):\\n sets = iter(map(set, d))\\n result = sets.next()\\n for s in sets:\\n result = result.intersection(s)\\n return result\",\n \"def intersection(self, other: Catalog) -> Catalog:\\n cat1 = self.copy()\\n cat2 = other.copy()\\n\\n new_cat = Catalog()\\n for k in cat1.keys():\\n for ver_id, version in cat1[k].versions.items():\\n if k in cat2 and ver_id in cat2[k].versions:\\n assert cat1[k][ver_id] == cat2[k][ver_id]\\n new_cat[k][ver_id] = version\\n return new_cat\",\n \"def test_intersection(self):\\n instance = QuerySetModel.objects.create(\\n other=self.other\\n )\\n queryset = QuerySetModel.objects.filter(id=instance.id)\\n self.assertEqual(\\n queryset.intersection(\\n QuerySetModel.objects.all()\\n ).count(),\\n 1\\n )\\n\\n queryset = QuerySetModel.all_objects.all()\\n self.assertEqual(\\n queryset.intersection(\\n QuerySetModel.objects.all()\\n ).count(),\\n 1\\n )\\n self.assertEqual(\\n queryset.intersection(\\n QuerySetModel.all_objects.all()\\n ).count(),\\n 2\\n )\",\n \"def list_intersection(listA, listB):\\n # create empty intersection\\n intersection = []\\n\\n # for each item a of listA\\n for a in listA:\\n # is any b of listB the same as a? \\n for b in listB:\\n if a == b:\\n # found a, add it to intersection\\n intersection.append(a)\\n\\n # all loops done, return intersection\\n return intersection\",\n \"def Intersect(self, *args):\\n return _BRepAlgo.BRepAlgo_DSAccess_Intersect(self, *args)\",\n \"def intersection(lst1, lst2):\\n lst3 = [value for value in lst1 if value in lst2]\\n return lst3\",\n \"def dict_sets_intersection_test(self, data):\\n\\n data_info = self.get_data_info(data)\\n finished = []\\n\\n for part in data:\\n for union_part in data:\\n if part != union_part and union_part not in finished:\\n data[part].intersection(data[union_part])\\n finished.append(part)\\n\\n return data_info\",\n \"def intersects(a, b, **kwargs):\\n return lib.intersects(a, b, **kwargs)\",\n \"def intersection(eqn0, eqn1):\\n x = (eqn1[1] - eqn0[1]) / (eqn0[0] - eqn1[0])\\n return (x, apply_eqn(eqn0, x))\",\n \"def intersections(boxes0, boxes1):\\n intersections = []\\n for box0 in boxes0:\\n current_intersections = [intersection(box0, box1) for box1 in boxes1]\\n intersections.extend([i for i in current_intersections if i is not None])\\n return intersections\",\n \"def get_intersect(a1, a2, b1, b2):\\n s = np.vstack((a1, a2, b1, b2)) # s for stacked\\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\\n l1 = np.cross(h[0], h[1]) # get first line\\n l2 = np.cross(h[2], h[3]) # get second line\\n x, y, z = np.cross(l1, l2) # point of intersection\\n if z == 0: # lines are parallel\\n return None\\n return np.array([x / z, y / z])\",\n \"def _op_and_(self, left: Any, right: Any) -> Any:\\n if isinstance(left, list):\\n # induce an intersect with Collection\\n return Intersect(left, right)\\n\\n left, right = _recycle_left_right(left, right)\\n left = Series(left).fillna(False)\\n right = Series(right).fillna(False)\\n return left & right\",\n \"def union(s1, s2):\\n \\\"*** YOUR CODE HERE ***\\\"\\n s = set()\\n for member in s1:\\n s.add(member)\\n for member in s2:\\n s.add(member)\\n return s\",\n \"def get_alphanumeric_intersection(set1, set2):\\n set1_clean = [x.upper() for x in set1]\\n set2_clean = [x.upper() for x in set2]\\n set1_clean = set([re.sub('[\\\\W_]', '', x) for x in set1_clean])\\n set2_clean = set([re.sub('[\\\\W_]', '', x) for x in set2_clean])\\n return set.intersection(set1_clean, set2_clean)\",\n \"def common(input1, input2):\\r\\n return set(input1)&set(input2) # write a single line of code\\r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8064488","0.759755","0.7544426","0.75385064","0.7532488","0.751954","0.7467276","0.7437161","0.7419048","0.74105626","0.7405655","0.7400201","0.7389499","0.7355031","0.7274344","0.7242505","0.7151147","0.7141193","0.7128307","0.71257377","0.7113491","0.71041936","0.7088164","0.7013681","0.6987809","0.694727","0.6945866","0.69368434","0.69368434","0.69368434","0.69368434","0.6933435","0.69215626","0.6909188","0.68708676","0.68686885","0.68324506","0.6791402","0.67577666","0.67179465","0.6682178","0.6681277","0.66580385","0.66487604","0.6636332","0.66032445","0.65776277","0.6566415","0.65555966","0.65157","0.64945555","0.64921105","0.64758646","0.64465976","0.64265686","0.64190036","0.64114684","0.6405865","0.6391862","0.6386623","0.63755345","0.6375054","0.63726014","0.63698727","0.6359363","0.63394517","0.6336188","0.6326504","0.6323971","0.6320157","0.6306389","0.629043","0.6287495","0.6280682","0.6263745","0.62507993","0.6250275","0.61945206","0.61909324","0.61902577","0.61860573","0.61845195","0.6182917","0.61662424","0.6164642","0.61595994","0.6143371","0.6142561","0.6123997","0.6114139","0.6083433","0.60833526","0.60819757","0.6071932","0.6070641","0.60616416","0.6048927","0.60362667","0.6035482","0.6033191"],"string":"[\n \"0.8064488\",\n \"0.759755\",\n \"0.7544426\",\n \"0.75385064\",\n \"0.7532488\",\n \"0.751954\",\n \"0.7467276\",\n \"0.7437161\",\n \"0.7419048\",\n \"0.74105626\",\n \"0.7405655\",\n \"0.7400201\",\n \"0.7389499\",\n \"0.7355031\",\n \"0.7274344\",\n \"0.7242505\",\n \"0.7151147\",\n \"0.7141193\",\n \"0.7128307\",\n \"0.71257377\",\n \"0.7113491\",\n \"0.71041936\",\n \"0.7088164\",\n \"0.7013681\",\n \"0.6987809\",\n \"0.694727\",\n \"0.6945866\",\n \"0.69368434\",\n \"0.69368434\",\n \"0.69368434\",\n \"0.69368434\",\n \"0.6933435\",\n \"0.69215626\",\n \"0.6909188\",\n \"0.68708676\",\n \"0.68686885\",\n \"0.68324506\",\n \"0.6791402\",\n \"0.67577666\",\n \"0.67179465\",\n \"0.6682178\",\n \"0.6681277\",\n \"0.66580385\",\n \"0.66487604\",\n \"0.6636332\",\n \"0.66032445\",\n \"0.65776277\",\n \"0.6566415\",\n \"0.65555966\",\n \"0.65157\",\n \"0.64945555\",\n \"0.64921105\",\n \"0.64758646\",\n \"0.64465976\",\n \"0.64265686\",\n \"0.64190036\",\n \"0.64114684\",\n \"0.6405865\",\n \"0.6391862\",\n \"0.6386623\",\n \"0.63755345\",\n \"0.6375054\",\n \"0.63726014\",\n \"0.63698727\",\n \"0.6359363\",\n \"0.63394517\",\n \"0.6336188\",\n \"0.6326504\",\n \"0.6323971\",\n \"0.6320157\",\n \"0.6306389\",\n \"0.629043\",\n \"0.6287495\",\n \"0.6280682\",\n \"0.6263745\",\n \"0.62507993\",\n \"0.6250275\",\n \"0.61945206\",\n \"0.61909324\",\n \"0.61902577\",\n \"0.61860573\",\n \"0.61845195\",\n \"0.6182917\",\n \"0.61662424\",\n \"0.6164642\",\n \"0.61595994\",\n \"0.6143371\",\n \"0.6142561\",\n \"0.6123997\",\n \"0.6114139\",\n \"0.6083433\",\n \"0.60833526\",\n \"0.60819757\",\n \"0.6071932\",\n \"0.6070641\",\n \"0.60616416\",\n \"0.6048927\",\n \"0.60362667\",\n \"0.6035482\",\n \"0.6033191\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71919143"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":93487,"cells":{"query":{"kind":"string","value":"Creates the union for both sets"},"document":{"kind":"string","value":"def union(A,B):\n set_A = A\n set_B = B\n sorted_union = []\n for elements in set_A:\n if elements not in sorted_union:\n sorted_union.append(elements)\n for elements in set_B:\n if elements not in sorted_union:\n sorted_union.append(elements)\n return sorted_union"},"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 union(set1, set2):","def union(self, other):\n # initialize new Set from the elements in the first Set\n union_set = Set(self.get_elements())\n\n # add every element in the second Set to a new Set and return it\n for element in other.get_elements():\n union_set.add(element)\n return union_set","def union(a, b):\r\n return list(set(a) | set(b))","def union(a, b):\n return list(set(a) | set(b))","def union(a, b):\n return list(set(a) | set(b))","def union(s1, s2):\n \"*** YOUR CODE HERE ***\"\n s = set()\n for member in s1:\n s.add(member)\n for member in s2:\n s.add(member)\n return s","def _control_union(self, entities_1: List[str], entities_2: List[str]):\n return list(set(entities_1).union(set(entities_2)))","def _union(cls, s1, s2):\n return s1.union(s2)","def union(A, B, *C):\n return setutils(\"union\", A, B, *C)","def union(self, *other):\n \n new_ordered_set = OrderedSet()\n\n for element in self:\n new_ordered_set.add(element)\n\n for obj in other:\n for element in obj:\n new_ordered_set.add(element)\n\n return new_ordered_set","def union(set_1, set_2):\n union_list = []\n\n for number in set_2: # Adds numbers to set_1, since this is the last step\n set_1.append(number)\n \n set_1.sort()\n\n for number in set_1:\n if number not in union_list:\n union_list.append(number)\n \n print(\"Union:\", union_list)\n return set_1, set_2","def union(self, *lists):\n if self.is_a(set):\n return _(self._.union(*lists))\n return _(_union(self._, *lists))","def union(stack):\n assertArity(stack, 2)\n rhs, lhs = stack.pop(), stack.pop()\n assertType(lhs, Set)\n assertType(rhs, Set)\n return Set(lhs | rhs)","def _eval_rewrite_as_Union(self, *sets, **kwargs):\n\n dj_union = S.EmptySet\n index = 0\n for set_i in sets:\n if isinstance(set_i, Set):\n cross = ProductSet(set_i, FiniteSet(index))\n dj_union = Union(dj_union, cross)\n index = index + 1\n return dj_union","def union(self, other):\n\n return self.intersect(other, op=np.union1d)","def union(first, second):\n # Put your code here.","def union(self, iterable):\n pass","def union(self, other):\n self.find_set()._link(other.find_set())","def union(self, other):\n return PermClass([S_1 + S_2 for S_1, S_2 in zip(self, other)])","def union(p1: Iterator[Posting], p2: Iterator[Posting]) -> Iterator[Posting]:\n raise NotImplementedError(\"You need to implement this as part of the assignment.\")","def __listunion(self, c1, c2):\n s1 = {}\n for delta in c1:\n s1[delta] = 1\n\n\tc = c1[:]\n\tfor delta in c2:\n if not s1.has_key(delta):\n\t\tc.append(delta)\n\n\treturn c","def make_union(self, *args, **kwargs): # real signature unknown\n pass","def union(self, *others):\r\n return self.r.sunion(self.r_key, *[o.r_key for o in others])","def __or__(self, other):\n\n union = list(self)\n union.extend([value for value in other if value not in union])\n\n return union","def union(list_a: list, list_b: list) -> list:\n if list_a is None:\n list_a = [None]\n if list_b is None:\n list_b = [None]\n return list(set(list_a) | set(list_b))","def listops_union(list_a,list_b):\r\n\r\n retlist = list_a[:]\r\n for item in list_b: \r\n if item not in list_a:\r\n retlist.append(item)\r\n\r\n # ensure that a duplicated item in list_a is only listed once\r\n return listops_uniq(retlist)","def union_signature(*args):\n *sets, n = args\n if len(sets) == 2:\n return set(sorted(sets[0] | sets[1])[:n])\n else:\n return set(sorted(reduce(operator.or_, list(sets)))[:n])","def union(self, *args):\n return self.phy2abs.union(*args)","def union(self, other, check_convex=False):\n return union(self, other, check_convex)","def union(self, other, check_convex=False):\n return union(self, other, check_convex)","def union(self, otherpvalueset):\n for candidate in otherpvalueset.pvalues.itervalues():\n self.add(candidate)","def union(llist_1 : LinkedList, llist_2 : LinkedList) -> LinkedList:\n # Convert to set to remove repeated entries in each list\n lset_1 = list_to_set(llist_1)\n lset_2 = list_to_set(llist_2)\n \n # Combine the two sets to create a union\n union_list = LinkedList()\n list_of_added = []\n for item in lset_1:\n union_list.append(item)\n list_of_added.append(item)\n\n for item in lset_2:\n if item not in list_of_added:\n union_list.append(item)\n\n return union_list","def union(self, p, q):\n pass","def union(self, a, b):\n if (a in self.node_id) and (b in self.node_id) and (self.node_id[a] != self.node_id[b]):\n self.merge(a, b)\n elif (a in self.node_id) or (b in self.node_id):\n self.add(a,b)\n else:\n self.create_new_group(a,b)","def union(llist_1, llist_2):\n union_set = set()\n return_linked_list = LinkedList()\n node = llist_1.get_head()\n while node:\n union_set.add(node.get_value())\n node = node.get_next()\n node = llist_2.get_head()\n while node:\n union_set.add(node.get_value())\n node = node.get_next()\n for item in union_set:\n return_linked_list.append(item)\n if return_linked_list.size() == 0:\n return 'No unions found'\n return return_linked_list","def union_sets(S):\n res = set()\n for s in S:\n res |= s\n return res","def union(cls, args):\n try:\n return cls(\n [\n (k, cls.union([i[1] for i in g]))\n for k, g in groupby(\n sorted(\n chain.from_iterable(arg.items() for arg in args),\n key=lambda a: a[0],\n ),\n key=lambda a: a[0],\n )\n ]\n )\n except AttributeError:\n return set(chain.from_iterable(args))","def variant_key_set_union(k, v_left, v_right, ordering=None):\n out_v = set(v_left) | set(v_right)\n return sorted(out_v, key=partial(_version_order, ordering=ordering))","def union(self, other):\n return self._geomgen(capi.geom_union, other)","def union(self, other):\n return Union(self, other)","def from_sets(cls, set1, set2, universe_size=None):\n if not isinstance(set1, Set):\n set1 = set(set1)\n if not isinstance(set2, Set):\n set2 = set(set2)\n TP = len(set1 & set2)\n FP = len(set2) - TP\n FN = len(set1) - TP\n if universe_size is None:\n TN = 0\n else:\n TN = universe_size - TP - FP - FN\n if TN < 0:\n raise ValueError(\n \"universe_size must be at least as large as set union\")\n return cls(TP, FN, FP, TN)","def union(self, other):\n self.vertices.extend(other.vertices)\n self.edges.extend(other.edges)\n self.faces.extend(other.faces)\n return self","def union(p,q):\n\tfor e in q:\n\t\tif e not in p:\n\t\t\tp.append(e)","def union(self, querysets):\n # union() is \"New in Django 1.11.\" (docs site)\n # but buggy in 2.0, with a backport in 1.11.8 ; my ticket 29229, fixed in 1.11.12 & 2.0.4.\n # For simplicity, let's even ignore the usable 1.11.0-7 frame.\n # Ticket 29286 reintroduced a bug in 1.11.13 & 2.0.5, by considering only the annotate() case and not the extra().\n # Ticket 29694 fixed the missing extra() case, but is only effective as of 2.1.1,\n # because extra() is destined to be deprecated.\n # So the final solution here was to replace all extra() by annotate() in this app.\n if VERSION < (1, 11, 12) or (2, 0) <= VERSION < (2, 0, 4):\n result_sql, result_params = [], []\n for qs in querysets:\n sql, params = qs.query.sql_with_params()\n result_sql.append(sql)\n result_params.extend(params)\n return ' UNION '.join(result_sql), tuple(result_params)\n else:\n qs = querysets[0].union(*querysets[1:])\n return qs.query.sql_with_params()","def __or__(self, other):\n return self.union(other)","def __or__(self, other):\n return self.union(other)","def union(list1, list2):\n new_list = list1\n for literal in list2:\n negate_literal = copy.deepcopy(literal)\n negate_literal.negate = not negate_literal.negate\n if negate_literal in list1:\n new_list.remove(negate_literal)\n continue\n if literal not in list1:\n new_list.append(literal)\n return new_list","def union(self, other):\n if isinstance(other, list):\n self.substrates = unary_union([self.substrates] + other)\n elif isinstance(other, Substrate):\n self.substrates = unary_union([self.substrates, other.substrates])\n else:\n self.substrates = unary_union([self.substrates, other])\n self.oriented = False","def union(self, rng_set: Union[Rangelike, Iterable[Rangelike]]) -> 'RangeSet':\n # convert to RangeSet\n rng_set = RangeSet._to_rangeset(rng_set)\n # simply merge lists\n return RangeSet(self._ranges + rng_set._ranges)","def union(p, q):\n for i in q:\n if i not in p:\n p.append(i)","def union(self):\n nfa2 = self.aut_stack.pop()\n nfa1 = self.aut_stack.pop()\n\n nfa1_star = nfa1.transform('X')\n nfa2_star = nfa2.transform('Y')\n\n nfa_union = Automaton()\n nfa_union.states = list(set(nfa1_star.states).union(nfa2_star.states))\n nfa_union.states.append('S')\n nfa_union.alphabet = list(set(nfa1_star.alphabet).union(nfa2_star.alphabet))\n nfa_union.final = list(set(nfa1_star.final).union(nfa2_star.final))\n nfa_union.change_start_state('S')\n nfa_union.transition = dict(nfa1_star.transition, **nfa2_star.transition)\n nfa_union.transition['S, .'] = [nfa1_star.q_0, nfa2_star.q_0]\n\n self.aut_stack.append(nfa_union)","def union(self, other): # -> BaseGeometry:\n ...","def union(self, table2):\n\n # check if arity of both the tables are same\n if len(self.columnNames) != len(table2.columnNames):\n print 'Arity of the tables are not same. Cant perform union.'\n return\n\n results = set([])\n for rec in self.records:\n rec_tuple = tuple([v for (k, v) in rec.items()])\n results.add(rec_tuple)\n for rec in table2.records:\n rec_tuple = tuple([v for (k, v) in rec.items()])\n if rec_tuple not in results:\n results.add(rec_tuple)\n for item in results:\n print item","def find_union(lcs_tables: Sequence[Sequence[int]]) ->Sequence[int]:\n return sorted(list(set().union(*lcs_tables)))","def disjoint_union(self, other):\n result = self.empty_copy()\n for s in self.iter_states():\n result.add_state(s.relabeled((0, s)))\n for s in other.iter_states():\n result.add_state(s.relabeled((1, s)))\n for t in self.iter_transitions():\n result.add_transition((0, t.from_state),\n (0, t.to_state),\n t.word_in,\n t.word_out)\n for t in other.iter_transitions():\n result.add_transition((1, t.from_state),\n (1, t.to_state),\n t.word_in,\n t.word_out)\n try:\n result.input_alphabet = list(set(self.input_alphabet)\n | set(other.input_alphabet))\n except TypeError:\n # e.g. None or unhashable letters\n result.input_alphabet = None\n\n return result","def unions(iterable):\n return reduce(union, iterable)","def union(tuple1, tuple2):\n if tuple1 is None:\n return tuple2\n if tuple2 is None:\n return tuple1\n l = list(tuple1)\n l.extend([e for e in tuple2 if e not in tuple1])\n return tuple(l)","def union(a, b):\n if a == b:\n return a\n elif not a:\n return b\n elif not b:\n return a\n a = Const.unwrap(a)\n b = Const.unwrap(b)\n # TODO(robertwb): Work this into the Union code in a more generic way.\n if type(a) == type(b) and element_type(a) == typehints.Union[()]:\n return b\n elif type(a) == type(b) and element_type(b) == typehints.Union[()]:\n return a\n return typehints.Union[a, b]","def test_union(self):\n queryset = QuerySetModel.objects.all()\n self.assertEqual(\n queryset.union(queryset).count(),\n 0\n )\n\n queryset = QuerySetModel.all_objects.all()\n self.assertEqual(\n queryset.union(queryset, all=False).count(),\n 1\n )\n self.assertEqual(\n queryset.union(queryset, all=True).count(),\n 2\n )","def union(self, other):\n from sage.misc.misc import deprecation\n deprecation('The function union is replaced by convex_hull.', 'Sage Version 4.4.4')\n return self.convex_hull(other)","def union_all(self, query):\n return self.union(query, True)","def _array_union(cls, queries):\n clean_queries = [q for q in queries if q is not None]\n if len(clean_queries) == 0:\n return db.session.query(Relationship.source_id).filter(sql.false())\n\n query = clean_queries.pop()\n for q in clean_queries:\n query = query.union(q)\n return query","def union(self, other, inplace=True):\n if self.target != other.target:\n raise ValueError('target mismatch (%s != %s)' % (\n self.target, other.target))\n\n union = self if inplace else copy.deepcopy(self)\n\n sections = [name for name in self.sections if name != 'target']\n for name in sections:\n mine = getattr(union, name)\n yours = getattr(other, name)\n setattr(union, name, mine | yours)\n\n return union","def union(cls, forms):\n \"\"\"This function must be recursive.\"\"\"\n if len(forms) == 2:\n return cls.unionTwoForms(forms[0], forms[1])\n else:\n pass\n\n result = forms[0]\n for form in forms[1:]:\n result.extend(cls.union(form, result))\n return result","def union_all(x: DataFrame, y: DataFrame) -> DataFrame:\n _check_xy(x, y)\n return bind_rows(x, y, __calling_env=CallingEnvs.REGULAR)","def union_of_non_none_sets(sets):\r\n return functools.reduce(lambda x, y: x.union(y), filter(lambda z: z is not\\\r\n None, sets), set())","def map_union(*args):\n union = {}\n for d in args:\n union.update(d)\n return union","def union(seq, *seqs):\n yield from unionby(None, seq, *seqs)","def sequence_union(s1, s2):\n # make sure that s1 is the longer sequence and s2 is merged into it\n if sequence_length(s1) < sequence_length(s2):\n sp = s2\n s2 = s1\n s1 = sp\n s = []\n c1, dt1 = s1.pop(0)\n c2, dt2 = s2.pop(0)\n while True:\n if dt1 < dt2:\n s.append( (list( set(c1) | set(c2) ), dt1) )\n dt2 -= dt1\n try:\n c1, dt1 = s1.pop(0)\n except:\n break\n elif dt2 < dt1:\n s.append( (list( set(c1) | set(c2) ), dt2) )\n dt1 -= dt2\n try:\n c2, dt2 = s2.pop(0)\n except:\n c2 = []\n dt2 = np.inf\n else:\n s.append( (list( set(c1) | set(c2) ), dt1) )\n try:\n c1, dt1 = s1.pop(0)\n except:\n break\n try:\n c2, dt2 = s2.pop(0)\n except:\n c2 = []\n dt2 = np.inf \n return s","def test_union_with_different_models(self):\n queryset = QuerySetModel.objects.values_list(\"pk\")\n other_queryset = OtherModel.objects.values_list(\"pk\")\n self.assertEqual(\n queryset.union(other_queryset).count(),\n 1\n )\n self.assertEqual(\n other_queryset.union(queryset).count(),\n 1\n )\n queryset = QuerySetModel.all_objects.values_list(\"pk\")\n self.assertEqual(\n queryset.union(other_queryset, all=True).count(),\n 2\n )\n self.assertEqual(\n other_queryset.union(queryset, all=True).count(),\n 2\n )","def union(self, *others):\n other_sents = [o.get_sentences() for o in others]\n return SentenceSet(self._sentences.union(*other_sents))","def _union(\n lows: np.array, ups: np.array, new_lows: np.array, new_ups: np.array\n) -> Union[np.array, np.array]:\n out_lows = []\n out_ups = []\n\n for i in range(0, lows.shape[1]):\n low, up = _union_one_dim( # pylint:disable=invalid-name\n lows[:, i], ups[:, i], new_lows[:, i], new_ups[:, i]\n )\n out_lows.append(low.reshape(-1, 1))\n out_ups.append(up.reshape(-1, 1))\n\n out_lows_array, out_ups_array = np.hstack(out_lows), np.hstack(out_ups)\n\n return out_lows_array, out_ups_array","def unary_union(self):\n return GeoSeries(arctern.ST_Union_Aggr(self))","def union(*graphs):\n from sets import Set\n out = {}\n for G in graphs:\n for v in G:\n out.setdefault(v,Set()).update(list(G[v]))\n return out","def union(self, node1, node2):\n\n root1 = self.root(node1)\n root2 = self.root(node2)\n\n if root1 == root2:\n return\n\n if node1 < node2:\n self.set[root2] = root1\n self.root(node2)\n else:\n self.set[root1] = root2\n self.root(node1)","def __add__(self, other):\n return union(self, other, check_convex=True)","def union(cls, *sels):\n\n out = cls('')\n tmp = set()\n for s in sels:\n if s.nonempty:\n tmp = tmp.union(s.expanded)\n if tmp:\n out._expanded = tuple(sorted(tmp))\n else:\n out._expanded = ((),)\n try:\n out._max_levels = max([s.max_levels for s in sels if s.nonempty])\n except ValueError:\n out._max_levels = 0\n return out","def union(self, StdVectorFst other):\n cdef StdVectorFst result = self.copy()\n result.set_union(other)\n return result","def union(self,x,y):\n assert x in self and y in self\n rx,ry = self.find(x),self.find(y)\n if rx!=ry:\n nx,ny = self.__rank[rx],self.__rank[ry]\n if nx<=ny:\n self.__parent[rx] = ry\n self.__size[ry] += self.__size[rx]\n if nx==ny: self.__rank[ry]+=1\n else:\n self.__parent[ry] = rx\n self.__size[rx] += self.__size[ry]","def union(one, other):\n left = min(one.left, other.left)\n right = max(one.right, other.right)\n top = min(one.top, other.top)\n bottom = max(one.bottom, other.bottom)\n return BBox([[left, top], [right, bottom]])","def union_add(this, that):\n return this.add(that, fill_value=0)","def union(arguments, flatten=True):\n return Component(\n \"Union\",\n arguments=arguments,\n options={\n 'flatten': flatten\n },\n constraints=None)","def compute_union(lattice1: NDArrayInt, lattice2: NDArrayInt, row_wise: bool = True):\n l1 = to_row_wise(lattice1, row_wise)\n l2 = to_row_wise(lattice2, row_wise)\n\n H, _ = row_style_hermite_normal_form(np.concatenate([l1, l2], axis=0))\n rank = get_triangular_rank(H)\n\n union = H[:rank, :]\n\n if not row_wise:\n union = union.T\n\n return union","def union(self, other: list) -> 'List':\n if not isinstance(other, list):\n raise ValueError('The comparing element is not a list')\n\n return List(self + other).unique()","def union(self, other: \"CFG\") -> \"CFG\":\n start_temp = Variable(\"#STARTUNION#\")\n temp_0 = Terminal(\"#0UNION#\")\n temp_1 = Terminal(\"#1UNION#\")\n production_0 = Production(start_temp, [temp_0])\n production_1 = Production(start_temp, [temp_1])\n cfg_temp = CFG({start_temp},\n {temp_0, temp_1},\n start_temp,\n {production_0, production_1})\n return cfg_temp.substitute({temp_0: self,\n temp_1: other})","def join_union(self, other):\n\n assert type(self) is type(other), 'Expected NestedRE instance'\n\n A = self.make_flat()\n B = other.make_flat()\n\n if A == B and A !='ϵ':\n return self.merge_union(A, [self.closure, other.closure])\n elif A == 'ϵ' and B == 'ϵ':\n return NestedRE('ϵ')\n elif A == 'ϵ':\n return NestedRE(B, '?')\n elif B == 'ϵ':\n return NestedRE(A, '?')\n else:\n return NestedRE( '(' + A + '|' + B + ')' )","def headsofunion(h1, h2):\n res = unfi.set(b'heads((%ln + %ln - null))', h1, h2)\n return {ctx.node() for ctx in res}","def symmetric_difference(self, rng_set: Union[Rangelike, Iterable[Rangelike]]) -> 'RangeSet':\n # convert to a RangeSet\n rng_set = RangeSet._to_rangeset(rng_set)\n # get union and then remove intersections\n union = self.union(rng_set)\n intersection = self.intersection(rng_set)\n union.difference_update(intersection)\n return union","def copy(self):\n products_by_target = defaultdict(OrderedSet)\n for key, value in self._products_by_target.items():\n products_by_target[key] = OrderedSet(value)\n return UnionProducts(products_by_target=products_by_target)","def union(self, other):\n p = AddPermission(*self.needs.union(other.needs))\n p.excludes.update(self.excludes.union(other.excludes))\n return p","def mergeWith(self, others):","def merge_working_sets(self, other):\n\n for dist in other.by_key.values(): self.add(dist)\n return self","def stemset_combiner(stempool1, stempool2):\n return stempool1.stemset | stempool2.stemset","def union(self, s2, exps=None):\n res = self.copy()\n tr = {}\n for expr, var in s2.items():\n if expr in self:\n if exps:\n exps = exps.xreplace({var: res[expr]})\n tr[var] = res[expr]\n else:\n res[expr] = var\n for var, rewr in s2.rewrites.items():\n res.rewrites[var] = rewr.xreplace(tr)\n return res, exps","def get_union(self, other):\n\n union_events_list = AtypicalEventsList()\n union_events_list.set_atypical_events = self.set_atypical_events | other.set_atypical_events\n\n return union_events_list","def graph_union(*args, **kwargs):\n\n if not len(args) > 1:\n raise AttributeError('At least two input Graphs required')\n\n # Validate if all arguments are Graphs\n check_graphbase_instance(*args)\n\n all_share_common_origin = all([share_common_origin(args[0], n) for n in args[1:]])\n if all_share_common_origin and not kwargs.get('return_copy', False):\n\n nids = []\n for graph in args:\n nids.extend([n for n in graph.nodes if n not in nids])\n\n eids = []\n for graph in args:\n eids.extend([e for e in graph.edges if e not in eids])\n\n result = args[0].origin.getnodes(nids)\n result.edges.set_view(eids)\n return result\n else:\n\n # make a deep copy of the first graph\n result = args[0].copy(deep=True, copy_view=False)\n\n # we need control over the node ID to add\n # temporary turn off auto_nid if needed\n auto_nid = result.data.auto_nid\n result.data.auto_nid = False\n\n for graph in args[1:]:\n for node, attrib in graph.nodes.items():\n if node not in result.nodes:\n result.add_node(node, **attrib)\n\n for edge, attrib in graph.edges.items():\n if edge not in result.edges:\n result.add_edge(*edge, **attrib)\n\n # Restore auto_nid\n result.data.auto_nid = auto_nid\n\n return result","def unIfInt(a, b):\n if len(intersect(a, b)) != 0:\n return (list(set(a).union(b)))","def join(self, a, b):\n r = defaultdict(lambda: 0)\n c = itertools.chain(a.get_elements().items(),\n b.get_elements().items())\n for element, n in c:\n r[element] = Nat_add(r[element], n)\n\n r = dict(**r)\n return Multiset(r, self.S)","def union(self, *args):\n _ub = None\n for _obj in args:\n if _ub is None:\n _ub = self.bbox(_obj)\n else:\n _b = self.bbox(_obj)\n _x = np.sort(np.array([_b[:, 0], _ub[:, 0]]), axis=None)\n _y = np.sort(np.array([_b[:, 1], _ub[:, 1]]), axis=None)\n _ub = np.array([[_x[0], _y[0]], [_x[3], _y[3]]])\n return _ub","def union(G, H):\n\n if G.order() != H.order():\n msg = \"Node sets of the two directed graphs are not equal!\"\n raise StaticGraphNotEqNodesException(msg)\n\n n_nodes = G.order()\n edges = ((u, v) for u in G.nodes()\n\t\t for v in chain(G.successors(u), H.successors(u)))\n deg = make_deg(n_nodes, edges) \n edges = ((u, v) for u in G.nodes()\n\t\t for v in chain(G.successors(u), H.successors(u)))\n GC = make(n_nodes, G.size() + H.size(), edges, deg)\n return GC"],"string":"[\n \"def union(set1, set2):\",\n \"def union(self, other):\\n # initialize new Set from the elements in the first Set\\n union_set = Set(self.get_elements())\\n\\n # add every element in the second Set to a new Set and return it\\n for element in other.get_elements():\\n union_set.add(element)\\n return union_set\",\n \"def union(a, b):\\r\\n return list(set(a) | set(b))\",\n \"def union(a, b):\\n return list(set(a) | set(b))\",\n \"def union(a, b):\\n return list(set(a) | set(b))\",\n \"def union(s1, s2):\\n \\\"*** YOUR CODE HERE ***\\\"\\n s = set()\\n for member in s1:\\n s.add(member)\\n for member in s2:\\n s.add(member)\\n return s\",\n \"def _control_union(self, entities_1: List[str], entities_2: List[str]):\\n return list(set(entities_1).union(set(entities_2)))\",\n \"def _union(cls, s1, s2):\\n return s1.union(s2)\",\n \"def union(A, B, *C):\\n return setutils(\\\"union\\\", A, B, *C)\",\n \"def union(self, *other):\\n \\n new_ordered_set = OrderedSet()\\n\\n for element in self:\\n new_ordered_set.add(element)\\n\\n for obj in other:\\n for element in obj:\\n new_ordered_set.add(element)\\n\\n return new_ordered_set\",\n \"def union(set_1, set_2):\\n union_list = []\\n\\n for number in set_2: # Adds numbers to set_1, since this is the last step\\n set_1.append(number)\\n \\n set_1.sort()\\n\\n for number in set_1:\\n if number not in union_list:\\n union_list.append(number)\\n \\n print(\\\"Union:\\\", union_list)\\n return set_1, set_2\",\n \"def union(self, *lists):\\n if self.is_a(set):\\n return _(self._.union(*lists))\\n return _(_union(self._, *lists))\",\n \"def union(stack):\\n assertArity(stack, 2)\\n rhs, lhs = stack.pop(), stack.pop()\\n assertType(lhs, Set)\\n assertType(rhs, Set)\\n return Set(lhs | rhs)\",\n \"def _eval_rewrite_as_Union(self, *sets, **kwargs):\\n\\n dj_union = S.EmptySet\\n index = 0\\n for set_i in sets:\\n if isinstance(set_i, Set):\\n cross = ProductSet(set_i, FiniteSet(index))\\n dj_union = Union(dj_union, cross)\\n index = index + 1\\n return dj_union\",\n \"def union(self, other):\\n\\n return self.intersect(other, op=np.union1d)\",\n \"def union(first, second):\\n # Put your code here.\",\n \"def union(self, iterable):\\n pass\",\n \"def union(self, other):\\n self.find_set()._link(other.find_set())\",\n \"def union(self, other):\\n return PermClass([S_1 + S_2 for S_1, S_2 in zip(self, other)])\",\n \"def union(p1: Iterator[Posting], p2: Iterator[Posting]) -> Iterator[Posting]:\\n raise NotImplementedError(\\\"You need to implement this as part of the assignment.\\\")\",\n \"def __listunion(self, c1, c2):\\n s1 = {}\\n for delta in c1:\\n s1[delta] = 1\\n\\n\\tc = c1[:]\\n\\tfor delta in c2:\\n if not s1.has_key(delta):\\n\\t\\tc.append(delta)\\n\\n\\treturn c\",\n \"def make_union(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def union(self, *others):\\r\\n return self.r.sunion(self.r_key, *[o.r_key for o in others])\",\n \"def __or__(self, other):\\n\\n union = list(self)\\n union.extend([value for value in other if value not in union])\\n\\n return union\",\n \"def union(list_a: list, list_b: list) -> list:\\n if list_a is None:\\n list_a = [None]\\n if list_b is None:\\n list_b = [None]\\n return list(set(list_a) | set(list_b))\",\n \"def listops_union(list_a,list_b):\\r\\n\\r\\n retlist = list_a[:]\\r\\n for item in list_b: \\r\\n if item not in list_a:\\r\\n retlist.append(item)\\r\\n\\r\\n # ensure that a duplicated item in list_a is only listed once\\r\\n return listops_uniq(retlist)\",\n \"def union_signature(*args):\\n *sets, n = args\\n if len(sets) == 2:\\n return set(sorted(sets[0] | sets[1])[:n])\\n else:\\n return set(sorted(reduce(operator.or_, list(sets)))[:n])\",\n \"def union(self, *args):\\n return self.phy2abs.union(*args)\",\n \"def union(self, other, check_convex=False):\\n return union(self, other, check_convex)\",\n \"def union(self, other, check_convex=False):\\n return union(self, other, check_convex)\",\n \"def union(self, otherpvalueset):\\n for candidate in otherpvalueset.pvalues.itervalues():\\n self.add(candidate)\",\n \"def union(llist_1 : LinkedList, llist_2 : LinkedList) -> LinkedList:\\n # Convert to set to remove repeated entries in each list\\n lset_1 = list_to_set(llist_1)\\n lset_2 = list_to_set(llist_2)\\n \\n # Combine the two sets to create a union\\n union_list = LinkedList()\\n list_of_added = []\\n for item in lset_1:\\n union_list.append(item)\\n list_of_added.append(item)\\n\\n for item in lset_2:\\n if item not in list_of_added:\\n union_list.append(item)\\n\\n return union_list\",\n \"def union(self, p, q):\\n pass\",\n \"def union(self, a, b):\\n if (a in self.node_id) and (b in self.node_id) and (self.node_id[a] != self.node_id[b]):\\n self.merge(a, b)\\n elif (a in self.node_id) or (b in self.node_id):\\n self.add(a,b)\\n else:\\n self.create_new_group(a,b)\",\n \"def union(llist_1, llist_2):\\n union_set = set()\\n return_linked_list = LinkedList()\\n node = llist_1.get_head()\\n while node:\\n union_set.add(node.get_value())\\n node = node.get_next()\\n node = llist_2.get_head()\\n while node:\\n union_set.add(node.get_value())\\n node = node.get_next()\\n for item in union_set:\\n return_linked_list.append(item)\\n if return_linked_list.size() == 0:\\n return 'No unions found'\\n return return_linked_list\",\n \"def union_sets(S):\\n res = set()\\n for s in S:\\n res |= s\\n return res\",\n \"def union(cls, args):\\n try:\\n return cls(\\n [\\n (k, cls.union([i[1] for i in g]))\\n for k, g in groupby(\\n sorted(\\n chain.from_iterable(arg.items() for arg in args),\\n key=lambda a: a[0],\\n ),\\n key=lambda a: a[0],\\n )\\n ]\\n )\\n except AttributeError:\\n return set(chain.from_iterable(args))\",\n \"def variant_key_set_union(k, v_left, v_right, ordering=None):\\n out_v = set(v_left) | set(v_right)\\n return sorted(out_v, key=partial(_version_order, ordering=ordering))\",\n \"def union(self, other):\\n return self._geomgen(capi.geom_union, other)\",\n \"def union(self, other):\\n return Union(self, other)\",\n \"def from_sets(cls, set1, set2, universe_size=None):\\n if not isinstance(set1, Set):\\n set1 = set(set1)\\n if not isinstance(set2, Set):\\n set2 = set(set2)\\n TP = len(set1 & set2)\\n FP = len(set2) - TP\\n FN = len(set1) - TP\\n if universe_size is None:\\n TN = 0\\n else:\\n TN = universe_size - TP - FP - FN\\n if TN < 0:\\n raise ValueError(\\n \\\"universe_size must be at least as large as set union\\\")\\n return cls(TP, FN, FP, TN)\",\n \"def union(self, other):\\n self.vertices.extend(other.vertices)\\n self.edges.extend(other.edges)\\n self.faces.extend(other.faces)\\n return self\",\n \"def union(p,q):\\n\\tfor e in q:\\n\\t\\tif e not in p:\\n\\t\\t\\tp.append(e)\",\n \"def union(self, querysets):\\n # union() is \\\"New in Django 1.11.\\\" (docs site)\\n # but buggy in 2.0, with a backport in 1.11.8 ; my ticket 29229, fixed in 1.11.12 & 2.0.4.\\n # For simplicity, let's even ignore the usable 1.11.0-7 frame.\\n # Ticket 29286 reintroduced a bug in 1.11.13 & 2.0.5, by considering only the annotate() case and not the extra().\\n # Ticket 29694 fixed the missing extra() case, but is only effective as of 2.1.1,\\n # because extra() is destined to be deprecated.\\n # So the final solution here was to replace all extra() by annotate() in this app.\\n if VERSION < (1, 11, 12) or (2, 0) <= VERSION < (2, 0, 4):\\n result_sql, result_params = [], []\\n for qs in querysets:\\n sql, params = qs.query.sql_with_params()\\n result_sql.append(sql)\\n result_params.extend(params)\\n return ' UNION '.join(result_sql), tuple(result_params)\\n else:\\n qs = querysets[0].union(*querysets[1:])\\n return qs.query.sql_with_params()\",\n \"def __or__(self, other):\\n return self.union(other)\",\n \"def __or__(self, other):\\n return self.union(other)\",\n \"def union(list1, list2):\\n new_list = list1\\n for literal in list2:\\n negate_literal = copy.deepcopy(literal)\\n negate_literal.negate = not negate_literal.negate\\n if negate_literal in list1:\\n new_list.remove(negate_literal)\\n continue\\n if literal not in list1:\\n new_list.append(literal)\\n return new_list\",\n \"def union(self, other):\\n if isinstance(other, list):\\n self.substrates = unary_union([self.substrates] + other)\\n elif isinstance(other, Substrate):\\n self.substrates = unary_union([self.substrates, other.substrates])\\n else:\\n self.substrates = unary_union([self.substrates, other])\\n self.oriented = False\",\n \"def union(self, rng_set: Union[Rangelike, Iterable[Rangelike]]) -> 'RangeSet':\\n # convert to RangeSet\\n rng_set = RangeSet._to_rangeset(rng_set)\\n # simply merge lists\\n return RangeSet(self._ranges + rng_set._ranges)\",\n \"def union(p, q):\\n for i in q:\\n if i not in p:\\n p.append(i)\",\n \"def union(self):\\n nfa2 = self.aut_stack.pop()\\n nfa1 = self.aut_stack.pop()\\n\\n nfa1_star = nfa1.transform('X')\\n nfa2_star = nfa2.transform('Y')\\n\\n nfa_union = Automaton()\\n nfa_union.states = list(set(nfa1_star.states).union(nfa2_star.states))\\n nfa_union.states.append('S')\\n nfa_union.alphabet = list(set(nfa1_star.alphabet).union(nfa2_star.alphabet))\\n nfa_union.final = list(set(nfa1_star.final).union(nfa2_star.final))\\n nfa_union.change_start_state('S')\\n nfa_union.transition = dict(nfa1_star.transition, **nfa2_star.transition)\\n nfa_union.transition['S, .'] = [nfa1_star.q_0, nfa2_star.q_0]\\n\\n self.aut_stack.append(nfa_union)\",\n \"def union(self, other): # -> BaseGeometry:\\n ...\",\n \"def union(self, table2):\\n\\n # check if arity of both the tables are same\\n if len(self.columnNames) != len(table2.columnNames):\\n print 'Arity of the tables are not same. Cant perform union.'\\n return\\n\\n results = set([])\\n for rec in self.records:\\n rec_tuple = tuple([v for (k, v) in rec.items()])\\n results.add(rec_tuple)\\n for rec in table2.records:\\n rec_tuple = tuple([v for (k, v) in rec.items()])\\n if rec_tuple not in results:\\n results.add(rec_tuple)\\n for item in results:\\n print item\",\n \"def find_union(lcs_tables: Sequence[Sequence[int]]) ->Sequence[int]:\\n return sorted(list(set().union(*lcs_tables)))\",\n \"def disjoint_union(self, other):\\n result = self.empty_copy()\\n for s in self.iter_states():\\n result.add_state(s.relabeled((0, s)))\\n for s in other.iter_states():\\n result.add_state(s.relabeled((1, s)))\\n for t in self.iter_transitions():\\n result.add_transition((0, t.from_state),\\n (0, t.to_state),\\n t.word_in,\\n t.word_out)\\n for t in other.iter_transitions():\\n result.add_transition((1, t.from_state),\\n (1, t.to_state),\\n t.word_in,\\n t.word_out)\\n try:\\n result.input_alphabet = list(set(self.input_alphabet)\\n | set(other.input_alphabet))\\n except TypeError:\\n # e.g. None or unhashable letters\\n result.input_alphabet = None\\n\\n return result\",\n \"def unions(iterable):\\n return reduce(union, iterable)\",\n \"def union(tuple1, tuple2):\\n if tuple1 is None:\\n return tuple2\\n if tuple2 is None:\\n return tuple1\\n l = list(tuple1)\\n l.extend([e for e in tuple2 if e not in tuple1])\\n return tuple(l)\",\n \"def union(a, b):\\n if a == b:\\n return a\\n elif not a:\\n return b\\n elif not b:\\n return a\\n a = Const.unwrap(a)\\n b = Const.unwrap(b)\\n # TODO(robertwb): Work this into the Union code in a more generic way.\\n if type(a) == type(b) and element_type(a) == typehints.Union[()]:\\n return b\\n elif type(a) == type(b) and element_type(b) == typehints.Union[()]:\\n return a\\n return typehints.Union[a, b]\",\n \"def test_union(self):\\n queryset = QuerySetModel.objects.all()\\n self.assertEqual(\\n queryset.union(queryset).count(),\\n 0\\n )\\n\\n queryset = QuerySetModel.all_objects.all()\\n self.assertEqual(\\n queryset.union(queryset, all=False).count(),\\n 1\\n )\\n self.assertEqual(\\n queryset.union(queryset, all=True).count(),\\n 2\\n )\",\n \"def union(self, other):\\n from sage.misc.misc import deprecation\\n deprecation('The function union is replaced by convex_hull.', 'Sage Version 4.4.4')\\n return self.convex_hull(other)\",\n \"def union_all(self, query):\\n return self.union(query, True)\",\n \"def _array_union(cls, queries):\\n clean_queries = [q for q in queries if q is not None]\\n if len(clean_queries) == 0:\\n return db.session.query(Relationship.source_id).filter(sql.false())\\n\\n query = clean_queries.pop()\\n for q in clean_queries:\\n query = query.union(q)\\n return query\",\n \"def union(self, other, inplace=True):\\n if self.target != other.target:\\n raise ValueError('target mismatch (%s != %s)' % (\\n self.target, other.target))\\n\\n union = self if inplace else copy.deepcopy(self)\\n\\n sections = [name for name in self.sections if name != 'target']\\n for name in sections:\\n mine = getattr(union, name)\\n yours = getattr(other, name)\\n setattr(union, name, mine | yours)\\n\\n return union\",\n \"def union(cls, forms):\\n \\\"\\\"\\\"This function must be recursive.\\\"\\\"\\\"\\n if len(forms) == 2:\\n return cls.unionTwoForms(forms[0], forms[1])\\n else:\\n pass\\n\\n result = forms[0]\\n for form in forms[1:]:\\n result.extend(cls.union(form, result))\\n return result\",\n \"def union_all(x: DataFrame, y: DataFrame) -> DataFrame:\\n _check_xy(x, y)\\n return bind_rows(x, y, __calling_env=CallingEnvs.REGULAR)\",\n \"def union_of_non_none_sets(sets):\\r\\n return functools.reduce(lambda x, y: x.union(y), filter(lambda z: z is not\\\\\\r\\n None, sets), set())\",\n \"def map_union(*args):\\n union = {}\\n for d in args:\\n union.update(d)\\n return union\",\n \"def union(seq, *seqs):\\n yield from unionby(None, seq, *seqs)\",\n \"def sequence_union(s1, s2):\\n # make sure that s1 is the longer sequence and s2 is merged into it\\n if sequence_length(s1) < sequence_length(s2):\\n sp = s2\\n s2 = s1\\n s1 = sp\\n s = []\\n c1, dt1 = s1.pop(0)\\n c2, dt2 = s2.pop(0)\\n while True:\\n if dt1 < dt2:\\n s.append( (list( set(c1) | set(c2) ), dt1) )\\n dt2 -= dt1\\n try:\\n c1, dt1 = s1.pop(0)\\n except:\\n break\\n elif dt2 < dt1:\\n s.append( (list( set(c1) | set(c2) ), dt2) )\\n dt1 -= dt2\\n try:\\n c2, dt2 = s2.pop(0)\\n except:\\n c2 = []\\n dt2 = np.inf\\n else:\\n s.append( (list( set(c1) | set(c2) ), dt1) )\\n try:\\n c1, dt1 = s1.pop(0)\\n except:\\n break\\n try:\\n c2, dt2 = s2.pop(0)\\n except:\\n c2 = []\\n dt2 = np.inf \\n return s\",\n \"def test_union_with_different_models(self):\\n queryset = QuerySetModel.objects.values_list(\\\"pk\\\")\\n other_queryset = OtherModel.objects.values_list(\\\"pk\\\")\\n self.assertEqual(\\n queryset.union(other_queryset).count(),\\n 1\\n )\\n self.assertEqual(\\n other_queryset.union(queryset).count(),\\n 1\\n )\\n queryset = QuerySetModel.all_objects.values_list(\\\"pk\\\")\\n self.assertEqual(\\n queryset.union(other_queryset, all=True).count(),\\n 2\\n )\\n self.assertEqual(\\n other_queryset.union(queryset, all=True).count(),\\n 2\\n )\",\n \"def union(self, *others):\\n other_sents = [o.get_sentences() for o in others]\\n return SentenceSet(self._sentences.union(*other_sents))\",\n \"def _union(\\n lows: np.array, ups: np.array, new_lows: np.array, new_ups: np.array\\n) -> Union[np.array, np.array]:\\n out_lows = []\\n out_ups = []\\n\\n for i in range(0, lows.shape[1]):\\n low, up = _union_one_dim( # pylint:disable=invalid-name\\n lows[:, i], ups[:, i], new_lows[:, i], new_ups[:, i]\\n )\\n out_lows.append(low.reshape(-1, 1))\\n out_ups.append(up.reshape(-1, 1))\\n\\n out_lows_array, out_ups_array = np.hstack(out_lows), np.hstack(out_ups)\\n\\n return out_lows_array, out_ups_array\",\n \"def unary_union(self):\\n return GeoSeries(arctern.ST_Union_Aggr(self))\",\n \"def union(*graphs):\\n from sets import Set\\n out = {}\\n for G in graphs:\\n for v in G:\\n out.setdefault(v,Set()).update(list(G[v]))\\n return out\",\n \"def union(self, node1, node2):\\n\\n root1 = self.root(node1)\\n root2 = self.root(node2)\\n\\n if root1 == root2:\\n return\\n\\n if node1 < node2:\\n self.set[root2] = root1\\n self.root(node2)\\n else:\\n self.set[root1] = root2\\n self.root(node1)\",\n \"def __add__(self, other):\\n return union(self, other, check_convex=True)\",\n \"def union(cls, *sels):\\n\\n out = cls('')\\n tmp = set()\\n for s in sels:\\n if s.nonempty:\\n tmp = tmp.union(s.expanded)\\n if tmp:\\n out._expanded = tuple(sorted(tmp))\\n else:\\n out._expanded = ((),)\\n try:\\n out._max_levels = max([s.max_levels for s in sels if s.nonempty])\\n except ValueError:\\n out._max_levels = 0\\n return out\",\n \"def union(self, StdVectorFst other):\\n cdef StdVectorFst result = self.copy()\\n result.set_union(other)\\n return result\",\n \"def union(self,x,y):\\n assert x in self and y in self\\n rx,ry = self.find(x),self.find(y)\\n if rx!=ry:\\n nx,ny = self.__rank[rx],self.__rank[ry]\\n if nx<=ny:\\n self.__parent[rx] = ry\\n self.__size[ry] += self.__size[rx]\\n if nx==ny: self.__rank[ry]+=1\\n else:\\n self.__parent[ry] = rx\\n self.__size[rx] += self.__size[ry]\",\n \"def union(one, other):\\n left = min(one.left, other.left)\\n right = max(one.right, other.right)\\n top = min(one.top, other.top)\\n bottom = max(one.bottom, other.bottom)\\n return BBox([[left, top], [right, bottom]])\",\n \"def union_add(this, that):\\n return this.add(that, fill_value=0)\",\n \"def union(arguments, flatten=True):\\n return Component(\\n \\\"Union\\\",\\n arguments=arguments,\\n options={\\n 'flatten': flatten\\n },\\n constraints=None)\",\n \"def compute_union(lattice1: NDArrayInt, lattice2: NDArrayInt, row_wise: bool = True):\\n l1 = to_row_wise(lattice1, row_wise)\\n l2 = to_row_wise(lattice2, row_wise)\\n\\n H, _ = row_style_hermite_normal_form(np.concatenate([l1, l2], axis=0))\\n rank = get_triangular_rank(H)\\n\\n union = H[:rank, :]\\n\\n if not row_wise:\\n union = union.T\\n\\n return union\",\n \"def union(self, other: list) -> 'List':\\n if not isinstance(other, list):\\n raise ValueError('The comparing element is not a list')\\n\\n return List(self + other).unique()\",\n \"def union(self, other: \\\"CFG\\\") -> \\\"CFG\\\":\\n start_temp = Variable(\\\"#STARTUNION#\\\")\\n temp_0 = Terminal(\\\"#0UNION#\\\")\\n temp_1 = Terminal(\\\"#1UNION#\\\")\\n production_0 = Production(start_temp, [temp_0])\\n production_1 = Production(start_temp, [temp_1])\\n cfg_temp = CFG({start_temp},\\n {temp_0, temp_1},\\n start_temp,\\n {production_0, production_1})\\n return cfg_temp.substitute({temp_0: self,\\n temp_1: other})\",\n \"def join_union(self, other):\\n\\n assert type(self) is type(other), 'Expected NestedRE instance'\\n\\n A = self.make_flat()\\n B = other.make_flat()\\n\\n if A == B and A !='ϵ':\\n return self.merge_union(A, [self.closure, other.closure])\\n elif A == 'ϵ' and B == 'ϵ':\\n return NestedRE('ϵ')\\n elif A == 'ϵ':\\n return NestedRE(B, '?')\\n elif B == 'ϵ':\\n return NestedRE(A, '?')\\n else:\\n return NestedRE( '(' + A + '|' + B + ')' )\",\n \"def headsofunion(h1, h2):\\n res = unfi.set(b'heads((%ln + %ln - null))', h1, h2)\\n return {ctx.node() for ctx in res}\",\n \"def symmetric_difference(self, rng_set: Union[Rangelike, Iterable[Rangelike]]) -> 'RangeSet':\\n # convert to a RangeSet\\n rng_set = RangeSet._to_rangeset(rng_set)\\n # get union and then remove intersections\\n union = self.union(rng_set)\\n intersection = self.intersection(rng_set)\\n union.difference_update(intersection)\\n return union\",\n \"def copy(self):\\n products_by_target = defaultdict(OrderedSet)\\n for key, value in self._products_by_target.items():\\n products_by_target[key] = OrderedSet(value)\\n return UnionProducts(products_by_target=products_by_target)\",\n \"def union(self, other):\\n p = AddPermission(*self.needs.union(other.needs))\\n p.excludes.update(self.excludes.union(other.excludes))\\n return p\",\n \"def mergeWith(self, others):\",\n \"def merge_working_sets(self, other):\\n\\n for dist in other.by_key.values(): self.add(dist)\\n return self\",\n \"def stemset_combiner(stempool1, stempool2):\\n return stempool1.stemset | stempool2.stemset\",\n \"def union(self, s2, exps=None):\\n res = self.copy()\\n tr = {}\\n for expr, var in s2.items():\\n if expr in self:\\n if exps:\\n exps = exps.xreplace({var: res[expr]})\\n tr[var] = res[expr]\\n else:\\n res[expr] = var\\n for var, rewr in s2.rewrites.items():\\n res.rewrites[var] = rewr.xreplace(tr)\\n return res, exps\",\n \"def get_union(self, other):\\n\\n union_events_list = AtypicalEventsList()\\n union_events_list.set_atypical_events = self.set_atypical_events | other.set_atypical_events\\n\\n return union_events_list\",\n \"def graph_union(*args, **kwargs):\\n\\n if not len(args) > 1:\\n raise AttributeError('At least two input Graphs required')\\n\\n # Validate if all arguments are Graphs\\n check_graphbase_instance(*args)\\n\\n all_share_common_origin = all([share_common_origin(args[0], n) for n in args[1:]])\\n if all_share_common_origin and not kwargs.get('return_copy', False):\\n\\n nids = []\\n for graph in args:\\n nids.extend([n for n in graph.nodes if n not in nids])\\n\\n eids = []\\n for graph in args:\\n eids.extend([e for e in graph.edges if e not in eids])\\n\\n result = args[0].origin.getnodes(nids)\\n result.edges.set_view(eids)\\n return result\\n else:\\n\\n # make a deep copy of the first graph\\n result = args[0].copy(deep=True, copy_view=False)\\n\\n # we need control over the node ID to add\\n # temporary turn off auto_nid if needed\\n auto_nid = result.data.auto_nid\\n result.data.auto_nid = False\\n\\n for graph in args[1:]:\\n for node, attrib in graph.nodes.items():\\n if node not in result.nodes:\\n result.add_node(node, **attrib)\\n\\n for edge, attrib in graph.edges.items():\\n if edge not in result.edges:\\n result.add_edge(*edge, **attrib)\\n\\n # Restore auto_nid\\n result.data.auto_nid = auto_nid\\n\\n return result\",\n \"def unIfInt(a, b):\\n if len(intersect(a, b)) != 0:\\n return (list(set(a).union(b)))\",\n \"def join(self, a, b):\\n r = defaultdict(lambda: 0)\\n c = itertools.chain(a.get_elements().items(),\\n b.get_elements().items())\\n for element, n in c:\\n r[element] = Nat_add(r[element], n)\\n\\n r = dict(**r)\\n return Multiset(r, self.S)\",\n \"def union(self, *args):\\n _ub = None\\n for _obj in args:\\n if _ub is None:\\n _ub = self.bbox(_obj)\\n else:\\n _b = self.bbox(_obj)\\n _x = np.sort(np.array([_b[:, 0], _ub[:, 0]]), axis=None)\\n _y = np.sort(np.array([_b[:, 1], _ub[:, 1]]), axis=None)\\n _ub = np.array([[_x[0], _y[0]], [_x[3], _y[3]]])\\n return _ub\",\n \"def union(G, H):\\n\\n if G.order() != H.order():\\n msg = \\\"Node sets of the two directed graphs are not equal!\\\"\\n raise StaticGraphNotEqNodesException(msg)\\n\\n n_nodes = G.order()\\n edges = ((u, v) for u in G.nodes()\\n\\t\\t for v in chain(G.successors(u), H.successors(u)))\\n deg = make_deg(n_nodes, edges) \\n edges = ((u, v) for u in G.nodes()\\n\\t\\t for v in chain(G.successors(u), H.successors(u)))\\n GC = make(n_nodes, G.size() + H.size(), edges, deg)\\n return GC\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.91032857","0.8199574","0.81561077","0.8112362","0.8112362","0.8079239","0.7954901","0.78030175","0.7769405","0.7736159","0.7602489","0.7571999","0.75703096","0.75657684","0.7470459","0.7423027","0.7389487","0.7339673","0.7271273","0.72401893","0.72324264","0.7204258","0.71874684","0.7174533","0.71673435","0.710947","0.71081567","0.70579976","0.70506966","0.70506966","0.70492595","0.70076686","0.6978038","0.69593495","0.6948637","0.6904008","0.6901154","0.6900158","0.6874749","0.68729407","0.68568003","0.67880803","0.676356","0.6752024","0.6743165","0.6743165","0.6724389","0.67047167","0.6693252","0.66871744","0.66782534","0.6673837","0.66446126","0.6635888","0.66275847","0.6616383","0.65669537","0.65513355","0.6524261","0.6518953","0.651529","0.6505538","0.6491353","0.64883703","0.64859635","0.6479959","0.64794415","0.64699507","0.64509326","0.64339703","0.6429156","0.641376","0.6392661","0.6390676","0.6381097","0.63664305","0.63605285","0.63565624","0.63485104","0.63200825","0.6284388","0.6279494","0.6278157","0.62780607","0.6239092","0.6212329","0.6191541","0.6174979","0.6156194","0.61348873","0.6132579","0.6117651","0.6098101","0.6090078","0.6076579","0.60642666","0.604205","0.60291547","0.59848404","0.59806466"],"string":"[\n \"0.91032857\",\n \"0.8199574\",\n \"0.81561077\",\n \"0.8112362\",\n \"0.8112362\",\n \"0.8079239\",\n \"0.7954901\",\n \"0.78030175\",\n \"0.7769405\",\n \"0.7736159\",\n \"0.7602489\",\n \"0.7571999\",\n \"0.75703096\",\n \"0.75657684\",\n \"0.7470459\",\n \"0.7423027\",\n \"0.7389487\",\n \"0.7339673\",\n \"0.7271273\",\n \"0.72401893\",\n \"0.72324264\",\n \"0.7204258\",\n \"0.71874684\",\n \"0.7174533\",\n \"0.71673435\",\n \"0.710947\",\n \"0.71081567\",\n \"0.70579976\",\n \"0.70506966\",\n \"0.70506966\",\n \"0.70492595\",\n \"0.70076686\",\n \"0.6978038\",\n \"0.69593495\",\n \"0.6948637\",\n \"0.6904008\",\n \"0.6901154\",\n \"0.6900158\",\n \"0.6874749\",\n \"0.68729407\",\n \"0.68568003\",\n \"0.67880803\",\n \"0.676356\",\n \"0.6752024\",\n \"0.6743165\",\n \"0.6743165\",\n \"0.6724389\",\n \"0.67047167\",\n \"0.6693252\",\n \"0.66871744\",\n \"0.66782534\",\n \"0.6673837\",\n \"0.66446126\",\n \"0.6635888\",\n \"0.66275847\",\n \"0.6616383\",\n \"0.65669537\",\n \"0.65513355\",\n \"0.6524261\",\n \"0.6518953\",\n \"0.651529\",\n \"0.6505538\",\n \"0.6491353\",\n \"0.64883703\",\n \"0.64859635\",\n \"0.6479959\",\n \"0.64794415\",\n \"0.64699507\",\n \"0.64509326\",\n \"0.64339703\",\n \"0.6429156\",\n \"0.641376\",\n \"0.6392661\",\n \"0.6390676\",\n \"0.6381097\",\n \"0.63664305\",\n \"0.63605285\",\n \"0.63565624\",\n \"0.63485104\",\n \"0.63200825\",\n \"0.6284388\",\n \"0.6279494\",\n \"0.6278157\",\n \"0.62780607\",\n \"0.6239092\",\n \"0.6212329\",\n \"0.6191541\",\n \"0.6174979\",\n \"0.6156194\",\n \"0.61348873\",\n \"0.6132579\",\n \"0.6117651\",\n \"0.6098101\",\n \"0.6090078\",\n \"0.6076579\",\n \"0.60642666\",\n \"0.604205\",\n \"0.60291547\",\n \"0.59848404\",\n \"0.59806466\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78106946"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":93488,"cells":{"query":{"kind":"string","value":"Merge thing classes to one class. In PanopticFPN, the background labels will be reset from `0` to `self.num_stuff_classes1`, the foreground labels will be merged to `self.num_stuff_classes`th channel."},"document":{"kind":"string","value":"def _set_things_to_void(self, gt_semantic_seg):\n gt_semantic_seg = gt_semantic_seg.int()\n fg_mask = gt_semantic_seg < self.num_things_classes\n bg_mask = (gt_semantic_seg >= self.num_things_classes) * (\n gt_semantic_seg < self.num_things_classes + self.num_stuff_classes)\n\n new_gt_seg = torch.clone(gt_semantic_seg)\n new_gt_seg = torch.where(bg_mask,\n gt_semantic_seg - self.num_things_classes,\n new_gt_seg)\n new_gt_seg = torch.where(fg_mask,\n fg_mask.int() * self.num_stuff_classes,\n new_gt_seg)\n return new_gt_seg"},"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 merge_class_labels(classes,group):\n classes=np.asarray(classes)\n if (classes.dtype != int) and (classes.dtype != 'int64') and (classes.dtype != 'int32'):\n classes_merged=np.zeros(classes.shape,dtype=object)\n for subgroup in group:\n subgroup_label='+'.join(subgroup)\n for member in subgroup:\n classes_merged[classes==member]=subgroup_label\n else: # int class labels\n classes_merged=np.zeros(classes.shape,dtype=int)\n for i in range(len(group)):\n subgroup=group[i]\n for member in subgroup:\n classes_merged[classes==member]=i\n \n return classes_merged","def reset_class(self, classes):\r\n self._clear_cached_op()\r\n self._classes = classes\r\n if self._pos_iou_thresh >= 1:\r\n self._target_generator = YOLOV3TargetMerger(len(classes), self._ignore_iou_thresh)\r\n for outputs in self.yolo_outputs:\r\n outputs.reset_class(classes)","def _absorb_classes(self, ground_to='in'):\n # Find number of new class for inside and outside set\n currnt_classes = np.unique(self.classes)\n new_class_in = currnt_classes.max() + 1\n new_class_out = currnt_classes.max() + 2\n \n # Ground node to new_class\n if ground_to == 'in':\n self.classes[self.ground_node] = new_class_in\n elif ground_to == 'out':\n self.classes[self.ground_node] = new_class_out\n else:\n self.classes[self.ground_node] = -1\n \n cond_out = self.x[:self.ground_node] > self.threshold\n self.classes[:self.ground_node][cond_out] = new_class_out\n cond_out = self.x[self.ground_node:] > self.threshold\n self.classes[self.ground_node+1:][cond_out] = new_class_out\n \n cond_in = self.x[self.ground_node:] <= self.threshold\n self.classes[self.ground_node+1:][cond_in] = new_class_in\n cond_in = self.x[:self.ground_node] <= self.threshold\n self.classes[:self.ground_node][cond_in] = new_class_in","def __init__(self, in_classes=1, channelscale=64):\n super(DetectPatchAndSegm, self).__init__()\n self.unetvgg1 = UNetSimple(in_classes=in_classes, channelscale=64, out_classes=2)#UNetVgg()\n self.unetvgg2 = UNetSimple(in_classes=3, channelscale=128, out_classes=3)#in is 2 patches and original image\n self.sft = nn.Softmax2d()","def finalize_class_set(self) -> None:\n logger.info(\"We have {} distinct classes, let's cluster it!\", len(self.classes))\n\n logger.debug(\"Created a cluster instance {} and this will cluster {} samples\", self.cluster, self.classes)\n try:\n assigned_clusters = self.cluster.cluster(vectors=[self.convert_str_list_to_vector(c) for c in self.classes],\n assign_clusters=True, trace=not execute_on_ssh_compute)\n except Exception:\n logger.exception(\"Failed to cluster the actual class set ({} samples)\", len(self.classes))\n return\n\n self.classes_to_one_hot_encode_dict.clear()\n for i in range(len(self.classes)):\n self.classes_to_one_hot_encode_dict[self.classes[i]] = assigned_clusters[i]","def increment_classes(self, num_classes):\n # Record number of input and output features for existing network\n in_features = self.model.fc.in_features\n out_features = self.model.fc.out_features\n # Record weight and bias values\n weight = self.model.fc.weight.data\n bias = self.model.fc.bias.data\n\n # If first task\n if self.seen_classes == 0:\n new_out_features = num_classes\n else:\n # Extend fc layer by number of new classes\n new_out_features = out_features + num_classes\n\n # Create new fc layer for the network\n self.model.fc = nn.Linear(in_features, new_out_features)\n\n # Init as per LwF paper\n kaiming_normal_init(self.model.fc.weight)\n # Reassign recorded weight and bias values to new layer\n self.model.fc.weight.data[:out_features] = weight\n self.model.fc.bias.data[:out_features] = bias\n # Increment number of classes\n self.n_classes += num_classes","def class2color(self, labels, clean_up_clusters=0, mode=None):\n clean_up_clusters *= clean_up_clusters # create an area\n colored_labels = np.zeros(labels.shape[:2] + (3,)).astype(np.uint8)\n labels = np.squeeze(labels)\n if clean_up_clusters > 0:\n labels = DropClusters.drop(labels, min_size=clean_up_clusters)\n ys, xs = np.where(labels)\n colored_labels[ys, xs, :] = self.label_color\n return colored_labels","def get_classes_with_colors(self):\n i = 0\n out_classes = ()\n classes = super(NamedEntityRecognizerModel, self).get_classes()\n\n for c in classes:\n if len(c) != 3:\n c += (self.default_colors[i],)\n i += 1\n out_classes += (c,)\n\n return (\n (self.outside_class, self.outside_class_display, self.outside_color),\n ) + out_classes","def thing_classes(self):\n return [Wall, Gold, Pit, Agent]","def change_class_labels_back(classes,given):\n classes=np.asarray(classes)\n classes_new=np.zeros(classes.shape,dtype=object)\n for i in range(len(given)):\n classes_new[classes==i]=given[i]\n return classes_new","def encodeToLabels(self, gt_instances):\n raw_boxes_xyzwhd = np.zeros((self.config_data[\"max_boxes_per_frame\"], 7))\n ### initialize gronud truth labels as np.zeors ###\n gt_labels = np.zeros(list(self.headoutput_shape[1:4]) + \\\n [len(self.anchor_boxes)] + \\\n [len(self.config_data[\"all_classes\"]) + 7])\n\n ### start transferring box to ground turth label format ###\n for i in range(len(gt_instances[\"classes\"])):\n if i > self.config_data[\"max_boxes_per_frame\"]:\n continue\n class_name = gt_instances[\"classes\"][i]\n box_xyzwhd = gt_instances[\"boxes\"][i]\n class_id = self.config_data[\"all_classes\"].index(class_name)\n if i < self.config_data[\"max_boxes_per_frame\"]:\n raw_boxes_xyzwhd[i, :6] = box_xyzwhd\n raw_boxes_xyzwhd[i, 6] = class_id\n class_onehot = helper.smoothOnehot(class_id, len(self.config_data[\"all_classes\"]))\n \n exist_positive = False\n\n grid_strid = self.grid_strides\n anchor_stage = self.anchor_boxes\n box_xyzwhd_scaled = box_xyzwhd[np.newaxis, :].astype(np.float32)\n box_xyzwhd_scaled[:, :3] /= grid_strid\n anchorstage_xyzwhd = np.zeros([len(anchor_stage), 6])\n anchorstage_xyzwhd[:, :3] = np.floor(box_xyzwhd_scaled[:, :3]) + 0.5\n anchorstage_xyzwhd[:, 3:] = anchor_stage.astype(np.float32)\n\n iou_scaled = helper.iou3d(box_xyzwhd_scaled, anchorstage_xyzwhd, \\\n self.input_size)\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\n ### should be taken into consideration as a ground truth label\n iou_mask = iou_scaled > 0.3\n\n if np.any(iou_mask):\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\n astype(np.int32)\n ### TODO: consider changing the box to raw yolohead output format ###\n gt_labels[xind, yind, zind, iou_mask, 0:6] = box_xyzwhd\n gt_labels[xind, yind, zind, iou_mask, 6:7] = 1.\n gt_labels[xind, yind, zind, iou_mask, 7:] = class_onehot\n exist_positive = True\n\n if not exist_positive:\n ### NOTE: this is the normal one ###\n ### it means take the anchor box with maximum iou to the raw\n ### box as the ground truth label\n anchor_ind = np.argmax(iou_scaled)\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\n astype(np.int32)\n gt_labels[xind, yind, zind, anchor_ind, 0:6] = box_xyzwhd\n gt_labels[xind, yind, zind, anchor_ind, 6:7] = 1.\n gt_labels[xind, yind, zind, anchor_ind, 7:] = class_onehot\n\n has_label = False\n for label_stage in gt_labels:\n if label_stage.max() != 0:\n has_label = True\n gt_labels = [np.where(gt_i == 0, 1e-16, gt_i) for gt_i in gt_labels]\n return gt_labels, has_label, raw_boxes_xyzwhd","def _add_class_assignments(self, roidb):\n for entry in roidb:\n gt_overlaps = entry['gt_overlaps'].toarray()\n # max overlap with gt over classes (columns)\n max_overlaps = gt_overlaps.max(axis=1)\n # gt class that had the max overlap\n max_classes = gt_overlaps.argmax(axis=1)\n entry['max_classes'] = max_classes\n entry['max_overlaps'] = max_overlaps\n # sanity checks\n # if max overlap is 0, the class must be background (class 0)\n zero_inds = np.where(max_overlaps == 0)[0]\n assert all(max_classes[zero_inds] == 0)\n # if max overlap > 0, the class must be a fg class (not class 0)\n nonzero_inds = np.where(max_overlaps > 0)[0]\n assert all(max_classes[nonzero_inds] != 0)","def __init__(self, nfeat, nhid, nclass, dropout, alpha):\n super(GCN, self).__init__()\n self.dropout = dropout\n\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\n \n self.add_module('conv1', self.conv1)\n\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)","def set_hypercubes_classes(self):\n print(\"Setting the BaseGrid hypercubes' classes.\")\n list_of_all_hc = list(self.hypercubes.flatten())\n print(\"Number of hypercubes: \" + str(len(list_of_all_hc)))\n for hypercube in list_of_all_hc:\n hypercube.set_hypercube_class()\n if self.child_grid:\n self.child_grid.set_hypercubes_classes()","def _get_cls_out_channels(self):\n # Class numbers (k) + objectness (1)\n return self.num_classes","def _update_mask_attributes(self, sitk_im=None):\n if sitk_im is None:\n sitk_im = self.sitk_image\n np_type = IMTYPE_2_NP[self.type]\n array = self.get_array(sitk_im, np_type, isotropic=False)\n unique, counts = np.unique(array, return_counts=True)\n \n num_classes = len(unique)\n msg = (f'Given {self.num_classes} classes, but this mask has '\n f'{num_classes} unique values!')\n assert len(self._class_names) >= num_classes, msg\n \n # check if unique values match up with associated class values\n given_vals = self._given_class_values\n if given_vals is None or len(given_vals) == 0:\n pre_msg = (f'During mask init, you gave no class_values, so it was '\n f'defaulted to {self._class_values}. ')\n else:\n pre_msg = (f'During mask init, you gave these class_values: '\n f'{self._class_values}.')\n post_msg = (f'When loading the image, it contained values '\n f'({unique}) that were not defined in \"class_values\".')\n msg = pre_msg + post_msg\n for unique_val in unique:\n assert unique_val in self._class_values, msg\n \n class_counts = np.array([0] * self.num_classes)\n for u, c in zip(unique, counts):\n cid = self.class_values.index(u)\n class_counts[cid] = c\n self._class_counts = class_counts\n \n self._unique_values = unique","def _add_class_assignments(self, rawdata):\n gt_overlaps = rawdata['gt_overlaps'].toarray()\n # max overlap with gt over classes (columns)\n max_overlaps = gt_overlaps.max(axis=1)\n # gt class that had the max overlap\n max_classes = gt_overlaps.argmax(axis=1)\n rawdata['max_classes'] = max_classes\n rawdata['max_overlaps'] = max_overlaps\n # sanity checks\n # if max overlap is 0, the class must be background (class 0)\n zero_inds = np.where(max_overlaps == 0)[0]\n assert all(max_classes[zero_inds] == 0)\n # if max overlap > 0, the class must be a fg class (not class 0)\n nonzero_inds = np.where(max_overlaps > 0)[0]\n assert all(max_classes[nonzero_inds] != 0)","def merge_tiles_aug_rbboxes(aug_bboxes,\n aug_labels,\n img_metas,\n merge_cfg,\n classes=None):\n recovered_bboxes = []\n for bboxes, img_info in zip(aug_bboxes, img_metas):\n img_shape = img_info[0]['img_shape']\n scale_factor = img_info[0]['scale_factor']\n flip = img_info[0]['flip']\n tile_offset = img_info[0]['tile_offset']\n bboxes[:, :-1] = rbbox_mapping_back(bboxes[:, :-1],\n img_shape,\n scale_factor,\n flip,\n tile_offset)\n recovered_bboxes.append(bboxes)\n global_bboxes = torch.cat(recovered_bboxes)\n global_labels = torch.cat(aug_labels)\n\n nms_pre = merge_cfg.get('nms_pre', -1)\n if nms_pre > 0 and global_bboxes.shape[0] > nms_pre:\n _, topk_inds = global_bboxes[:, -1].topk(nms_pre)\n global_bboxes = global_bboxes[topk_inds, :]\n global_labels = global_labels[topk_inds]\n\n if isinstance(merge_cfg.nms['iou_thr'], dict):\n assert classes is not None\n iou_thr_dict = merge_cfg.nms['iou_thr']\n merge_cfg.nms['iou_thr'] = [*map(lambda cls: iou_thr_dict.get(cls, 0.05), classes)]\n\n global_bboxes, global_labels = aug_multiclass_rnms(\n global_bboxes,\n global_labels,\n merge_cfg.score_thr,\n merge_cfg.nms,\n merge_cfg.max_per_img)\n return global_bboxes, global_labels","def load_classes(self):\n\t\t\t# Load class names (name -> label).\n\t\t\tcategories = self.coco.loadCats(self.coco.getCatIds())\n\t\t\tcategories.sort(key=lambda x: x['id'])\n\n\t\t\tself.classes = {}\n\t\t\tself.coco_labels = {}\n\t\t\tself.coco_labels_inverse = {}\n\t\t\tfor c in categories:\n\t\t\t\tself.coco_labels[len(self.classes)] = c['id']\n\t\t\t\tself.coco_labels_inverse[c['id']] = len(self.classes)\n\t\t\t\tself.classes[c['name']] = len(self.classes)\n\n\t\t\t# Also load the reverse (label -> name).\n\t\t\tself.labels = {}\n\t\t\tfor key, value in self.classes.items():\n\t\t\t\tself.labels[value] = key","def _update_classification_mask(self, obj_class, mask_coords):\n # Remove background where object resides\n self.classification_mask[0, mask_coords[1]:mask_coords[3], mask_coords[0]:mask_coords[2]] = 0\n # Set classification mask where object resides\n self.classification_mask[obj_class, mask_coords[1]:mask_coords[3], mask_coords[0]:mask_coords[2]] = 1","def _load_classes(self):\n\t\t# load class names (name -> label)\n\t\tcategories = self.coco.loadCats(self.coco.getCatIds())\n\t\tcategories.sort(key=lambda x: x['id'])\n\n\t\tself.classes \t\t\t\t= {}\n\t\tself.coco_labels \t\t\t= {}\n\t\tself.coco_labels_inverse \t= {}\n\t\tfor c in categories:\n\t\t\tself.coco_labels[len(self.classes)] = c['id']\n\t\t\tself.coco_labels_inverse[c['id']] = len(self.classes)\n\t\t\tself.classes[c['name']] = len(self.classes)\n\t\tself.labels = {}\n\t\tfor key, value in self.classes.items():\n\t\t\tself.labels[value] = key\n\n\t\tprint(self.coco_labels)\n\t\tprint(self.coco_labels_inverse)\n\t\tprint(self.classes)\n\t\tprint(self.labels)","def class2onehot(class_labels, seq_len, batchsize, num_task):\n\n\n one_hot = torch.FloatTensor(batchsize,seq_len,num_task)\n one_hot.zero_()\n one_hot = one_hot.scatter_(1, seq_len,class_labels, 1)\n\n return one_hot","def classes(self):\n if not hasattr(self, '_unique_classes'):\n # build when we don't have\n self._unique_classes = self.data['label'].unique()\n self._unique_classes.sort()\n\n ret = self._unique_classes\n return ret","def first_nms(background_class, score_activation, threshold):\r\n # Identify Class Net and Box Net head names based on model type.\r\n if self.model == 'ssd_mobilenet_v2_keras':\r\n head_names = ['StatefulPartitionedCall/BoxPredictor/ConvolutionalClassHead_', \r\n 'StatefulPartitionedCall/BoxPredictor/ConvolutionalBoxHead_']\r\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \r\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \r\n self.model == 'ssd_resnet152_v1_fpn_keras'):\r\n head_names = ['StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalClassHead',\r\n 'StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalBoxHead']\r\n elif (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \r\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \"faster_rcnn_inception_resnet_v2_keras\"):\r\n head_names = ['StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalClassHead_0/ClassPredictor',\r\n 'StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor']\r\n\r\n class_net = None\r\n box_net = None\r\n\r\n # Getting SSD's Class and Box Nets final tensors.\r\n if \"ssd\" in self.model:\r\n # Find the concat node at the end of the class net (multi-scale class predictor).\r\n class_net = find_head_end(head_names[0], \"Transpose\", \"Concat\")\r\n\r\n # SSD's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\r\n slice_start = np.asarray([1], dtype=np.int64)\r\n slice_end = np.asarray([91], dtype=np.int64)\r\n # Second list element but third tensor dimension.\r\n slice_axes = np.asarray([2], dtype=np.int64)\r\n slice_out = self.graph.elt_const_slice(\"Slice\", head_names[0]+\"/slicer\", class_net.outputs[0], slice_start, slice_end, slice_axes)\r\n\r\n # Final Class Net tensor.\r\n class_net_tensor = slice_out[0]\r\n\r\n if self.model == 'ssd_mobilenet_v2_keras':\r\n # Find the squeeze node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Concat\")\r\n box_net_squeeze = self.graph.find_descendant_by_op(box_net, \"Squeeze\")\r\n box_net_output = box_net_squeeze.outputs[0]\r\n\r\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \r\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \r\n self.model == 'ssd_resnet152_v1_fpn_keras'):\r\n # Find the concat node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Concat\")\r\n box_net_output = box_net.outputs[0]\r\n\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output in order to get accurate coordinates.\r\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n scale_out = self.graph.elt_const(\"Mul\", head_names[1]+\"/scale\", box_net_output, scale_adj)\r\n\r\n # Final Box Net tensor.\r\n box_net_tensor = scale_out[0]\r\n \r\n # Getting Faster R-CNN's 1st Class and Box Nets tensors.\r\n elif \"faster_rcnn\" in self.model:\r\n if (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \r\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \"faster_rcnn_inception_resnet_v2_keras\"):\r\n # Find the softmax node at the end of the class net (multi-scale class predictor).\r\n class_net = find_head_end(head_names[0], \"Transpose\", \"Softmax\")\r\n\r\n # Final Class Net tensor\r\n class_net_tensor = class_net.outputs[0] \r\n\r\n # Find the reshape node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Reshape\")\r\n # Final Box Net tensor.\r\n box_net_output = box_net.outputs[0]\r\n\r\n #Insert a squeeze node\r\n squeeze_node = self.graph.squeeze(head_names[1]+\"/squeeze\", box_net_output)\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output, in order to get accurate coordinates.\r\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n scale_out = self.graph.elt_const(\"Mul\", head_names[1]+\"/scale\", squeeze_node, scale_adj)\r\n\r\n # Final Box Net tensor.\r\n box_net_tensor = scale_out[0]\r\n\r\n\r\n # 3. Find the split node that separates the box net coordinates and feeds them into the box decoder.\r\n box_net_split = self.graph.find_descendant_by_op(box_net, \"Split\")\r\n assert box_net_split and len(box_net_split.outputs) == 4\r\n\r\n # Set score threshold\r\n score_threshold = self.first_stage_nms_score_threshold if threshold is None else threshold\r\n\r\n # NMS Inputs and Attributes\r\n # NMS expects these shapes for its input tensors:\r\n # box_net: [batch_size, number_boxes, 4]\r\n # class_net: [batch_size, number_boxes, number_classes]\r\n # anchors: [1, number_boxes, 4] (if used)\r\n nms_op = None\r\n nms_attrs = None\r\n nms_inputs = None\r\n\r\n # EfficientNMS TensorRT Plugin is suitable for our use case.\r\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\r\n # three inputs are given to the NMS TensorRT node:\r\n # - The box predictions (from the Box Net node found above)\r\n # - The class predictions (from the Class Net node found above)\r\n # - The default anchor coordinates (from the extracted anchor constants)\r\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\r\n # because this is the internal box coding format used by the network.\r\n anchors_tensor = extract_anchors_tensor(box_net_split)\r\n nms_inputs = [box_net_tensor, class_net_tensor, anchors_tensor]\r\n nms_op = \"EfficientNMS_TRT\"\r\n nms_attrs = {\r\n 'plugin_version': \"1\",\r\n 'background_class': background_class,\r\n 'max_output_boxes': self.first_stage_max_proposals,\r\n 'score_threshold': max(0.01, score_threshold),\r\n 'iou_threshold': self.first_stage_nms_iou_threshold,\r\n 'score_activation': score_activation,\r\n 'box_coding': 1,\r\n }\r\n nms_output_classes_dtype = np.int32\r\n\r\n # NMS Outputs.\r\n nms_output_num_detections = gs.Variable(name=\"num_detections\", dtype=np.int32, shape=[self.batch_size, 1])\r\n nms_output_boxes = gs.Variable(name=\"detection_boxes\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\r\n nms_output_scores = gs.Variable(name=\"detection_scores\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n nms_output_classes = gs.Variable(name=\"detection_classes\", dtype=nms_output_classes_dtype,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n\r\n nms_outputs = [nms_output_num_detections, nms_output_boxes, nms_output_scores, nms_output_classes]\r\n\r\n # Create the NMS Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=nms_op,\r\n name=\"nms/non_maximum_suppression_first\",\r\n inputs=nms_inputs,\r\n outputs=nms_outputs,\r\n attrs=nms_attrs)\r\n log.info(\"Created NMS plugin '{}' with attributes: {}\".format(nms_op, nms_attrs))\r\n\r\n # If model type is SSD, then you are done with conversion and optimizations.\r\n if \"ssd\" in self.model:\r\n self.graph.outputs = nms_outputs\r\n self.infer()\r\n return None\r\n # If model is Faster R-CNN, then you continue with conversion and optimizations,\r\n # next step is CropAndResize. \r\n elif \"faster_rcnn\" in self.model:\r\n return nms_outputs[1]","def __init__(self, channels, num_classes):\n super(AuxiliaryHead, self).__init__()\n self.features = nn.Sequential(\n nn.ReLU(inplace=True),\n # image size = 2 x 2\n nn.AvgPool2d(5, stride=3, padding=0, count_include_pad=False),\n nn.Conv2d(channels, 128, 1, bias=False),\n nn.BatchNorm2d(128),\n nn.ReLU(inplace=True),\n nn.Conv2d(128, 768, 2, bias=False),\n nn.BatchNorm2d(768),\n nn.ReLU(inplace=True),\n )\n self.classifier = nn.Linear(768, num_classes)","def update_class(self):\n neighbors_set = list(set(self.neighbors))\n counts = np.array([self.neighbors.count(n) for n in neighbors_set])\n probs = (counts / counts.sum()) * (1-self.mutation_prob)\n probs = np.append(probs, self.mutation_prob)\n neighbors_set.append(np.random.choice(np.arange(1, self.board.classes))) \n\n self.cell_class = np.random.choice(neighbors_set, p=probs)","def build(self, input_image, num_class):\n x = build_resnet(101)\n # add classifier\n x = Conv2D(num_class, (1, 1), kernel_initializer='he_normal', activation='linear', padding='valid', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x)","def assign_class_from_feature_annotation(feature_annotation_df):\n print \"============Start assigning and encoding classes=================\"\n print \"================thresholds=====================\"\n walkthreshold = 0.3\n ambithreshold = 0.25\n phonethreshold = 0.3\n computerthreshold = 0.3\n activity_thresholds = [0.3,0.25,0.3,0.3,0.3,0.3,0.3,0.25]\n activity_names = ['walking','eating','phone','computer','talking', 'reading','in car', 'drinking']\n class_codes = [1,2,3,4,5,6,7,8]\n activity_cols = [s_info.walkproportion_col,\n s_info.eatproportion_col,\n s_info.phoneproportion_col,\n s_info.computerproportion_col,\n s_info.talkproportion_col,\n s_info.readproportion_col,\n s_info.carproportion_col,\n s_info.drinkproportion_col]\n puff_with_puff_duration_threshold = 0.3\n puff_with_segment_duration_threshold = 0.3\n print \"walking: \" + str(walkthreshold)\n print \"drinking/eating: \" + str(ambithreshold)\n print \"phone: \" + str(phonethreshold)\n print \"computer: \" + str(computerthreshold)\n print \"puff: \" + str(puff_with_puff_duration_threshold) + \", \" + str(puff_with_segment_duration_threshold)\n class_df = feature_annotation_df.copy(deep=True)\n \n # class assignment rules\n class_df[s_info.classname_col] = 'others'\n class_df[s_info.classnum_col] = 0\n\n for code, name, threshold, col in zip(class_codes, activity_names, activity_thresholds, activity_cols):\n flag = class_df[col] >= threshold\n class_df[s_info.classname_col][flag] = name\n class_df[s_info.classnum_col][flag] = code\n # for short window size\n puff_flag1 = class_df[s_info.puff_with_segment_duration_col] >= puff_with_segment_duration_threshold\n class_df[s_info.classname_col][puff_flag1] = 'puff'\n class_df[s_info.classnum_col][puff_flag1] = len(class_codes) + 1\n # for short puffs\n puff_flag2 = class_df[s_info.puff_with_puff_duration_col] >= puff_with_puff_duration_threshold\n class_df[s_info.classname_col][puff_flag2] = 'puff'\n class_df[s_info.classnum_col][puff_flag2] = len(class_codes) + 1\n return class_df","def cut_classes(self, dataset, classes, max_size, label):\n\n # Cherry picked classes\n class_dfs = []\n for c in classes:\n picked_data = dataset.loc[(dataset.loc[:,label] == c),:].reset_index(drop=True)\n class_dfs.append(picked_data.loc[0:min(len(picked_data), max_size),:])\n #class_dfs.append(picked_data.sample(n=min(len(picked_data), max_size)))\n\n # Concat\n data = pd.concat(class_dfs)\n return data","def one_hot_encoding(mask: typing.Any, classes: typing.List[int]):\n raise TypeError(\"Mask should be either np.ndarray of torch.Tensor\")","def mask_classes(outputs: torch.Tensor, dataset: ContinualDataset, k: int) -> None:\n outputs[:, 0:k * dataset.N_CLASSES_PER_TASK] = -float('inf')\n outputs[:, (k + 1) * dataset.N_CLASSES_PER_TASK:\n dataset.N_TASKS * dataset.N_CLASSES_PER_TASK] = -float('inf')","def make_multilabel_target(num_classes, classes):\n target = np.zeros(num_classes, dtype=np.uint8)\n target[classes] = 1\n return target","def __init__(self, C, num_classes):\n super(AuxiliaryHeadImageNet, self).__init__()\n self.features = nn.Sequential(nn.ReLU(inplace=True), nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False), nn.Conv2d(C, 128, 1, bias=False), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 768, 2, bias=False), nn.ReLU(inplace=True))\n self.classifier = nn.Linear(768, num_classes)","def shapeItToRFMixMultiClass(rfmix_admix, rfmix_ancestrals):\n\tprint rfmix_admix + \".haps\"\n\thapfile = open(rfmix_admix + \".haps\", \"r\")\n\tallele_file = open(rfmix_admix + \".alleles\", \"w\") # File that stores 10 haplotypes\n\tmapfile = open(rfmix_admix + \".amaps\", \"w\")\n\t# Need to keep track of population numbers here\n\t\n\thap_strings, alleles = readShapeItFile(hapfile)\n\tpop_nums = [0]*len(hap_strings[0]) # Add admixed ind codes to pop_numbers array\n\ti = 1\n\tfor thisanc in rfmix_ancestrals:\n\t\tthisfile = open(thisanc + \".haps\", \"r\")\n\t\tthis_haps, this_alleles = readShapeItFile(thisfile)\n\t\tpop_nums.extend([i]*(len(this_haps[0])))\n\t\tfor j in range(0,len(hap_strings)): \n\t\t\t# need to check if the alleles are flipped the same way\n\t\t\tif not checkPolarity(alleles[j], this_alleles[j]):\n\t\t\t\tthis_haps[j] = flip10(this_haps[j])\n\t\t\thap_strings[j] += this_haps[j]\n\t\ti += 1\n\t## Ok now I should have all the classes and haplotypes correctly\n\tclassout = open(rfmix_admix + \".classes\", \"w\")\n\tclassout.write(\" \".join(map(str,pop_nums)) + \"\\n\")\n\tallele_file.write(\"\\n\".join(hap_strings) + \"\\n\")\n\tfor a in alleles:\n\t\tmapfile.write(\"\\t\".join(a) + \"\\n\")\n\tallele_file.close()\n\tclassout.close()\n\tmapfile.close()\n\treturn([allele_file.name, classout.name, mapfile.name])","def _set_classifiers(self, clfs):\n # tuple to guarantee immutability since we are asssigning\n # __tags__ below and rely on having clfs populated already\n self.__clfs = tuple(clfs) if clfs is not None else tuple()\n \"\"\"Classifiers to use\"\"\"\n\n if len(clfs):\n # enable corresponding ca in the slave-classifiers\n if self.__propagate_ca:\n for clf in self.__clfs:\n clf.ca.enable(self.ca.enabled, missingok=True)\n\n # adhere to their capabilities + 'multiclass'\n # XXX do intersection across all classifiers!\n # TODO: this seems to be wrong since it can be regression etc\n self.__tags__ = [ 'binary', 'multiclass', 'meta' ]\n if len(clfs)>0:\n self.__tags__ += self.__clfs[0].__tags__","def get_shapes(self):\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\n X = []\n backmap = {}\n rad = 3\n for k,((i,y),(j,x)) in enumerate(self.mids):\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\n colours[i][j] = m\n X.append(m)\n backmap[k] = (i,j)\n print(np.shape(X))\n Z = linkage(X, 'ward')\n Q = fcluster(Z, self.thresh, criterion='distance')\n\n closenesses = []\n for k,cls in enumerate(Q):\n i,j = backmap[k]\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\n minidx = np.argmin(closenesses)\n bgcls = Q[minidx]\n\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\n img4 = self.img2.copy()\n for k,((i,y),(j,x)) in enumerate(self.mids):\n cls = Q[k]\n if cls == bgcls:\n continue\n col = blibs[(cls-1)]\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\n\n write_img(\"./out/test_classes.png\", img4)\n self.classimg = img4\n\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\n mx = np.max(Q)\n for k,cls in enumerate(Q):\n if cls == bgcls:\n continue\n\n if cls == mx:\n plotcls = bgcls\n else:\n plotcls = cls\n i,j = backmap[k]\n A[i][j] = plotcls\n\n self.res = A","def merge(self):\n # Find which clusters/rows to merge\n self.segsChanged = True\n tomerge = []\n i = 0\n for cbox in self.cboxes:\n if cbox.checkState() != 0:\n tomerge.append(i)\n i += 1\n print('rows/clusters to merge are:', tomerge)\n if len(tomerge) < 2:\n return\n\n # Generate new class labels\n nclasses = self.nclasses - len(tomerge) + 1\n max_label = nclasses - 1\n labels = []\n c = self.nclasses - 1\n while c > -1:\n if c in tomerge:\n labels.append((c, 0))\n else:\n labels.append((c, max_label))\n max_label -= 1\n c -= 1\n\n # print('[old, new] labels')\n labels = dict(labels)\n # print(labels)\n\n keys = [i for i in range(self.nclasses) if i not in tomerge] # the old keys those didn't merge\n # print('old keys left: ', keys)\n\n # update clusters dictionary {ID: cluster_name}\n clusters = {0: self.clusters[tomerge[0]]}\n for i in keys:\n clusters.update({labels[i]: self.clusters[i]})\n\n print('before update: ', self.clusters)\n self.clusters = clusters\n print('after update: ', self.clusters)\n\n self.nclasses = nclasses\n\n # update the segments\n for seg in self.segments:\n seg[-1] = labels[seg[-1]]\n\n # update the cluster combobox\n #self.cmbUpdateSeg.clear()\n #for x in self.clusters:\n #self.cmbUpdateSeg.addItem(self.clusters[x])\n\n # Clean and redraw\n self.clearButtons()\n self.updateButtons()\n self.completeChanged.emit()","def _add_basic_classifier_combined(model_1, model_2):\n dropout = None\n if model_1._dropout:\n dropout = model_1._dropout.p\n return BasicClassifierCombined(\n vocab=model_1.vocab,\n text_field_embedder=model_1._text_field_embedder,\n seq2vec_encoder=model_1._seq2vec_encoder,\n feedforward=model_1._feedforward,\n dropout=dropout,\n num_labels=model_1._num_labels,\n )","def update_categorical_feats(self):\n common_feats = self.get_common_features()\n self.categorical_feats = list(set(self.categorical_feats).intersection(common_feats))","def __init__(self, num_classes):\n super().__init__()\n # maintains size of 128x128\n self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1)\n # maintains size of 64x64\n self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)\n # Half size\n self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n # Original image of size 128x128 is halved twice to 32 * 32. With 64 channels flattened is 32 * 32 * 64\n self.fc1 = nn.Linear(32 * 32 * 64, 1000)\n self.fc2 = nn.Linear(1000, num_classes)\n self.dropout = nn.Dropout()","def __init__(self, classes=2622):\n super().__init__()\n self.conv1 = _ConvBlock(3, 64, 64)\n self.conv2 = _ConvBlock(64, 128, 128)\n self.conv3 = _ConvBlock(128, 256, 256, 256)\n self.conv4 = _ConvBlock(256, 512, 512, 512)\n self.conv5 = _ConvBlock(512, 512, 512, 512)\n self.dropout = torch.nn.Dropout(0.5)\n self.fc1 = torch.nn.Linear(7 * 7 * 512, 4096)\n self.fc2 = torch.nn.Linear(4096, 4096)\n self.fc3 = torch.nn.Linear(4096, classes)","def _convert_to_onehot_labels(seg_label, num_classes):\n\n batch_size = seg_label.size(0)\n onehot_labels = seg_label.new_zeros((batch_size, num_classes))\n for i in range(batch_size):\n hist = seg_label[i].float().histc(\n bins=num_classes, min=0, max=num_classes - 1)\n onehot_labels[i] = hist > 0\n return onehot_labels","def _multiclass_with_missing_class(*shape: Any, num_classes=NUM_CLASSES):\n x = torch.randint(0, num_classes, shape)\n x[x == 0] = 2\n return x","def classify(self):\n infer = self.model.signatures['serving_default']\n for i, original_image in enumerate(self.images):\n image = original_image.copy()\n image = cv.cvtColor(image, cv.COLOR_BGR2RGB)\n image = cv.resize(image, (self.image_size, self.image_size))\n image = image / 255.\n\n image = [image]\n image = np.asarray(image).astype(np.float32)\n batch_data = tf.constant(image)\n pred_bbox = infer(batch_data)\n for key, value in pred_bbox.items():\n boxes = value[:, :, 0:4]\n pred_conf = value[:, :, 4:]\n\n boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(\n boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),\n scores=tf.reshape(\n pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),\n max_output_size_per_class=10,\n max_total_size=10,\n iou_threshold=FLAGS.iou,\n score_threshold=FLAGS.score\n )\n\n height, width, _ = original_image.shape\n\n print(scores)\n classes = classes[0]\n print(classes)\n\n bbox = boxes[0][0].numpy()\n bbox[0] = int(bbox[0] * height)\n bbox[2] = int(bbox[2] * height)\n bbox[1] = int(bbox[1] * width)\n bbox[3] = int(bbox[3] * width)\n\n if BIRD_CLASS in classes:\n idx = np.where(classes == BIRD_CLASS)\n bbox = bbox.astype(np.int)\n x = int((bbox[1] + bbox[3]) / 2)\n y = int((bbox[0] + bbox[2]) / 2)\n self.thumbnail_center.append((x, y))\n cropped_img = original_image[bbox[0]:bbox[2], bbox[1]: bbox[3]]\n self.bird_images.append(cropped_img)\n self.confidence_arr.append(scores[idx[0][0]][0])\n\n self.generate_thumbnail(size=150)","def mask_label_into_class_label(self, mask_labels, img_resolution = 256, bigger_than_percent=3.0):\n array_of_number_of_change_pixels = []\n\n for mask in mask_labels:\n number_of_ones = np.count_nonzero(mask.flatten()) # << loading takes care of this 0 vs non-zero\n array_of_number_of_change_pixels.append(number_of_ones)\n\n self.debugger.save_arr(array_of_number_of_change_pixels, \"BALANCING\")\n array_of_number_of_change_pixels = self.debugger.load_arr(\"BALANCING\")\n\n array_of_number_of_change_pixels = array_of_number_of_change_pixels / (\n img_resolution * img_resolution) * 100.0 # percentage of image changed\n\n class_labels = []\n for value in array_of_number_of_change_pixels:\n is_change = value > bigger_than_percent\n class_labels.append(int(is_change))\n\n return np.array(class_labels)","def assignClassLabelToSuperPixel(superPixelMask, imageClassLabels):\n # just adopt the most frequently occurring class label as the superpixel label\n superPixelConstituentLabels = imageClassLabels[superPixelMask]\n labelCount = scipy.stats.itemfreq(superPixelConstituentLabels)\n # This is nx2 matrix, each row is (label, count). Sort in descending count order\n if labelCount.shape[0] > 1:\n idx = np.argsort( labelCount[:,1] )[::-1]\n labelCount = labelCount[ idx, : ]\n # If there are enough pixels of the max class, and the second class is not\n # significant, include it. Otherwise give it void so it gets discarded\n # later on.\n if float(labelCount[0,1])/len(superPixelConstituentLabels) >= 0.5 and \\\n ( labelCount.shape[0]<=1 or labelCount[1,1] <= labelCount[0,1]/2 ):\n return int( labelCount[0,0] )\n else:\n raise Exception( 'WARNING: superpixel has conflicting GT class labels (%.3f %% majority).' % \\\n (100.0 * float(labelCount[0,1])/len(superPixelConstituentLabels)) )","def _labels_to_one_hot_class(self, labels, mask):\n classes = tf.one_hot(\n tf.cast(labels, tf.int32), self._num_classes, dtype=tf.float32)\n return tf.where(tf.expand_dims(mask, axis=-1), classes, 0.0)","def apply_classifier(self):\n for detected_object in self.detected_objects:\n detected_object.predict_class(self.original_image)","def get_one_hot(self, mask_slice):\n mask_one_hot = self.map_vert_to_class(mask_slice).reshape(-1, 1)\n self.one_hot_encoder.fit(mask_one_hot)\n mask_one_hot = self.one_hot_encoder.transform(mask_one_hot).toarray()\n # set 1st dim to num classes\n mask_one_hot = np.transpose(mask_one_hot, (1, 0))\n mask_one_hot = mask_one_hot[:,:, None]\n mask_one_hot = mask_one_hot.reshape((6, mask_slice.shape[0], mask_slice.shape[1]))\n return mask_one_hot","def get_target_shape(self):\n if not self.channels_first:\n return [None] + self.w + [self.nclasses]\n else:\n return [None] + [self.nclasses] + self.w","def __init__(self, C, num_classes):\n super(AuxiliaryHeadImageNet, self).__init__()\n self.features = nn.Sequential(\n nn.ReLU(inplace=True),\n nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False),\n nn.Conv2d(C, 128, 1, bias=False),\n nn.BatchNorm2d(128),\n nn.ReLU(inplace=True),\n nn.Conv2d(128, 768, 2, bias=False),\n # NOTE: This batchnorm was omitted in my earlier implementation due to a typo.\n # Commenting it out for consistency with the experiments in the paper.\n # nn.BatchNorm2d(768),\n nn.ReLU(inplace=True)\n )\n self.classifier = nn.Linear(768, num_classes)","def __init__(self, C, num_classes):\n super(AuxiliaryHeadImageNet, self).__init__()\n self.features = nn.Sequential(\n nn.ReLU(inplace=True),\n nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False),\n nn.Conv2d(C, 128, 1, bias=False),\n nn.BatchNorm2d(128),\n nn.ReLU(inplace=True),\n nn.Conv2d(128, 768, 2, bias=False),\n # NOTE: This batchnorm was omitted in my earlier implementation due to a typo.\n # Commenting it out for consistency with the experiments in the paper.\n # nn.BatchNorm2d(768),\n nn.ReLU(inplace=True)\n )\n self.classifier = nn.Linear(768, num_classes)","def __init__(self, C, num_classes):\n super(AuxiliaryHeadImageNet, self).__init__()\n self.features = nn.Sequential(\n nn.ReLU(inplace=True),\n nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False),\n nn.Conv2d(C, 128, 1, bias=False),\n nn.BatchNorm2d(128),\n nn.ReLU(inplace=True),\n nn.Conv2d(128, 768, 2, bias=False),\n # NOTE: This batchnorm was omitted in my earlier implementation due to a typo.\n # Commenting it out for consistency with the experiments in the paper.\n # nn.BatchNorm2d(768),\n nn.ReLU(inplace=True)\n )\n self.classifier = nn.Linear(768, num_classes)","def classes(self):\n #print \"making classes again!\"\n l = []\n for p in self.marks:\n l.append(psi_class(self,p))\n for d in range(1, self.dimension + 1):\n l.append(kappa_class(self,d))\n for i in range(1, self.genus+1):\n l.append(chern_char(self, 2*i-1))\n if True:#self.genus != 0:\n l.append(irreducible_boundary(self))\n marks = set(self.marks)\n reducible_boundaries = []\n if self.n != 0:\n first_mark_list = [marks.pop()] \n for g1 in range(0, self.genus + 1):\n for p in subsets(marks):\n r_marks = set(first_mark_list + p)\n if 3*g1 - 3 + len(r_marks) + 1 >= 0 and 3*(self.genus-g1) - 3 + self.n - len(r_marks) + 1 >= 0:\n reducible_boundaries.append( reducible_boundary(self, Mgn(g1, r_marks)) )\n \n reducible_boundaries.sort(key = lambda b: sorted(list(b.component1.marks)))\n reducible_boundaries.sort(key = lambda b: len(b.component1.marks))\n reducible_boundaries.sort(key = lambda b: b.component1.genus)\n \n else: #self.n == 0\n for g1 in range(1, floor(self.genus/2.0)+1):\n reducible_boundaries.append(reducible_boundary(self, Mgn(g1, []))) \n \n \n l += reducible_boundaries \n \n for i in range(1,self.genus+1):\n l.append(lambda_class(self,i))\n return l","def encodeToCartBoxesLabels(self, gt_instances):\n raw_boxes_xywh = np.zeros((self.config_data[\"max_boxes_per_frame\"], 5))\n ### initialize gronud truth labels as np.zeros ###\n gt_labels = np.zeros(list(self.cart_shape[1:3]) + \\\n [len(self.anchor_boxes_cart)] + \\\n [len(self.config_data[\"all_classes\"]) + 5]) \n\n ### start transferring box to ground turth label format ###\n for i in range(len(gt_instances[\"classes\"])):\n if i > self.config_data[\"max_boxes_per_frame\"]:\n continue\n class_name = gt_instances[\"classes\"][i]\n box_xywh = gt_instances[\"cart_boxes\"][i]\n class_id = self.config_data[\"all_classes\"].index(class_name)\n if i <= self.config_data[\"max_boxes_per_frame\"]:\n raw_boxes_xywh[i, :4] = box_xywh\n raw_boxes_xywh[i, 4] = class_id\n class_onehot = helper.smoothOnehot(class_id, \\\n len(self.config_data[\"all_classes\"]))\n exist_positive = False\n grid_strid = self.cart_grid_strides\n anchors = self.anchor_boxes_cart\n box_xywh_scaled = box_xywh[np.newaxis, :].astype(np.float32)\n box_xywh_scaled[:, :2] /= grid_strid\n anchors_xywh = np.zeros([len(anchors), 4])\n anchors_xywh[:, :2] = np.floor(box_xywh_scaled[:, :2]) + 0.5\n anchors_xywh[:, 2:] = anchors.astype(np.float32)\n\n iou_scaled = helper.iou2d(box_xywh_scaled, anchors_xywh)\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\n ### should be taken into consideration as a ground truth label\n iou_mask = iou_scaled > 0.3\n\n if np.any(iou_mask):\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\n ### TODO: consider changing the box to raw yolohead output format ###\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\n exist_positive = True\n\n if not exist_positive:\n ### NOTE: this is the normal one ###\n ### it means take the anchor box with maximum iou to the raw\n ### box as the ground truth label\n iou_mask = iou_scaled == iou_scaled.max()\n\n if np.any(iou_mask):\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\n ### TODO: consider changing the box to raw yolohead output format ###\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\n\n has_label = False\n if gt_labels.max() != 0:\n has_label = True\n gt_labels = np.where(gt_labels == 0, 1e-16, gt_labels)\n return gt_labels, has_label, raw_boxes_xywh","def compute_mask_class(y_true: Tensor):\n y_true = y_true.detach().cpu()\n batch_size = y_true.size(0)\n num_classes = y_true.size(1)\n if num_classes == 1:\n y_true = y_true.view(batch_size, -1)\n elif num_classes == 2:\n y_true = y_true[:, 1, ...].contiguous().view(batch_size, -1) # Take salt class\n else:\n raise ValueError('Unknown num_classes')\n\n img_area = float(y_true.size(1))\n percentage = y_true.sum(dim=1) / img_area\n class_index = (percentage * 4).round().byte()\n return class_index","def _merge_heads(self, x, is_picture):\n if is_picture is False:\n if len(x.shape) != 4:\n raise ValueError(\"x must have rank 4\")\n shape = x.shape\n return x.permute(0, 2, 1, 3).contiguous().reshape(shape[0], shape[2], shape[3]*self.num_heads)\n else:\n if len(x.shape) != 6:\n raise ValueError(\"x must have rank 6\")\n shape = x.shape\n return x.permute(0, 2, 3, 4, 1, 5).contiguous().reshape(shape[0], shape[2], shape[3], shape[4], shape[5]*self.num_heads)","def generate(self, objects):\n\n 'Initialize/reset each target volume with zeros'\n self.classification_mask = np.zeros([self.num_classes, self.target_height, self.target_width])\n self.bbox_mask = np.zeros([self.num_coords, self.target_height, self.target_width])\n self.depth_mask = np.zeros([self.num_depth, self.target_height, self.target_width])\n\n 'Set entire mask as background until objects are processed'\n self.classification_mask[0, :, :] = 1\n\n for obj in objects:\n obj_class = self._get_class(obj)\n shrink_factor = self._get_shrink_factor(obj_class)\n mask_coords = self._get_mask_coords(obj, shrink_factor)\n\n self._update_classification_mask(obj_class, mask_coords)\n self._update_bbox_mask(obj.bounding_box, mask_coords)\n self._update_depth_mask(obj.bounding_box, mask_coords)\n\n \"Suppress background and dont care classes\"\n suppress_mask = self._suppress_bg_dc()\n\n return np.copy(self.classification_mask), np.copy(self.bbox_mask), \\\n np.copy(self.depth_mask), np.copy(suppress_mask)","def prepare(self, class_map=None):\n def clean_name(name):\n \"\"\"Returns a shorter version of object names for cleaner display.\"\"\"\n return \",\".join(name.split(\",\")[:1])\n\n # Build (or rebuild) everything else from the info dicts.\n self.num_classes = len(self.class_info)\n self.class_ids = np.arange(self.num_classes)\n self.class_names = [clean_name(c[\"name\"]) for c in self.class_info]\n self.num_images = len(self.image_info)\n self._image_ids = np.arange(self.num_images)\n\n self.class_from_source_map = {\"{}.{}\".format(info['source'], info['id']): id\n for info, id in zip(self.class_info, self.class_ids)}\n\n # Map sources to class_ids they support\n self.sources = list(set([i['source'] for i in self.class_info]))\n self.source_class_ids = {}\n # Loop over datasets\n for source in self.sources:\n self.source_class_ids[source] = []\n # Find classes that belong to this dataset\n for i, info in enumerate(self.class_info):\n # Include BG class in all datasets\n if i == 0 or source == info['source']:\n self.source_class_ids[source].append(i)","def __init__(self, num_classed= 100):\n self.model = Sequential()\n self.num_classed = num_classed\n self.categories = ['apples', 'aquarium fish', 'baby', 'bear', 'beaver',\n 'bed', 'bee', 'beetle', 'bicycle', 'bottles',\n 'bowls','boy', 'bridge', 'bus', 'butterfly', \n 'camel', 'cans', 'castle', 'caterpillar', 'cattle', \n 'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', \n 'couch', 'crab', 'crocodile', 'cups', \n 'dinosaur', 'dolphin', 'elephant', 'flatfish', 'forest', \n 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'computer keyboard', 'lamp', \n 'lawn-mower', 'leopard', 'lion', 'lizard', 'lobster', \n 'man', 'maple', 'motorcycle', 'mountain', 'mouse', \n 'mushrooms', 'oak', 'oranges', 'orchids', 'otter', \n 'palm', 'pears', 'pickup truck', 'pine', 'plain', \n 'plates', 'poppies', 'porcupine', 'possum', 'rabbit', \n 'raccoon', 'ray', 'road', 'rocket', 'roses', 'sea', \n 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', \n 'snail', 'snake', 'spider', 'squirrel', 'streetcar', \n 'sunflowers', 'sweet peppers', 'table', 'tank', 'telephone', \n 'television', 'tiger', 'tractor', 'train', 'trout', \n 'tulips', 'turtle', 'wardrobe', 'whale', 'willow', \n 'wolf', 'woman', 'worm']","def translate_all_poslists_to_ourclass_numb(motifs_dict,gnum_classes_rel,cons_pos_dict,current_class,other_classes_ok):\n current_poslists=cons_pos_dict[current_class]\n current_motif = motifs_dict[current_class]\n show_class={\"A\":True,\"B\":True,\"C\":True,\"F\":True}\n for gpcr_class in other_classes_ok:\n for cons_pos_li in cons_pos_dict[gpcr_class]:\n for el in cons_pos_li:\n pos_nm=el[0]\n s=re.search(\"([A-Z]?)([\\d\\.]+)\",pos_nm)\n AA=s.group(1)\n bw_pos_ok=s.group(2)\n try:\n current_bw_pos=gnum_classes_rel[gpcr_class][bw_pos_ok]\n except Exception:\n current_bw_pos=\"Position not found\"\n el[2]=\"None\"\n el[0]=AA + bw_pos_ok + gpcr_class.lower()\n el[1]=current_bw_pos\n motif_info = motifs_dict[gpcr_class]\n if motif_info:\n for el in motif_info[0]:\n bw_pos=el[1][1:]\n if bw_pos in gnum_classes_rel[gpcr_class]:\n current_bw_pos=gnum_classes_rel[gpcr_class][bw_pos]\n el[4]=current_bw_pos\n none_classes=list({\"A\",\"B\",\"C\",\"F\"} - set(other_classes_ok + list(current_class)))\n for n_class in none_classes:\n show_class[n_class]=False\n i=0\n while i < len(cons_pos_dict[n_class]):\n cons_pos_dict[n_class][i]=None\n i+=1\n motifs_dict[n_class]=[]\n return (show_class,current_poslists,current_motif,other_classes_ok)","def add_extra_classes():\n\n for wire_version in [of_g.VERSION_1_2, of_g.VERSION_1_3]:\n version_name = of_g.of_version_wire2name[wire_version]\n oxm.add_oxm_classes_1_2(versions[version_name]['classes'], wire_version)","def generate_subclass_mask(mask_image,\n subclasses=(1, 3)):\n mask_shape = mask_image.shape\n sub_mask = generate_image(mask_shape[0], mask_shape[1], color=0)\n if mask_image.ndim == 2:\n gray_mask_image = mask_image[:, :]\n else:\n gray_mask_image = mask_image[:, :, 0]\n \n if isinstance(subclasses, (list, tuple)):\n if len(subclasses) == 2:\n keep_bool = np.logical_or(gray_mask_image == subclasses[0], gray_mask_image == subclasses[1])\n else:\n keep = []\n for subclass in subclasses:\n keep.append(gray_mask_image == subclass)\n\n keep_bool = np.logical_or.reduce(tuple(keep))\n else:\n keep_bool = (gray_mask_image == subclasses)\n\n sub_mask[keep_bool] = 1\n\n return sub_mask","def combine_all(self):\n if self._train_only:\n return\n\n combined = copy.deepcopy(self.train)\n\n # relabel pids in gallery (query shares the same scope)\n g_pids = set()\n for items in self.gallery:\n pid = items[1]\n if pid in self._junk_pids:\n continue\n g_pids.add(pid)\n pid2label = {pid: i for i, pid in enumerate(g_pids)}\n\n def _combine_data(data):\n for img_path, pid, camid, dsetid in data:\n if pid in self._junk_pids:\n continue\n pid = pid2label[pid] + self.num_train_pids\n combined.append((img_path, pid, camid, dsetid))\n\n _combine_data(self.query)\n _combine_data(self.gallery)\n\n self.train = combined\n self.num_train_pids = self.get_num_pids(self.train)","def set_config_layers_by_class(self, class_name, **items):\n for layer in self._layers:\n if layer.__class__.__name__.lower().startswith(class_name.lower()):\n self.set_config_layer(layer.name, **items)","def n_classes(self):\n raise NotImplementedError","def n_classes(self):\n raise NotImplementedError","def get_classes(self):\n out_classes = ()\n classes = super(NamedEntityRecognizerModel, self).get_classes()\n\n for c in classes:\n out_classes += (c[:2],)\n\n return ((self.outside_class, self.outside_class_display),) + out_classes","def one_hot_encode_soy(soy_data, classes):\n\n print('[ INFO ]: One-hot-encoding soy data...')\n\n for col in soy_data.columns:\n if col not in ['index', 'attr_35']:\n\n # Find the min and max values in each column to account for all values\n col_min = min(soy_data[col])\n col_max = max(soy_data[col]) + 1\n for u in range(col_min, col_max):\n soy_data[col + '_' + str(u)] = (soy_data[col] == u).astype(int)\n soy_data = soy_data.drop(col, axis=1)\n if col == 'attr_35':\n\n # Create new columns for each unique class\n for u in soy_data[col].unique():\n soy_data['{}_class'.format(u)] = np.where(soy_data[col] == u, 1, 0)\n classes = np.char.replace(classes, u, u + '_class')\n soy_data = soy_data.drop(col, axis=1)\n\n return soy_data, classes","def __init__(self, classes, alpha=1.0):\n self.alpha_ = alpha\n self.classes_ = classes.tolist()\n self.class_counts_ = self.alpha_*np.ones(len(self.classes_))\n self.features_ = []","def change_class_labels_to_given(classes,given):\n classes=np.asarray(classes)\n classes_new=np.zeros(classes.shape,dtype=object)\n for i in given:\n classes_new[classes==i]=given[i]\n return classes_new","def mix_labellers(labellers, class_name=\"MixtureLabeller\"):\n return type(class_name, labellers, {})","def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):\n box_list = [b for b in cls_boxes if len(b) > 0]\n if len(box_list) > 0:\n boxes = np.concatenate(box_list)\n else:\n boxes = None\n if cls_segms is not None:\n segms = [s for slist in cls_segms for s in slist]\n else:\n segms = None\n if cls_keyps is not None:\n keyps = [k for klist in cls_keyps for k in klist]\n else:\n keyps = None\n classes = []\n for j in range(len(cls_boxes)):\n classes += [j] * len(cls_boxes[j])\n return boxes, segms, keyps, classes","def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):\n box_list = [b for b in cls_boxes if len(b) > 0]\n if len(box_list) > 0:\n boxes = np.concatenate(box_list)\n else:\n boxes = None\n if cls_segms is not None:\n segms = [s for slist in cls_segms for s in slist]\n else:\n segms = None\n if cls_keyps is not None:\n keyps = [k for klist in cls_keyps for k in klist]\n else:\n keyps = None\n classes = []\n for j in range(len(cls_boxes)):\n classes += [j] * len(cls_boxes[j])\n return boxes, segms, keyps, classes","def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):\n box_list = [b for b in cls_boxes if len(b) > 0]\n if len(box_list) > 0:\n boxes = np.concatenate(box_list)\n else:\n boxes = None\n if cls_segms is not None:\n segms = [s for slist in cls_segms for s in slist]\n else:\n segms = None\n if cls_keyps is not None:\n keyps = [k for klist in cls_keyps for k in klist]\n else:\n keyps = None\n classes = []\n for j in range(len(cls_boxes)):\n classes += [j] * len(cls_boxes[j])\n return boxes, segms, keyps, classes","def class_labels(self):\n return self._class_labels","def n_classes(self):\n raise NotImplementedError()","def __init__(self):\n self.label = \"Combine NNOutput Files \"\n self.description = \"Combines PNN, FUZ, and RBN files generated from partitions of the class.dta file.\"\n self.canRunInBackground = False\n self.category = \"Neural network\"","def _classifier(self, classes):\n # Initialize key variables\n pseudo = np.linalg.pinv(self.data)\n result = np.dot(pseudo, classes)\n return result","def prepare(self, class_map=None):\n\n def clean_name(name):\n \"\"\"Returns a shorter version of object names for cleaner display.\"\"\"\n return \",\".join(name.split(\",\")[:1])\n\n # Build (or rebuild) everything else from the info dicts.\n self.num_classes = len(self.class_info)\n self.class_ids = np.arange(self.num_classes)\n self.class_names = [clean_name(c[\"name\"]) for c in self.class_info]\n self.num_images = len(self.image_info)\n self._image_ids = np.arange(self.num_images)\n\n # Mapping from source class and image IDs to internal IDs\n self.class_from_source_map = {\"{}.{}\".format(info['source'], info['id']): id\n for info, id in zip(self.class_info, self.class_ids)}\n self.image_from_source_map = {\"{}.{}\".format(info['source'], info['id']): id\n for info, id in zip(self.image_info, self.image_ids)}\n\n # Map sources to class_ids they support\n self.sources = list(set([i['source'] for i in self.class_info]))\n self.source_class_ids = {}\n # Loop over datasets\n for source in self.sources:\n self.source_class_ids[source] = []\n # Find classes that belong to this dataset\n for i, info in enumerate(self.class_info):\n # Include BG class in all datasets\n if i == 0 or source == info['source']:\n self.source_class_ids[source].append(i)","def set_sclasses(self, w: Wrapper, classes: Any) -> None:\n w.setProperty(self.style_sclass_property, f\" {' '.join(set(classes))} \")","def classes(self):\n raise NotImplementedError(\"Please implement this yourself.\")","def __multilabel_processing(self):\n # read the raw dataset\n self.data['image_name'] = self.data['image_name'].map(lambda x: '{}.{}'.format(x, img_format))\n self.data['tags'] = self.data['tags'].map(lambda x: x.split())\n\n # create a df with the same number of rows as the dataset filled with the name of the unique values in tags\n label_names = self.data['tags'].explode().unique().tolist()\n label_df = pd.DataFrame([label_names] * self.data.shape[0], columns=label_names)\n\n # binarize the labels according to if they exist for each image or not\n self.data = pd.concat([self.data, label_df], axis=1)\n self.data[['image_name'] + label_names] = self.data.apply(lambda x: pd.Series([x[0]] + [1 if label in x[1] else 0 for label in x[2:]]), axis=1)","def __init__(\n self, \n dim_feat_raw, \n dim_feat_smooth, \n dim_label_raw, \n dim_label_smooth, \n arch_gnn, \n aug_feat,\n num_ensemble, \n train_params\n ):\n super().__init__()\n self.mulhead = 1\n self.num_layers = arch_gnn[\"num_layers\"]\n self.dropout, self.dropedge = train_params[\"dropout\"], train_params['dropedge']\n self.mulhead = int(arch_gnn[\"heads\"]) # only useful for GAT\n\n self.branch_sharing = arch_gnn['branch_sharing'] # only for ensemble\n\n self.type_feature_augment = aug_feat\n assert dim_feat_raw <= dim_feat_smooth, \"smoothened feature cannot have smaller shape than the original one\"\n # NOTE: dim_label_raw may be larger than dim_label_smooth ==> label is not used as input\n self.num_classes = dim_label_raw\n self.dim_label_in = dim_label_smooth\n self.dim_feat_in = dim_feat_smooth\n self.dim_hidden = arch_gnn['dim']\n # build the model below\n dim, act = arch_gnn['dim'], arch_gnn['act']\n self.aug_layers, self.conv_layers, self.res_pool_layers = [], [], []\n for i in range(num_ensemble):\n # feat aug\n if len(self.type_feature_augment) > 0:\n self.aug_layers.append(nn.ModuleList(\n nn.Linear(_dim, self.dim_feat_in) for _, _dim in self.type_feature_augment\n ))\n # graph convs\n convs = []\n if i == 0 or not self.branch_sharing:\n for j in range(arch_gnn['num_layers']):\n cls_gconv = DeepGNN.NAME2CLS[arch_gnn['aggr']]\n dim_in = (self.dim_feat_in + self.dim_label_in) if j == 0 else dim\n convs.append(cls_gconv(dim_in, dim, dropout=self.dropout, act=act, mulhead=self.mulhead))\n self.conv_layers.append(nn.Sequential(*convs))\n else: # i > 0 and branch_sharing\n self.conv_layers.append(self.conv_layers[-1])\n # skip-pooling layer\n type_res = arch_gnn['residue'].lower()\n type_pool = arch_gnn['pooling'].split('-')[0].lower()\n cls_res_pool = layers.ResPool\n args_pool = {}\n if type_pool == 'sort':\n args_pool['k'] = int(arch_gnn['pooling'].split('-')[1])\n self.res_pool_layers.append(\n cls_res_pool(dim, dim, arch_gnn['num_layers'], type_res, type_pool,\n dropout=self.dropout, act=act, args_pool=args_pool\n ))\n if len(self.aug_layers) > 0:\n self.aug_layers = nn.ModuleList(self.aug_layers)\n self.conv_layers = nn.ModuleList(self.conv_layers)\n self.res_pool_layers = nn.ModuleList(self.res_pool_layers)\n # ------- ensembler + classifier -------\n if num_ensemble == 1:\n self.ensembler = layers.EnsembleDummy()\n else:\n self.ensembler = layers.EnsembleAggregator(dim, dim, num_ensemble, dropout=self.dropout, \n type_dropout=train_params[\"ensemble_dropout\"], act=arch_gnn[\"ensemble_act\"])\n self.classifier = DeepGNN.NAME2CLS['mlp'](dim, self.num_classes, act='I', dropout=0.)\n # ---- optimizer, etc. ----\n self.lr = train_params[\"lr\"]\n self.sigmoid_loss = arch_gnn[\"loss\"] == \"sigmoid\"\n self.loss, self.opt_op = 0, None\n self.optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)\n\n self.num_ensemble = num_ensemble","def class_and_replace(org_label, classes):\r\n # Classify and replace\r\n keys = np.unique(org_label)\r\n values = classes #0 for non veg, 1 for veg\r\n dictionary = dict(zip(keys, values))\r\n classified = replace(org_label, dictionary)\r\n \r\n # Label merged regions with unique ID\r\n labeld = label(classified)\r\n number_of_labels = np.unique(labeld)\r\n newvals = np.asarray(list(range(1,(len(number_of_labels) + 1))))\r\n keys_ID = number_of_labels\r\n values_ID = newvals\r\n dictionary_ID = dict(zip(keys_ID, values_ID))\r\n classified_ID = replace(labeld, dictionary_ID)\r\n \r\n del(labeld)\r\n \r\n return classified, classified_ID","def draw_all_labels(df,root_folder_path,root_folder_name,logger):\n # df=df[df.type==\"Color\"]\n len_images=df['file_id'].nunique()\n perc_list=[i*0.05 for i in range(0,20,1)]\n grouped_df=df.groupby(['file_id','class'])\n coordinate_names=['x_max','x_min','y_max','y_min']\n group_len=len(grouped_df)\n\n class_label_dict={}\n label_info_list=[]\n for ind,(name, group) in enumerate(grouped_df):\n img_name,class_name=name\n img_type=group['type'].values[0]\n bb_list=group[coordinate_names].values.astype(int)\n if class_name not in class_label_dict.keys():\n class_label_dict[class_name]=get_random_color()\n bb_color=class_label_dict[class_name]\n label_info_list.append([img_name,img_type,class_name,bb_color,bb_list])\n draw_label_on_image(root_folder_path,root_folder_name,img_name,img_type,class_name,bb_color,bb_list)\n perc=float(\"{:.2f}\".format((ind+1)/group_len))\n if perc in perc_list:\n perc_list.remove(perc)\n logger.write(\"Classes annotated: \"+str(ind+1)+\"/\"+str(group_len))\n # print(\"Label list generated.\")\n # pool = Pool(1)\n # pool.starmap(draw_label_on_one_image, zip(\n # label_info_list, itertools.repeat(root_folder_path), itertools.repeat(root_folder_name)))\n # pool.close()\n # pool.join()\n # print(\"Drawing labels is finished.\")","def compute_mask_class(y_true: Tensor):\n batch_size = y_true.size(0)\n num_classes = y_true.size(1)\n if num_classes == 1:\n y_true = y_true.view(batch_size, -1)\n elif num_classes == 2:\n y_true = y_true[:, 1, ...].contiguous().view(batch_size, -1) # Take salt class\n else:\n raise ValueError('Unknown num_classes')\n\n img_area = float(y_true.size(1))\n percentage = y_true.sum(dim=1) / img_area\n class_index = (percentage * 4).round().byte()\n return class_index","def classesAndFrames(self):\n classes = defaultdict(int)\n with open(self.inputfile) as fin:\n for line in fin:\n arr = line.strip().split()\n y = int(arr[1])\n classes[y] += 1\n return classes","def __init__(self, num_classes):\n super(VGG16, self).__init__()\n self.vgg16_feature_extractor = VGG16FeatureExtraction(weights_update=True)\n self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)\n self.classifier = VGG16Classfier()\n self.fc3 = _fc(in_channels=4096, out_channels=num_classes)","def create_classification_graf(\n inputs,\n num_classes,\n pyramid_feature_size=256,\n classification_feature_size=256,\n name='classification_submodel'\n):\n options = {\n 'kernel_size': 3,\n 'strides': 1,\n 'padding': 'same',\n }\n outputs = inputs\n for i in range(4):\n outputs = keras.layers.Conv2D(\n filters=classification_feature_size,\n activation='relu',\n name='pyramid_classification_{}'.format(i),\n kernel_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None),\n bias_initializer='zeros',\n **options\n )(outputs)\n\n outputs = keras.layers.Conv2D(\n filters=num_classes,\n #activation='relu',\n kernel_initializer=keras.initializers.zeros(),\n bias_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None), #initializers.PriorProbability(probability=prior_probability),\n name='pyramid_classification',\n **options\n )(outputs)\n\n outputs = keras.layers.Activation('sigmoid', name='pyramid_classification_sigmoid')(outputs)\n\n return outputs","def __init__(self, in_channels=3, in_channels1=3, n_classes=21):\n super(SegNet, self).__init__()\n\n self.layer_1 = SegnetLayer_Encoder(in_channels, 64, 2)\n self.layer_2 = SegnetLayer_Encoder(64, 128, 2)\n self.layer_3 = SegnetLayer_Encoder(128, 256, 3)\n self.layer_4 = SegnetLayer_Encoder(256, 512, 3)\n self.layer_5 = SegnetLayer_Encoder(512, 512, 3)\n\n self.layer_6 = SegnetLayer_Decoder(512, 512, 3)\n self.layer_7 = SegnetLayer_Decoder(512, 256, 3)\n self.layer_8 = SegnetLayer_Decoder(256, 128, 3)\n self.layer_9 = SegnetLayer_Decoder(128, 64, 2)\n self.layer_10 = SegnetLayer_Decoder(64, n_classes, 2)\n\n self.layer_11 = SegnetLayer_Encoder(in_channels1, 64, 2)\n self.layer_12 = SegnetLayer_Encoder(64, 128, 2)\n self.layer_13 = SegnetLayer_Encoder(128, 256, 3)\n self.layer_14 = SegnetLayer_Encoder(256, 512, 3)\n self.layer_15 = SegnetLayer_Encoder(512, 512, 3)\n\n self.layer_16 = SegnetLayer_Decoder(512, 512, 3)\n self.layer_17 = SegnetLayer_Decoder(512, 256, 3)\n self.layer_18 = SegnetLayer_Decoder(256, 128, 3)\n self.layer_19 = SegnetLayer_Decoder(128, 64, 2)\n self.layer_110 = SegnetLayer_Decoder(64, n_classes, 2)\n\n self.layer_1110 = UNet_Decoder_Particular(n_classes * 2, n_classes)","def set_hypercubes_classes(self):\n print(\"Setting the Hypercubes' classes of grid at level: \" + str(self.level))\n for hypercube in self.hypercubes.flatten():\n coordinates = []\n for coord in hypercube.coords:\n coordinates.append([2 * coord, 2 * coord + 1])\n parents_list = []\n for indices in list(itertools.product(*coordinates)):\n parents_list.append(self.parent_hypercubes[tuple(reversed(indices))])\n hypercube.set_lower_level_hypercube_class(parent_hypercubes=parents_list, threshold=self.threshold)\n if self.child_grid:\n self.child_grid.set_hypercubes_classes()","def reconcile(self):\r\n\t\tclass_A = np.empty((self.basis.nK,self.basis.nK),float)\r\n\t\tclass_G = np.empty((self.basis.nK,self.basis.nK),float)\r\n\t\tclass_koop = np.empty((self.basis.nK,self.basis.nK),float)\r\n\t\tclass_num = len(self.koop_cluster_list)\r\n\t\tfor i in range(class_num):\r\n\t\t\tclass_mem_num = len(self.koop_cluster_list[i])\r\n\t\t\tclass_counter = 0.0\r\n\t\t\tfor j in range(class_mem_num):\r\n\t\t\t\tclass_A += (self.koop_cluster_list[i][j]._A*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\r\n\t\t\t\tclass_G += (self.koop_cluster_list[i][j]._G*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\r\n\t\t\t\tclass_counter += self.koop_cluster_list[i][j].counter\r\n\t\t\tclass_koop = np.dot(np.linalg.pinv(class_G),class_A)\r\n\t\t\tself.koopman_hybrid_modes.append(KoopmanOperator(self.basis, class_koop, class_A, class_G, class_counter))","def nms_per_class(box_data, nms_thresh=.45, conf_thresh=0.01, top_k=200):\n decoded_boxes, class_predictions = box_data[:, :4], box_data[:, 4:]\n num_classes = class_predictions.shape[1]\n output = np.zeros((num_classes, top_k, 5))\n\n # skip the background class (start counter in 1)\n for class_arg in range(1, num_classes):\n conf_mask = class_predictions[:, class_arg] >= conf_thresh\n scores = class_predictions[:, class_arg][conf_mask]\n if len(scores) == 0:\n continue\n boxes = decoded_boxes[conf_mask]\n indices, count = apply_non_max_suppression(\n boxes, scores, nms_thresh, top_k)\n scores = np.expand_dims(scores, -1)\n selected_indices = indices[:count]\n selections = np.concatenate(\n (boxes[selected_indices], scores[selected_indices]), axis=1)\n output[class_arg, :count, :] = selections\n return output","def rij(self):\n for i, c in zip(range(len(self.classes)), self.classes):\n print(\"[\" + str(i+1) + \"] \" + repr(c)) #+ \" --- \" + str(c) ","def num_classes():\n return NUM_CLASSES","def preprocess(self):\n print(\"processing content images...\")\n for dir_item in self.selectedContent:\n join_path = Path(self.content_image_dir,dir_item.replace('/','_'))\n if join_path.exists():\n print(\"processing %s\"%dir_item,end='\\r')\n images = join_path.glob('*.%s'%(self.subffix))\n for item in images:\n self.content_dataset.append(item)\n else:\n print(\"%s dir does not exist!\"%dir_item,end='\\r')\n label_index = 0\n print(\"processing style images...\")\n for class_item in self.selectedStyle:\n images = Path(self.style_image_dir).glob('%s/*.%s'%(class_item, self.subffix))\n for item in images:\n self.art_dataset.append([item, label_index])\n label_index += 1\n random.seed(self.random_seed)\n random.shuffle(self.content_dataset)\n random.shuffle(self.art_dataset)\n # self.dataset = images\n print('Finished preprocessing the Art Works dataset, total image number: %d...'%len(self.art_dataset))\n print('Finished preprocessing the Content dataset, total image number: %d...'%len(self.content_dataset))","def decode_labels(mask, num_images=1, num_classes=21, task='seg'):\n n, h, w, c = mask.shape\n assert (n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (n, num_images)\n outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)\n for i in range(num_images):\n if task == 'normal':\n outputs[i] = mask[i]\n elif task == 'seg':\n img = Image.new('RGB', (w, h), (255, 255, 255)) # unlabeled part is white (255, 255, 255)\n pixels = img.load()\n for j_, j in enumerate(mask[i, :, :, 0]):\n for k_, k in enumerate(j):\n if k < num_classes:\n pixels[k_, j_] = label_colours[k]\n outputs[i] = np.array(img)\n else:\n raise Exception('task name is not recognized!')\n\n return outputs","def get_class_labels(self):\r\n \r\n y = self.get_data()['y']\r\n if type(y) == torch.Tensor:\r\n return y.unique().numpy()\r\n else:\r\n return sorted(list(set(y)))","def create_heads(x, upsample_feature, num_classes, hg_id, num_channels):\n hg_name = 'hg' + str(hg_id)\n\n head = Conv2D(num_channels, kernel_size=(1, 1), activation='relu', padding='same', name=hg_name+'_conv_1x1_1')(upsample_feature)\n head = BatchNormalization()(head)\n\n # for head as intermediate supervision, use 'linear' as activation.\n head_predict = Conv2D(num_classes, kernel_size=(1, 1), activation='linear', padding='same',\n name=hg_name+'_conv_1x1_predict')(head)\n\n # use linear activation\n head = Conv2D(num_channels, kernel_size=(1, 1), activation='linear', padding='same',\n name=hg_name+'_conv_1x1_2')(head)\n head_m = Conv2D(num_channels, kernel_size=(1, 1), activation='linear', padding='same',\n name=hg_name+'_conv_1x1_3')(head_predict)\n\n # merge heads for next stage\n head_next_stage = Add()([head, head_m, x])\n\n return head_next_stage, head_predict","def __init__(self, classes, smoothing=0.0, dim=-1, weight = None):\n super(LabelSmoothingLoss, self).__init__()\n self.confidence = 1.0 - smoothing\n self.smoothing = smoothing\n self.weight = weight\n self.cls = classes\n self.dim = dim"],"string":"[\n \"def merge_class_labels(classes,group):\\n classes=np.asarray(classes)\\n if (classes.dtype != int) and (classes.dtype != 'int64') and (classes.dtype != 'int32'):\\n classes_merged=np.zeros(classes.shape,dtype=object)\\n for subgroup in group:\\n subgroup_label='+'.join(subgroup)\\n for member in subgroup:\\n classes_merged[classes==member]=subgroup_label\\n else: # int class labels\\n classes_merged=np.zeros(classes.shape,dtype=int)\\n for i in range(len(group)):\\n subgroup=group[i]\\n for member in subgroup:\\n classes_merged[classes==member]=i\\n \\n return classes_merged\",\n \"def reset_class(self, classes):\\r\\n self._clear_cached_op()\\r\\n self._classes = classes\\r\\n if self._pos_iou_thresh >= 1:\\r\\n self._target_generator = YOLOV3TargetMerger(len(classes), self._ignore_iou_thresh)\\r\\n for outputs in self.yolo_outputs:\\r\\n outputs.reset_class(classes)\",\n \"def _absorb_classes(self, ground_to='in'):\\n # Find number of new class for inside and outside set\\n currnt_classes = np.unique(self.classes)\\n new_class_in = currnt_classes.max() + 1\\n new_class_out = currnt_classes.max() + 2\\n \\n # Ground node to new_class\\n if ground_to == 'in':\\n self.classes[self.ground_node] = new_class_in\\n elif ground_to == 'out':\\n self.classes[self.ground_node] = new_class_out\\n else:\\n self.classes[self.ground_node] = -1\\n \\n cond_out = self.x[:self.ground_node] > self.threshold\\n self.classes[:self.ground_node][cond_out] = new_class_out\\n cond_out = self.x[self.ground_node:] > self.threshold\\n self.classes[self.ground_node+1:][cond_out] = new_class_out\\n \\n cond_in = self.x[self.ground_node:] <= self.threshold\\n self.classes[self.ground_node+1:][cond_in] = new_class_in\\n cond_in = self.x[:self.ground_node] <= self.threshold\\n self.classes[:self.ground_node][cond_in] = new_class_in\",\n \"def __init__(self, in_classes=1, channelscale=64):\\n super(DetectPatchAndSegm, self).__init__()\\n self.unetvgg1 = UNetSimple(in_classes=in_classes, channelscale=64, out_classes=2)#UNetVgg()\\n self.unetvgg2 = UNetSimple(in_classes=3, channelscale=128, out_classes=3)#in is 2 patches and original image\\n self.sft = nn.Softmax2d()\",\n \"def finalize_class_set(self) -> None:\\n logger.info(\\\"We have {} distinct classes, let's cluster it!\\\", len(self.classes))\\n\\n logger.debug(\\\"Created a cluster instance {} and this will cluster {} samples\\\", self.cluster, self.classes)\\n try:\\n assigned_clusters = self.cluster.cluster(vectors=[self.convert_str_list_to_vector(c) for c in self.classes],\\n assign_clusters=True, trace=not execute_on_ssh_compute)\\n except Exception:\\n logger.exception(\\\"Failed to cluster the actual class set ({} samples)\\\", len(self.classes))\\n return\\n\\n self.classes_to_one_hot_encode_dict.clear()\\n for i in range(len(self.classes)):\\n self.classes_to_one_hot_encode_dict[self.classes[i]] = assigned_clusters[i]\",\n \"def increment_classes(self, num_classes):\\n # Record number of input and output features for existing network\\n in_features = self.model.fc.in_features\\n out_features = self.model.fc.out_features\\n # Record weight and bias values\\n weight = self.model.fc.weight.data\\n bias = self.model.fc.bias.data\\n\\n # If first task\\n if self.seen_classes == 0:\\n new_out_features = num_classes\\n else:\\n # Extend fc layer by number of new classes\\n new_out_features = out_features + num_classes\\n\\n # Create new fc layer for the network\\n self.model.fc = nn.Linear(in_features, new_out_features)\\n\\n # Init as per LwF paper\\n kaiming_normal_init(self.model.fc.weight)\\n # Reassign recorded weight and bias values to new layer\\n self.model.fc.weight.data[:out_features] = weight\\n self.model.fc.bias.data[:out_features] = bias\\n # Increment number of classes\\n self.n_classes += num_classes\",\n \"def class2color(self, labels, clean_up_clusters=0, mode=None):\\n clean_up_clusters *= clean_up_clusters # create an area\\n colored_labels = np.zeros(labels.shape[:2] + (3,)).astype(np.uint8)\\n labels = np.squeeze(labels)\\n if clean_up_clusters > 0:\\n labels = DropClusters.drop(labels, min_size=clean_up_clusters)\\n ys, xs = np.where(labels)\\n colored_labels[ys, xs, :] = self.label_color\\n return colored_labels\",\n \"def get_classes_with_colors(self):\\n i = 0\\n out_classes = ()\\n classes = super(NamedEntityRecognizerModel, self).get_classes()\\n\\n for c in classes:\\n if len(c) != 3:\\n c += (self.default_colors[i],)\\n i += 1\\n out_classes += (c,)\\n\\n return (\\n (self.outside_class, self.outside_class_display, self.outside_color),\\n ) + out_classes\",\n \"def thing_classes(self):\\n return [Wall, Gold, Pit, Agent]\",\n \"def change_class_labels_back(classes,given):\\n classes=np.asarray(classes)\\n classes_new=np.zeros(classes.shape,dtype=object)\\n for i in range(len(given)):\\n classes_new[classes==i]=given[i]\\n return classes_new\",\n \"def encodeToLabels(self, gt_instances):\\n raw_boxes_xyzwhd = np.zeros((self.config_data[\\\"max_boxes_per_frame\\\"], 7))\\n ### initialize gronud truth labels as np.zeors ###\\n gt_labels = np.zeros(list(self.headoutput_shape[1:4]) + \\\\\\n [len(self.anchor_boxes)] + \\\\\\n [len(self.config_data[\\\"all_classes\\\"]) + 7])\\n\\n ### start transferring box to ground turth label format ###\\n for i in range(len(gt_instances[\\\"classes\\\"])):\\n if i > self.config_data[\\\"max_boxes_per_frame\\\"]:\\n continue\\n class_name = gt_instances[\\\"classes\\\"][i]\\n box_xyzwhd = gt_instances[\\\"boxes\\\"][i]\\n class_id = self.config_data[\\\"all_classes\\\"].index(class_name)\\n if i < self.config_data[\\\"max_boxes_per_frame\\\"]:\\n raw_boxes_xyzwhd[i, :6] = box_xyzwhd\\n raw_boxes_xyzwhd[i, 6] = class_id\\n class_onehot = helper.smoothOnehot(class_id, len(self.config_data[\\\"all_classes\\\"]))\\n \\n exist_positive = False\\n\\n grid_strid = self.grid_strides\\n anchor_stage = self.anchor_boxes\\n box_xyzwhd_scaled = box_xyzwhd[np.newaxis, :].astype(np.float32)\\n box_xyzwhd_scaled[:, :3] /= grid_strid\\n anchorstage_xyzwhd = np.zeros([len(anchor_stage), 6])\\n anchorstage_xyzwhd[:, :3] = np.floor(box_xyzwhd_scaled[:, :3]) + 0.5\\n anchorstage_xyzwhd[:, 3:] = anchor_stage.astype(np.float32)\\n\\n iou_scaled = helper.iou3d(box_xyzwhd_scaled, anchorstage_xyzwhd, \\\\\\n self.input_size)\\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\\n ### should be taken into consideration as a ground truth label\\n iou_mask = iou_scaled > 0.3\\n\\n if np.any(iou_mask):\\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\\\\n astype(np.int32)\\n ### TODO: consider changing the box to raw yolohead output format ###\\n gt_labels[xind, yind, zind, iou_mask, 0:6] = box_xyzwhd\\n gt_labels[xind, yind, zind, iou_mask, 6:7] = 1.\\n gt_labels[xind, yind, zind, iou_mask, 7:] = class_onehot\\n exist_positive = True\\n\\n if not exist_positive:\\n ### NOTE: this is the normal one ###\\n ### it means take the anchor box with maximum iou to the raw\\n ### box as the ground truth label\\n anchor_ind = np.argmax(iou_scaled)\\n xind, yind, zind = np.floor(np.squeeze(box_xyzwhd_scaled)[:3]).\\\\\\n astype(np.int32)\\n gt_labels[xind, yind, zind, anchor_ind, 0:6] = box_xyzwhd\\n gt_labels[xind, yind, zind, anchor_ind, 6:7] = 1.\\n gt_labels[xind, yind, zind, anchor_ind, 7:] = class_onehot\\n\\n has_label = False\\n for label_stage in gt_labels:\\n if label_stage.max() != 0:\\n has_label = True\\n gt_labels = [np.where(gt_i == 0, 1e-16, gt_i) for gt_i in gt_labels]\\n return gt_labels, has_label, raw_boxes_xyzwhd\",\n \"def _add_class_assignments(self, roidb):\\n for entry in roidb:\\n gt_overlaps = entry['gt_overlaps'].toarray()\\n # max overlap with gt over classes (columns)\\n max_overlaps = gt_overlaps.max(axis=1)\\n # gt class that had the max overlap\\n max_classes = gt_overlaps.argmax(axis=1)\\n entry['max_classes'] = max_classes\\n entry['max_overlaps'] = max_overlaps\\n # sanity checks\\n # if max overlap is 0, the class must be background (class 0)\\n zero_inds = np.where(max_overlaps == 0)[0]\\n assert all(max_classes[zero_inds] == 0)\\n # if max overlap > 0, the class must be a fg class (not class 0)\\n nonzero_inds = np.where(max_overlaps > 0)[0]\\n assert all(max_classes[nonzero_inds] != 0)\",\n \"def __init__(self, nfeat, nhid, nclass, dropout, alpha):\\n super(GCN, self).__init__()\\n self.dropout = dropout\\n\\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\\n \\n self.add_module('conv1', self.conv1)\\n\\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)\",\n \"def set_hypercubes_classes(self):\\n print(\\\"Setting the BaseGrid hypercubes' classes.\\\")\\n list_of_all_hc = list(self.hypercubes.flatten())\\n print(\\\"Number of hypercubes: \\\" + str(len(list_of_all_hc)))\\n for hypercube in list_of_all_hc:\\n hypercube.set_hypercube_class()\\n if self.child_grid:\\n self.child_grid.set_hypercubes_classes()\",\n \"def _get_cls_out_channels(self):\\n # Class numbers (k) + objectness (1)\\n return self.num_classes\",\n \"def _update_mask_attributes(self, sitk_im=None):\\n if sitk_im is None:\\n sitk_im = self.sitk_image\\n np_type = IMTYPE_2_NP[self.type]\\n array = self.get_array(sitk_im, np_type, isotropic=False)\\n unique, counts = np.unique(array, return_counts=True)\\n \\n num_classes = len(unique)\\n msg = (f'Given {self.num_classes} classes, but this mask has '\\n f'{num_classes} unique values!')\\n assert len(self._class_names) >= num_classes, msg\\n \\n # check if unique values match up with associated class values\\n given_vals = self._given_class_values\\n if given_vals is None or len(given_vals) == 0:\\n pre_msg = (f'During mask init, you gave no class_values, so it was '\\n f'defaulted to {self._class_values}. ')\\n else:\\n pre_msg = (f'During mask init, you gave these class_values: '\\n f'{self._class_values}.')\\n post_msg = (f'When loading the image, it contained values '\\n f'({unique}) that were not defined in \\\"class_values\\\".')\\n msg = pre_msg + post_msg\\n for unique_val in unique:\\n assert unique_val in self._class_values, msg\\n \\n class_counts = np.array([0] * self.num_classes)\\n for u, c in zip(unique, counts):\\n cid = self.class_values.index(u)\\n class_counts[cid] = c\\n self._class_counts = class_counts\\n \\n self._unique_values = unique\",\n \"def _add_class_assignments(self, rawdata):\\n gt_overlaps = rawdata['gt_overlaps'].toarray()\\n # max overlap with gt over classes (columns)\\n max_overlaps = gt_overlaps.max(axis=1)\\n # gt class that had the max overlap\\n max_classes = gt_overlaps.argmax(axis=1)\\n rawdata['max_classes'] = max_classes\\n rawdata['max_overlaps'] = max_overlaps\\n # sanity checks\\n # if max overlap is 0, the class must be background (class 0)\\n zero_inds = np.where(max_overlaps == 0)[0]\\n assert all(max_classes[zero_inds] == 0)\\n # if max overlap > 0, the class must be a fg class (not class 0)\\n nonzero_inds = np.where(max_overlaps > 0)[0]\\n assert all(max_classes[nonzero_inds] != 0)\",\n \"def merge_tiles_aug_rbboxes(aug_bboxes,\\n aug_labels,\\n img_metas,\\n merge_cfg,\\n classes=None):\\n recovered_bboxes = []\\n for bboxes, img_info in zip(aug_bboxes, img_metas):\\n img_shape = img_info[0]['img_shape']\\n scale_factor = img_info[0]['scale_factor']\\n flip = img_info[0]['flip']\\n tile_offset = img_info[0]['tile_offset']\\n bboxes[:, :-1] = rbbox_mapping_back(bboxes[:, :-1],\\n img_shape,\\n scale_factor,\\n flip,\\n tile_offset)\\n recovered_bboxes.append(bboxes)\\n global_bboxes = torch.cat(recovered_bboxes)\\n global_labels = torch.cat(aug_labels)\\n\\n nms_pre = merge_cfg.get('nms_pre', -1)\\n if nms_pre > 0 and global_bboxes.shape[0] > nms_pre:\\n _, topk_inds = global_bboxes[:, -1].topk(nms_pre)\\n global_bboxes = global_bboxes[topk_inds, :]\\n global_labels = global_labels[topk_inds]\\n\\n if isinstance(merge_cfg.nms['iou_thr'], dict):\\n assert classes is not None\\n iou_thr_dict = merge_cfg.nms['iou_thr']\\n merge_cfg.nms['iou_thr'] = [*map(lambda cls: iou_thr_dict.get(cls, 0.05), classes)]\\n\\n global_bboxes, global_labels = aug_multiclass_rnms(\\n global_bboxes,\\n global_labels,\\n merge_cfg.score_thr,\\n merge_cfg.nms,\\n merge_cfg.max_per_img)\\n return global_bboxes, global_labels\",\n \"def load_classes(self):\\n\\t\\t\\t# Load class names (name -> label).\\n\\t\\t\\tcategories = self.coco.loadCats(self.coco.getCatIds())\\n\\t\\t\\tcategories.sort(key=lambda x: x['id'])\\n\\n\\t\\t\\tself.classes = {}\\n\\t\\t\\tself.coco_labels = {}\\n\\t\\t\\tself.coco_labels_inverse = {}\\n\\t\\t\\tfor c in categories:\\n\\t\\t\\t\\tself.coco_labels[len(self.classes)] = c['id']\\n\\t\\t\\t\\tself.coco_labels_inverse[c['id']] = len(self.classes)\\n\\t\\t\\t\\tself.classes[c['name']] = len(self.classes)\\n\\n\\t\\t\\t# Also load the reverse (label -> name).\\n\\t\\t\\tself.labels = {}\\n\\t\\t\\tfor key, value in self.classes.items():\\n\\t\\t\\t\\tself.labels[value] = key\",\n \"def _update_classification_mask(self, obj_class, mask_coords):\\n # Remove background where object resides\\n self.classification_mask[0, mask_coords[1]:mask_coords[3], mask_coords[0]:mask_coords[2]] = 0\\n # Set classification mask where object resides\\n self.classification_mask[obj_class, mask_coords[1]:mask_coords[3], mask_coords[0]:mask_coords[2]] = 1\",\n \"def _load_classes(self):\\n\\t\\t# load class names (name -> label)\\n\\t\\tcategories = self.coco.loadCats(self.coco.getCatIds())\\n\\t\\tcategories.sort(key=lambda x: x['id'])\\n\\n\\t\\tself.classes \\t\\t\\t\\t= {}\\n\\t\\tself.coco_labels \\t\\t\\t= {}\\n\\t\\tself.coco_labels_inverse \\t= {}\\n\\t\\tfor c in categories:\\n\\t\\t\\tself.coco_labels[len(self.classes)] = c['id']\\n\\t\\t\\tself.coco_labels_inverse[c['id']] = len(self.classes)\\n\\t\\t\\tself.classes[c['name']] = len(self.classes)\\n\\t\\tself.labels = {}\\n\\t\\tfor key, value in self.classes.items():\\n\\t\\t\\tself.labels[value] = key\\n\\n\\t\\tprint(self.coco_labels)\\n\\t\\tprint(self.coco_labels_inverse)\\n\\t\\tprint(self.classes)\\n\\t\\tprint(self.labels)\",\n \"def class2onehot(class_labels, seq_len, batchsize, num_task):\\n\\n\\n one_hot = torch.FloatTensor(batchsize,seq_len,num_task)\\n one_hot.zero_()\\n one_hot = one_hot.scatter_(1, seq_len,class_labels, 1)\\n\\n return one_hot\",\n \"def classes(self):\\n if not hasattr(self, '_unique_classes'):\\n # build when we don't have\\n self._unique_classes = self.data['label'].unique()\\n self._unique_classes.sort()\\n\\n ret = self._unique_classes\\n return ret\",\n \"def first_nms(background_class, score_activation, threshold):\\r\\n # Identify Class Net and Box Net head names based on model type.\\r\\n if self.model == 'ssd_mobilenet_v2_keras':\\r\\n head_names = ['StatefulPartitionedCall/BoxPredictor/ConvolutionalClassHead_', \\r\\n 'StatefulPartitionedCall/BoxPredictor/ConvolutionalBoxHead_']\\r\\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \\r\\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \\r\\n self.model == 'ssd_resnet152_v1_fpn_keras'):\\r\\n head_names = ['StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalClassHead',\\r\\n 'StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalBoxHead']\\r\\n elif (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \\r\\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \\\"faster_rcnn_inception_resnet_v2_keras\\\"):\\r\\n head_names = ['StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalClassHead_0/ClassPredictor',\\r\\n 'StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor']\\r\\n\\r\\n class_net = None\\r\\n box_net = None\\r\\n\\r\\n # Getting SSD's Class and Box Nets final tensors.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n # Find the concat node at the end of the class net (multi-scale class predictor).\\r\\n class_net = find_head_end(head_names[0], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n\\r\\n # SSD's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\\r\\n slice_start = np.asarray([1], dtype=np.int64)\\r\\n slice_end = np.asarray([91], dtype=np.int64)\\r\\n # Second list element but third tensor dimension.\\r\\n slice_axes = np.asarray([2], dtype=np.int64)\\r\\n slice_out = self.graph.elt_const_slice(\\\"Slice\\\", head_names[0]+\\\"/slicer\\\", class_net.outputs[0], slice_start, slice_end, slice_axes)\\r\\n\\r\\n # Final Class Net tensor.\\r\\n class_net_tensor = slice_out[0]\\r\\n\\r\\n if self.model == 'ssd_mobilenet_v2_keras':\\r\\n # Find the squeeze node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n box_net_squeeze = self.graph.find_descendant_by_op(box_net, \\\"Squeeze\\\")\\r\\n box_net_output = box_net_squeeze.outputs[0]\\r\\n\\r\\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \\r\\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \\r\\n self.model == 'ssd_resnet152_v1_fpn_keras'):\\r\\n # Find the concat node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n box_net_output = box_net.outputs[0]\\r\\n\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output in order to get accurate coordinates.\\r\\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n scale_out = self.graph.elt_const(\\\"Mul\\\", head_names[1]+\\\"/scale\\\", box_net_output, scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n box_net_tensor = scale_out[0]\\r\\n \\r\\n # Getting Faster R-CNN's 1st Class and Box Nets tensors.\\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n if (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \\r\\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \\\"faster_rcnn_inception_resnet_v2_keras\\\"):\\r\\n # Find the softmax node at the end of the class net (multi-scale class predictor).\\r\\n class_net = find_head_end(head_names[0], \\\"Transpose\\\", \\\"Softmax\\\")\\r\\n\\r\\n # Final Class Net tensor\\r\\n class_net_tensor = class_net.outputs[0] \\r\\n\\r\\n # Find the reshape node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Reshape\\\")\\r\\n # Final Box Net tensor.\\r\\n box_net_output = box_net.outputs[0]\\r\\n\\r\\n #Insert a squeeze node\\r\\n squeeze_node = self.graph.squeeze(head_names[1]+\\\"/squeeze\\\", box_net_output)\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output, in order to get accurate coordinates.\\r\\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n scale_out = self.graph.elt_const(\\\"Mul\\\", head_names[1]+\\\"/scale\\\", squeeze_node, scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n box_net_tensor = scale_out[0]\\r\\n\\r\\n\\r\\n # 3. Find the split node that separates the box net coordinates and feeds them into the box decoder.\\r\\n box_net_split = self.graph.find_descendant_by_op(box_net, \\\"Split\\\")\\r\\n assert box_net_split and len(box_net_split.outputs) == 4\\r\\n\\r\\n # Set score threshold\\r\\n score_threshold = self.first_stage_nms_score_threshold if threshold is None else threshold\\r\\n\\r\\n # NMS Inputs and Attributes\\r\\n # NMS expects these shapes for its input tensors:\\r\\n # box_net: [batch_size, number_boxes, 4]\\r\\n # class_net: [batch_size, number_boxes, number_classes]\\r\\n # anchors: [1, number_boxes, 4] (if used)\\r\\n nms_op = None\\r\\n nms_attrs = None\\r\\n nms_inputs = None\\r\\n\\r\\n # EfficientNMS TensorRT Plugin is suitable for our use case.\\r\\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\\r\\n # three inputs are given to the NMS TensorRT node:\\r\\n # - The box predictions (from the Box Net node found above)\\r\\n # - The class predictions (from the Class Net node found above)\\r\\n # - The default anchor coordinates (from the extracted anchor constants)\\r\\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\\r\\n # because this is the internal box coding format used by the network.\\r\\n anchors_tensor = extract_anchors_tensor(box_net_split)\\r\\n nms_inputs = [box_net_tensor, class_net_tensor, anchors_tensor]\\r\\n nms_op = \\\"EfficientNMS_TRT\\\"\\r\\n nms_attrs = {\\r\\n 'plugin_version': \\\"1\\\",\\r\\n 'background_class': background_class,\\r\\n 'max_output_boxes': self.first_stage_max_proposals,\\r\\n 'score_threshold': max(0.01, score_threshold),\\r\\n 'iou_threshold': self.first_stage_nms_iou_threshold,\\r\\n 'score_activation': score_activation,\\r\\n 'box_coding': 1,\\r\\n }\\r\\n nms_output_classes_dtype = np.int32\\r\\n\\r\\n # NMS Outputs.\\r\\n nms_output_num_detections = gs.Variable(name=\\\"num_detections\\\", dtype=np.int32, shape=[self.batch_size, 1])\\r\\n nms_output_boxes = gs.Variable(name=\\\"detection_boxes\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\\r\\n nms_output_scores = gs.Variable(name=\\\"detection_scores\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n nms_output_classes = gs.Variable(name=\\\"detection_classes\\\", dtype=nms_output_classes_dtype,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n\\r\\n nms_outputs = [nms_output_num_detections, nms_output_boxes, nms_output_scores, nms_output_classes]\\r\\n\\r\\n # Create the NMS Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=nms_op,\\r\\n name=\\\"nms/non_maximum_suppression_first\\\",\\r\\n inputs=nms_inputs,\\r\\n outputs=nms_outputs,\\r\\n attrs=nms_attrs)\\r\\n log.info(\\\"Created NMS plugin '{}' with attributes: {}\\\".format(nms_op, nms_attrs))\\r\\n\\r\\n # If model type is SSD, then you are done with conversion and optimizations.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n self.graph.outputs = nms_outputs\\r\\n self.infer()\\r\\n return None\\r\\n # If model is Faster R-CNN, then you continue with conversion and optimizations,\\r\\n # next step is CropAndResize. \\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n return nms_outputs[1]\",\n \"def __init__(self, channels, num_classes):\\n super(AuxiliaryHead, self).__init__()\\n self.features = nn.Sequential(\\n nn.ReLU(inplace=True),\\n # image size = 2 x 2\\n nn.AvgPool2d(5, stride=3, padding=0, count_include_pad=False),\\n nn.Conv2d(channels, 128, 1, bias=False),\\n nn.BatchNorm2d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(128, 768, 2, bias=False),\\n nn.BatchNorm2d(768),\\n nn.ReLU(inplace=True),\\n )\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def update_class(self):\\n neighbors_set = list(set(self.neighbors))\\n counts = np.array([self.neighbors.count(n) for n in neighbors_set])\\n probs = (counts / counts.sum()) * (1-self.mutation_prob)\\n probs = np.append(probs, self.mutation_prob)\\n neighbors_set.append(np.random.choice(np.arange(1, self.board.classes))) \\n\\n self.cell_class = np.random.choice(neighbors_set, p=probs)\",\n \"def build(self, input_image, num_class):\\n x = build_resnet(101)\\n # add classifier\\n x = Conv2D(num_class, (1, 1), kernel_initializer='he_normal', activation='linear', padding='valid', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x)\",\n \"def assign_class_from_feature_annotation(feature_annotation_df):\\n print \\\"============Start assigning and encoding classes=================\\\"\\n print \\\"================thresholds=====================\\\"\\n walkthreshold = 0.3\\n ambithreshold = 0.25\\n phonethreshold = 0.3\\n computerthreshold = 0.3\\n activity_thresholds = [0.3,0.25,0.3,0.3,0.3,0.3,0.3,0.25]\\n activity_names = ['walking','eating','phone','computer','talking', 'reading','in car', 'drinking']\\n class_codes = [1,2,3,4,5,6,7,8]\\n activity_cols = [s_info.walkproportion_col,\\n s_info.eatproportion_col,\\n s_info.phoneproportion_col,\\n s_info.computerproportion_col,\\n s_info.talkproportion_col,\\n s_info.readproportion_col,\\n s_info.carproportion_col,\\n s_info.drinkproportion_col]\\n puff_with_puff_duration_threshold = 0.3\\n puff_with_segment_duration_threshold = 0.3\\n print \\\"walking: \\\" + str(walkthreshold)\\n print \\\"drinking/eating: \\\" + str(ambithreshold)\\n print \\\"phone: \\\" + str(phonethreshold)\\n print \\\"computer: \\\" + str(computerthreshold)\\n print \\\"puff: \\\" + str(puff_with_puff_duration_threshold) + \\\", \\\" + str(puff_with_segment_duration_threshold)\\n class_df = feature_annotation_df.copy(deep=True)\\n \\n # class assignment rules\\n class_df[s_info.classname_col] = 'others'\\n class_df[s_info.classnum_col] = 0\\n\\n for code, name, threshold, col in zip(class_codes, activity_names, activity_thresholds, activity_cols):\\n flag = class_df[col] >= threshold\\n class_df[s_info.classname_col][flag] = name\\n class_df[s_info.classnum_col][flag] = code\\n # for short window size\\n puff_flag1 = class_df[s_info.puff_with_segment_duration_col] >= puff_with_segment_duration_threshold\\n class_df[s_info.classname_col][puff_flag1] = 'puff'\\n class_df[s_info.classnum_col][puff_flag1] = len(class_codes) + 1\\n # for short puffs\\n puff_flag2 = class_df[s_info.puff_with_puff_duration_col] >= puff_with_puff_duration_threshold\\n class_df[s_info.classname_col][puff_flag2] = 'puff'\\n class_df[s_info.classnum_col][puff_flag2] = len(class_codes) + 1\\n return class_df\",\n \"def cut_classes(self, dataset, classes, max_size, label):\\n\\n # Cherry picked classes\\n class_dfs = []\\n for c in classes:\\n picked_data = dataset.loc[(dataset.loc[:,label] == c),:].reset_index(drop=True)\\n class_dfs.append(picked_data.loc[0:min(len(picked_data), max_size),:])\\n #class_dfs.append(picked_data.sample(n=min(len(picked_data), max_size)))\\n\\n # Concat\\n data = pd.concat(class_dfs)\\n return data\",\n \"def one_hot_encoding(mask: typing.Any, classes: typing.List[int]):\\n raise TypeError(\\\"Mask should be either np.ndarray of torch.Tensor\\\")\",\n \"def mask_classes(outputs: torch.Tensor, dataset: ContinualDataset, k: int) -> None:\\n outputs[:, 0:k * dataset.N_CLASSES_PER_TASK] = -float('inf')\\n outputs[:, (k + 1) * dataset.N_CLASSES_PER_TASK:\\n dataset.N_TASKS * dataset.N_CLASSES_PER_TASK] = -float('inf')\",\n \"def make_multilabel_target(num_classes, classes):\\n target = np.zeros(num_classes, dtype=np.uint8)\\n target[classes] = 1\\n return target\",\n \"def __init__(self, C, num_classes):\\n super(AuxiliaryHeadImageNet, self).__init__()\\n self.features = nn.Sequential(nn.ReLU(inplace=True), nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False), nn.Conv2d(C, 128, 1, bias=False), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 768, 2, bias=False), nn.ReLU(inplace=True))\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def shapeItToRFMixMultiClass(rfmix_admix, rfmix_ancestrals):\\n\\tprint rfmix_admix + \\\".haps\\\"\\n\\thapfile = open(rfmix_admix + \\\".haps\\\", \\\"r\\\")\\n\\tallele_file = open(rfmix_admix + \\\".alleles\\\", \\\"w\\\") # File that stores 10 haplotypes\\n\\tmapfile = open(rfmix_admix + \\\".amaps\\\", \\\"w\\\")\\n\\t# Need to keep track of population numbers here\\n\\t\\n\\thap_strings, alleles = readShapeItFile(hapfile)\\n\\tpop_nums = [0]*len(hap_strings[0]) # Add admixed ind codes to pop_numbers array\\n\\ti = 1\\n\\tfor thisanc in rfmix_ancestrals:\\n\\t\\tthisfile = open(thisanc + \\\".haps\\\", \\\"r\\\")\\n\\t\\tthis_haps, this_alleles = readShapeItFile(thisfile)\\n\\t\\tpop_nums.extend([i]*(len(this_haps[0])))\\n\\t\\tfor j in range(0,len(hap_strings)): \\n\\t\\t\\t# need to check if the alleles are flipped the same way\\n\\t\\t\\tif not checkPolarity(alleles[j], this_alleles[j]):\\n\\t\\t\\t\\tthis_haps[j] = flip10(this_haps[j])\\n\\t\\t\\thap_strings[j] += this_haps[j]\\n\\t\\ti += 1\\n\\t## Ok now I should have all the classes and haplotypes correctly\\n\\tclassout = open(rfmix_admix + \\\".classes\\\", \\\"w\\\")\\n\\tclassout.write(\\\" \\\".join(map(str,pop_nums)) + \\\"\\\\n\\\")\\n\\tallele_file.write(\\\"\\\\n\\\".join(hap_strings) + \\\"\\\\n\\\")\\n\\tfor a in alleles:\\n\\t\\tmapfile.write(\\\"\\\\t\\\".join(a) + \\\"\\\\n\\\")\\n\\tallele_file.close()\\n\\tclassout.close()\\n\\tmapfile.close()\\n\\treturn([allele_file.name, classout.name, mapfile.name])\",\n \"def _set_classifiers(self, clfs):\\n # tuple to guarantee immutability since we are asssigning\\n # __tags__ below and rely on having clfs populated already\\n self.__clfs = tuple(clfs) if clfs is not None else tuple()\\n \\\"\\\"\\\"Classifiers to use\\\"\\\"\\\"\\n\\n if len(clfs):\\n # enable corresponding ca in the slave-classifiers\\n if self.__propagate_ca:\\n for clf in self.__clfs:\\n clf.ca.enable(self.ca.enabled, missingok=True)\\n\\n # adhere to their capabilities + 'multiclass'\\n # XXX do intersection across all classifiers!\\n # TODO: this seems to be wrong since it can be regression etc\\n self.__tags__ = [ 'binary', 'multiclass', 'meta' ]\\n if len(clfs)>0:\\n self.__tags__ += self.__clfs[0].__tags__\",\n \"def get_shapes(self):\\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\\n X = []\\n backmap = {}\\n rad = 3\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\\n colours[i][j] = m\\n X.append(m)\\n backmap[k] = (i,j)\\n print(np.shape(X))\\n Z = linkage(X, 'ward')\\n Q = fcluster(Z, self.thresh, criterion='distance')\\n\\n closenesses = []\\n for k,cls in enumerate(Q):\\n i,j = backmap[k]\\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\\n minidx = np.argmin(closenesses)\\n bgcls = Q[minidx]\\n\\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\\n img4 = self.img2.copy()\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n cls = Q[k]\\n if cls == bgcls:\\n continue\\n col = blibs[(cls-1)]\\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\\n\\n write_img(\\\"./out/test_classes.png\\\", img4)\\n self.classimg = img4\\n\\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\\n mx = np.max(Q)\\n for k,cls in enumerate(Q):\\n if cls == bgcls:\\n continue\\n\\n if cls == mx:\\n plotcls = bgcls\\n else:\\n plotcls = cls\\n i,j = backmap[k]\\n A[i][j] = plotcls\\n\\n self.res = A\",\n \"def merge(self):\\n # Find which clusters/rows to merge\\n self.segsChanged = True\\n tomerge = []\\n i = 0\\n for cbox in self.cboxes:\\n if cbox.checkState() != 0:\\n tomerge.append(i)\\n i += 1\\n print('rows/clusters to merge are:', tomerge)\\n if len(tomerge) < 2:\\n return\\n\\n # Generate new class labels\\n nclasses = self.nclasses - len(tomerge) + 1\\n max_label = nclasses - 1\\n labels = []\\n c = self.nclasses - 1\\n while c > -1:\\n if c in tomerge:\\n labels.append((c, 0))\\n else:\\n labels.append((c, max_label))\\n max_label -= 1\\n c -= 1\\n\\n # print('[old, new] labels')\\n labels = dict(labels)\\n # print(labels)\\n\\n keys = [i for i in range(self.nclasses) if i not in tomerge] # the old keys those didn't merge\\n # print('old keys left: ', keys)\\n\\n # update clusters dictionary {ID: cluster_name}\\n clusters = {0: self.clusters[tomerge[0]]}\\n for i in keys:\\n clusters.update({labels[i]: self.clusters[i]})\\n\\n print('before update: ', self.clusters)\\n self.clusters = clusters\\n print('after update: ', self.clusters)\\n\\n self.nclasses = nclasses\\n\\n # update the segments\\n for seg in self.segments:\\n seg[-1] = labels[seg[-1]]\\n\\n # update the cluster combobox\\n #self.cmbUpdateSeg.clear()\\n #for x in self.clusters:\\n #self.cmbUpdateSeg.addItem(self.clusters[x])\\n\\n # Clean and redraw\\n self.clearButtons()\\n self.updateButtons()\\n self.completeChanged.emit()\",\n \"def _add_basic_classifier_combined(model_1, model_2):\\n dropout = None\\n if model_1._dropout:\\n dropout = model_1._dropout.p\\n return BasicClassifierCombined(\\n vocab=model_1.vocab,\\n text_field_embedder=model_1._text_field_embedder,\\n seq2vec_encoder=model_1._seq2vec_encoder,\\n feedforward=model_1._feedforward,\\n dropout=dropout,\\n num_labels=model_1._num_labels,\\n )\",\n \"def update_categorical_feats(self):\\n common_feats = self.get_common_features()\\n self.categorical_feats = list(set(self.categorical_feats).intersection(common_feats))\",\n \"def __init__(self, num_classes):\\n super().__init__()\\n # maintains size of 128x128\\n self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1)\\n # maintains size of 64x64\\n self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)\\n # Half size\\n self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\\n # Original image of size 128x128 is halved twice to 32 * 32. With 64 channels flattened is 32 * 32 * 64\\n self.fc1 = nn.Linear(32 * 32 * 64, 1000)\\n self.fc2 = nn.Linear(1000, num_classes)\\n self.dropout = nn.Dropout()\",\n \"def __init__(self, classes=2622):\\n super().__init__()\\n self.conv1 = _ConvBlock(3, 64, 64)\\n self.conv2 = _ConvBlock(64, 128, 128)\\n self.conv3 = _ConvBlock(128, 256, 256, 256)\\n self.conv4 = _ConvBlock(256, 512, 512, 512)\\n self.conv5 = _ConvBlock(512, 512, 512, 512)\\n self.dropout = torch.nn.Dropout(0.5)\\n self.fc1 = torch.nn.Linear(7 * 7 * 512, 4096)\\n self.fc2 = torch.nn.Linear(4096, 4096)\\n self.fc3 = torch.nn.Linear(4096, classes)\",\n \"def _convert_to_onehot_labels(seg_label, num_classes):\\n\\n batch_size = seg_label.size(0)\\n onehot_labels = seg_label.new_zeros((batch_size, num_classes))\\n for i in range(batch_size):\\n hist = seg_label[i].float().histc(\\n bins=num_classes, min=0, max=num_classes - 1)\\n onehot_labels[i] = hist > 0\\n return onehot_labels\",\n \"def _multiclass_with_missing_class(*shape: Any, num_classes=NUM_CLASSES):\\n x = torch.randint(0, num_classes, shape)\\n x[x == 0] = 2\\n return x\",\n \"def classify(self):\\n infer = self.model.signatures['serving_default']\\n for i, original_image in enumerate(self.images):\\n image = original_image.copy()\\n image = cv.cvtColor(image, cv.COLOR_BGR2RGB)\\n image = cv.resize(image, (self.image_size, self.image_size))\\n image = image / 255.\\n\\n image = [image]\\n image = np.asarray(image).astype(np.float32)\\n batch_data = tf.constant(image)\\n pred_bbox = infer(batch_data)\\n for key, value in pred_bbox.items():\\n boxes = value[:, :, 0:4]\\n pred_conf = value[:, :, 4:]\\n\\n boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(\\n boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),\\n scores=tf.reshape(\\n pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),\\n max_output_size_per_class=10,\\n max_total_size=10,\\n iou_threshold=FLAGS.iou,\\n score_threshold=FLAGS.score\\n )\\n\\n height, width, _ = original_image.shape\\n\\n print(scores)\\n classes = classes[0]\\n print(classes)\\n\\n bbox = boxes[0][0].numpy()\\n bbox[0] = int(bbox[0] * height)\\n bbox[2] = int(bbox[2] * height)\\n bbox[1] = int(bbox[1] * width)\\n bbox[3] = int(bbox[3] * width)\\n\\n if BIRD_CLASS in classes:\\n idx = np.where(classes == BIRD_CLASS)\\n bbox = bbox.astype(np.int)\\n x = int((bbox[1] + bbox[3]) / 2)\\n y = int((bbox[0] + bbox[2]) / 2)\\n self.thumbnail_center.append((x, y))\\n cropped_img = original_image[bbox[0]:bbox[2], bbox[1]: bbox[3]]\\n self.bird_images.append(cropped_img)\\n self.confidence_arr.append(scores[idx[0][0]][0])\\n\\n self.generate_thumbnail(size=150)\",\n \"def mask_label_into_class_label(self, mask_labels, img_resolution = 256, bigger_than_percent=3.0):\\n array_of_number_of_change_pixels = []\\n\\n for mask in mask_labels:\\n number_of_ones = np.count_nonzero(mask.flatten()) # << loading takes care of this 0 vs non-zero\\n array_of_number_of_change_pixels.append(number_of_ones)\\n\\n self.debugger.save_arr(array_of_number_of_change_pixels, \\\"BALANCING\\\")\\n array_of_number_of_change_pixels = self.debugger.load_arr(\\\"BALANCING\\\")\\n\\n array_of_number_of_change_pixels = array_of_number_of_change_pixels / (\\n img_resolution * img_resolution) * 100.0 # percentage of image changed\\n\\n class_labels = []\\n for value in array_of_number_of_change_pixels:\\n is_change = value > bigger_than_percent\\n class_labels.append(int(is_change))\\n\\n return np.array(class_labels)\",\n \"def assignClassLabelToSuperPixel(superPixelMask, imageClassLabels):\\n # just adopt the most frequently occurring class label as the superpixel label\\n superPixelConstituentLabels = imageClassLabels[superPixelMask]\\n labelCount = scipy.stats.itemfreq(superPixelConstituentLabels)\\n # This is nx2 matrix, each row is (label, count). Sort in descending count order\\n if labelCount.shape[0] > 1:\\n idx = np.argsort( labelCount[:,1] )[::-1]\\n labelCount = labelCount[ idx, : ]\\n # If there are enough pixels of the max class, and the second class is not\\n # significant, include it. Otherwise give it void so it gets discarded\\n # later on.\\n if float(labelCount[0,1])/len(superPixelConstituentLabels) >= 0.5 and \\\\\\n ( labelCount.shape[0]<=1 or labelCount[1,1] <= labelCount[0,1]/2 ):\\n return int( labelCount[0,0] )\\n else:\\n raise Exception( 'WARNING: superpixel has conflicting GT class labels (%.3f %% majority).' % \\\\\\n (100.0 * float(labelCount[0,1])/len(superPixelConstituentLabels)) )\",\n \"def _labels_to_one_hot_class(self, labels, mask):\\n classes = tf.one_hot(\\n tf.cast(labels, tf.int32), self._num_classes, dtype=tf.float32)\\n return tf.where(tf.expand_dims(mask, axis=-1), classes, 0.0)\",\n \"def apply_classifier(self):\\n for detected_object in self.detected_objects:\\n detected_object.predict_class(self.original_image)\",\n \"def get_one_hot(self, mask_slice):\\n mask_one_hot = self.map_vert_to_class(mask_slice).reshape(-1, 1)\\n self.one_hot_encoder.fit(mask_one_hot)\\n mask_one_hot = self.one_hot_encoder.transform(mask_one_hot).toarray()\\n # set 1st dim to num classes\\n mask_one_hot = np.transpose(mask_one_hot, (1, 0))\\n mask_one_hot = mask_one_hot[:,:, None]\\n mask_one_hot = mask_one_hot.reshape((6, mask_slice.shape[0], mask_slice.shape[1]))\\n return mask_one_hot\",\n \"def get_target_shape(self):\\n if not self.channels_first:\\n return [None] + self.w + [self.nclasses]\\n else:\\n return [None] + [self.nclasses] + self.w\",\n \"def __init__(self, C, num_classes):\\n super(AuxiliaryHeadImageNet, self).__init__()\\n self.features = nn.Sequential(\\n nn.ReLU(inplace=True),\\n nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False),\\n nn.Conv2d(C, 128, 1, bias=False),\\n nn.BatchNorm2d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(128, 768, 2, bias=False),\\n # NOTE: This batchnorm was omitted in my earlier implementation due to a typo.\\n # Commenting it out for consistency with the experiments in the paper.\\n # nn.BatchNorm2d(768),\\n nn.ReLU(inplace=True)\\n )\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def __init__(self, C, num_classes):\\n super(AuxiliaryHeadImageNet, self).__init__()\\n self.features = nn.Sequential(\\n nn.ReLU(inplace=True),\\n nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False),\\n nn.Conv2d(C, 128, 1, bias=False),\\n nn.BatchNorm2d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(128, 768, 2, bias=False),\\n # NOTE: This batchnorm was omitted in my earlier implementation due to a typo.\\n # Commenting it out for consistency with the experiments in the paper.\\n # nn.BatchNorm2d(768),\\n nn.ReLU(inplace=True)\\n )\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def __init__(self, C, num_classes):\\n super(AuxiliaryHeadImageNet, self).__init__()\\n self.features = nn.Sequential(\\n nn.ReLU(inplace=True),\\n nn.AvgPool2d(5, stride=2, padding=0, count_include_pad=False),\\n nn.Conv2d(C, 128, 1, bias=False),\\n nn.BatchNorm2d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(128, 768, 2, bias=False),\\n # NOTE: This batchnorm was omitted in my earlier implementation due to a typo.\\n # Commenting it out for consistency with the experiments in the paper.\\n # nn.BatchNorm2d(768),\\n nn.ReLU(inplace=True)\\n )\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def classes(self):\\n #print \\\"making classes again!\\\"\\n l = []\\n for p in self.marks:\\n l.append(psi_class(self,p))\\n for d in range(1, self.dimension + 1):\\n l.append(kappa_class(self,d))\\n for i in range(1, self.genus+1):\\n l.append(chern_char(self, 2*i-1))\\n if True:#self.genus != 0:\\n l.append(irreducible_boundary(self))\\n marks = set(self.marks)\\n reducible_boundaries = []\\n if self.n != 0:\\n first_mark_list = [marks.pop()] \\n for g1 in range(0, self.genus + 1):\\n for p in subsets(marks):\\n r_marks = set(first_mark_list + p)\\n if 3*g1 - 3 + len(r_marks) + 1 >= 0 and 3*(self.genus-g1) - 3 + self.n - len(r_marks) + 1 >= 0:\\n reducible_boundaries.append( reducible_boundary(self, Mgn(g1, r_marks)) )\\n \\n reducible_boundaries.sort(key = lambda b: sorted(list(b.component1.marks)))\\n reducible_boundaries.sort(key = lambda b: len(b.component1.marks))\\n reducible_boundaries.sort(key = lambda b: b.component1.genus)\\n \\n else: #self.n == 0\\n for g1 in range(1, floor(self.genus/2.0)+1):\\n reducible_boundaries.append(reducible_boundary(self, Mgn(g1, []))) \\n \\n \\n l += reducible_boundaries \\n \\n for i in range(1,self.genus+1):\\n l.append(lambda_class(self,i))\\n return l\",\n \"def encodeToCartBoxesLabels(self, gt_instances):\\n raw_boxes_xywh = np.zeros((self.config_data[\\\"max_boxes_per_frame\\\"], 5))\\n ### initialize gronud truth labels as np.zeros ###\\n gt_labels = np.zeros(list(self.cart_shape[1:3]) + \\\\\\n [len(self.anchor_boxes_cart)] + \\\\\\n [len(self.config_data[\\\"all_classes\\\"]) + 5]) \\n\\n ### start transferring box to ground turth label format ###\\n for i in range(len(gt_instances[\\\"classes\\\"])):\\n if i > self.config_data[\\\"max_boxes_per_frame\\\"]:\\n continue\\n class_name = gt_instances[\\\"classes\\\"][i]\\n box_xywh = gt_instances[\\\"cart_boxes\\\"][i]\\n class_id = self.config_data[\\\"all_classes\\\"].index(class_name)\\n if i <= self.config_data[\\\"max_boxes_per_frame\\\"]:\\n raw_boxes_xywh[i, :4] = box_xywh\\n raw_boxes_xywh[i, 4] = class_id\\n class_onehot = helper.smoothOnehot(class_id, \\\\\\n len(self.config_data[\\\"all_classes\\\"]))\\n exist_positive = False\\n grid_strid = self.cart_grid_strides\\n anchors = self.anchor_boxes_cart\\n box_xywh_scaled = box_xywh[np.newaxis, :].astype(np.float32)\\n box_xywh_scaled[:, :2] /= grid_strid\\n anchors_xywh = np.zeros([len(anchors), 4])\\n anchors_xywh[:, :2] = np.floor(box_xywh_scaled[:, :2]) + 0.5\\n anchors_xywh[:, 2:] = anchors.astype(np.float32)\\n\\n iou_scaled = helper.iou2d(box_xywh_scaled, anchors_xywh)\\n ### NOTE: 0.3 is from YOLOv4, maybe this should be different here ###\\n ### it means, as long as iou is over 0.3 with an anchor, the anchor\\n ### should be taken into consideration as a ground truth label\\n iou_mask = iou_scaled > 0.3\\n\\n if np.any(iou_mask):\\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\\n ### TODO: consider changing the box to raw yolohead output format ###\\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\\n exist_positive = True\\n\\n if not exist_positive:\\n ### NOTE: this is the normal one ###\\n ### it means take the anchor box with maximum iou to the raw\\n ### box as the ground truth label\\n iou_mask = iou_scaled == iou_scaled.max()\\n\\n if np.any(iou_mask):\\n xind, yind = np.floor(np.squeeze(box_xywh_scaled)[:2]).astype(np.int32)\\n ### TODO: consider changing the box to raw yolohead output format ###\\n gt_labels[xind, yind, iou_mask, 0:4] = box_xywh\\n gt_labels[xind, yind, iou_mask, 4:5] = 1.\\n gt_labels[xind, yind, iou_mask, 5:] = class_onehot\\n\\n has_label = False\\n if gt_labels.max() != 0:\\n has_label = True\\n gt_labels = np.where(gt_labels == 0, 1e-16, gt_labels)\\n return gt_labels, has_label, raw_boxes_xywh\",\n \"def compute_mask_class(y_true: Tensor):\\n y_true = y_true.detach().cpu()\\n batch_size = y_true.size(0)\\n num_classes = y_true.size(1)\\n if num_classes == 1:\\n y_true = y_true.view(batch_size, -1)\\n elif num_classes == 2:\\n y_true = y_true[:, 1, ...].contiguous().view(batch_size, -1) # Take salt class\\n else:\\n raise ValueError('Unknown num_classes')\\n\\n img_area = float(y_true.size(1))\\n percentage = y_true.sum(dim=1) / img_area\\n class_index = (percentage * 4).round().byte()\\n return class_index\",\n \"def _merge_heads(self, x, is_picture):\\n if is_picture is False:\\n if len(x.shape) != 4:\\n raise ValueError(\\\"x must have rank 4\\\")\\n shape = x.shape\\n return x.permute(0, 2, 1, 3).contiguous().reshape(shape[0], shape[2], shape[3]*self.num_heads)\\n else:\\n if len(x.shape) != 6:\\n raise ValueError(\\\"x must have rank 6\\\")\\n shape = x.shape\\n return x.permute(0, 2, 3, 4, 1, 5).contiguous().reshape(shape[0], shape[2], shape[3], shape[4], shape[5]*self.num_heads)\",\n \"def generate(self, objects):\\n\\n 'Initialize/reset each target volume with zeros'\\n self.classification_mask = np.zeros([self.num_classes, self.target_height, self.target_width])\\n self.bbox_mask = np.zeros([self.num_coords, self.target_height, self.target_width])\\n self.depth_mask = np.zeros([self.num_depth, self.target_height, self.target_width])\\n\\n 'Set entire mask as background until objects are processed'\\n self.classification_mask[0, :, :] = 1\\n\\n for obj in objects:\\n obj_class = self._get_class(obj)\\n shrink_factor = self._get_shrink_factor(obj_class)\\n mask_coords = self._get_mask_coords(obj, shrink_factor)\\n\\n self._update_classification_mask(obj_class, mask_coords)\\n self._update_bbox_mask(obj.bounding_box, mask_coords)\\n self._update_depth_mask(obj.bounding_box, mask_coords)\\n\\n \\\"Suppress background and dont care classes\\\"\\n suppress_mask = self._suppress_bg_dc()\\n\\n return np.copy(self.classification_mask), np.copy(self.bbox_mask), \\\\\\n np.copy(self.depth_mask), np.copy(suppress_mask)\",\n \"def prepare(self, class_map=None):\\n def clean_name(name):\\n \\\"\\\"\\\"Returns a shorter version of object names for cleaner display.\\\"\\\"\\\"\\n return \\\",\\\".join(name.split(\\\",\\\")[:1])\\n\\n # Build (or rebuild) everything else from the info dicts.\\n self.num_classes = len(self.class_info)\\n self.class_ids = np.arange(self.num_classes)\\n self.class_names = [clean_name(c[\\\"name\\\"]) for c in self.class_info]\\n self.num_images = len(self.image_info)\\n self._image_ids = np.arange(self.num_images)\\n\\n self.class_from_source_map = {\\\"{}.{}\\\".format(info['source'], info['id']): id\\n for info, id in zip(self.class_info, self.class_ids)}\\n\\n # Map sources to class_ids they support\\n self.sources = list(set([i['source'] for i in self.class_info]))\\n self.source_class_ids = {}\\n # Loop over datasets\\n for source in self.sources:\\n self.source_class_ids[source] = []\\n # Find classes that belong to this dataset\\n for i, info in enumerate(self.class_info):\\n # Include BG class in all datasets\\n if i == 0 or source == info['source']:\\n self.source_class_ids[source].append(i)\",\n \"def __init__(self, num_classed= 100):\\n self.model = Sequential()\\n self.num_classed = num_classed\\n self.categories = ['apples', 'aquarium fish', 'baby', 'bear', 'beaver',\\n 'bed', 'bee', 'beetle', 'bicycle', 'bottles',\\n 'bowls','boy', 'bridge', 'bus', 'butterfly', \\n 'camel', 'cans', 'castle', 'caterpillar', 'cattle', \\n 'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', \\n 'couch', 'crab', 'crocodile', 'cups', \\n 'dinosaur', 'dolphin', 'elephant', 'flatfish', 'forest', \\n 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'computer keyboard', 'lamp', \\n 'lawn-mower', 'leopard', 'lion', 'lizard', 'lobster', \\n 'man', 'maple', 'motorcycle', 'mountain', 'mouse', \\n 'mushrooms', 'oak', 'oranges', 'orchids', 'otter', \\n 'palm', 'pears', 'pickup truck', 'pine', 'plain', \\n 'plates', 'poppies', 'porcupine', 'possum', 'rabbit', \\n 'raccoon', 'ray', 'road', 'rocket', 'roses', 'sea', \\n 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', \\n 'snail', 'snake', 'spider', 'squirrel', 'streetcar', \\n 'sunflowers', 'sweet peppers', 'table', 'tank', 'telephone', \\n 'television', 'tiger', 'tractor', 'train', 'trout', \\n 'tulips', 'turtle', 'wardrobe', 'whale', 'willow', \\n 'wolf', 'woman', 'worm']\",\n \"def translate_all_poslists_to_ourclass_numb(motifs_dict,gnum_classes_rel,cons_pos_dict,current_class,other_classes_ok):\\n current_poslists=cons_pos_dict[current_class]\\n current_motif = motifs_dict[current_class]\\n show_class={\\\"A\\\":True,\\\"B\\\":True,\\\"C\\\":True,\\\"F\\\":True}\\n for gpcr_class in other_classes_ok:\\n for cons_pos_li in cons_pos_dict[gpcr_class]:\\n for el in cons_pos_li:\\n pos_nm=el[0]\\n s=re.search(\\\"([A-Z]?)([\\\\d\\\\.]+)\\\",pos_nm)\\n AA=s.group(1)\\n bw_pos_ok=s.group(2)\\n try:\\n current_bw_pos=gnum_classes_rel[gpcr_class][bw_pos_ok]\\n except Exception:\\n current_bw_pos=\\\"Position not found\\\"\\n el[2]=\\\"None\\\"\\n el[0]=AA + bw_pos_ok + gpcr_class.lower()\\n el[1]=current_bw_pos\\n motif_info = motifs_dict[gpcr_class]\\n if motif_info:\\n for el in motif_info[0]:\\n bw_pos=el[1][1:]\\n if bw_pos in gnum_classes_rel[gpcr_class]:\\n current_bw_pos=gnum_classes_rel[gpcr_class][bw_pos]\\n el[4]=current_bw_pos\\n none_classes=list({\\\"A\\\",\\\"B\\\",\\\"C\\\",\\\"F\\\"} - set(other_classes_ok + list(current_class)))\\n for n_class in none_classes:\\n show_class[n_class]=False\\n i=0\\n while i < len(cons_pos_dict[n_class]):\\n cons_pos_dict[n_class][i]=None\\n i+=1\\n motifs_dict[n_class]=[]\\n return (show_class,current_poslists,current_motif,other_classes_ok)\",\n \"def add_extra_classes():\\n\\n for wire_version in [of_g.VERSION_1_2, of_g.VERSION_1_3]:\\n version_name = of_g.of_version_wire2name[wire_version]\\n oxm.add_oxm_classes_1_2(versions[version_name]['classes'], wire_version)\",\n \"def generate_subclass_mask(mask_image,\\n subclasses=(1, 3)):\\n mask_shape = mask_image.shape\\n sub_mask = generate_image(mask_shape[0], mask_shape[1], color=0)\\n if mask_image.ndim == 2:\\n gray_mask_image = mask_image[:, :]\\n else:\\n gray_mask_image = mask_image[:, :, 0]\\n \\n if isinstance(subclasses, (list, tuple)):\\n if len(subclasses) == 2:\\n keep_bool = np.logical_or(gray_mask_image == subclasses[0], gray_mask_image == subclasses[1])\\n else:\\n keep = []\\n for subclass in subclasses:\\n keep.append(gray_mask_image == subclass)\\n\\n keep_bool = np.logical_or.reduce(tuple(keep))\\n else:\\n keep_bool = (gray_mask_image == subclasses)\\n\\n sub_mask[keep_bool] = 1\\n\\n return sub_mask\",\n \"def combine_all(self):\\n if self._train_only:\\n return\\n\\n combined = copy.deepcopy(self.train)\\n\\n # relabel pids in gallery (query shares the same scope)\\n g_pids = set()\\n for items in self.gallery:\\n pid = items[1]\\n if pid in self._junk_pids:\\n continue\\n g_pids.add(pid)\\n pid2label = {pid: i for i, pid in enumerate(g_pids)}\\n\\n def _combine_data(data):\\n for img_path, pid, camid, dsetid in data:\\n if pid in self._junk_pids:\\n continue\\n pid = pid2label[pid] + self.num_train_pids\\n combined.append((img_path, pid, camid, dsetid))\\n\\n _combine_data(self.query)\\n _combine_data(self.gallery)\\n\\n self.train = combined\\n self.num_train_pids = self.get_num_pids(self.train)\",\n \"def set_config_layers_by_class(self, class_name, **items):\\n for layer in self._layers:\\n if layer.__class__.__name__.lower().startswith(class_name.lower()):\\n self.set_config_layer(layer.name, **items)\",\n \"def n_classes(self):\\n raise NotImplementedError\",\n \"def n_classes(self):\\n raise NotImplementedError\",\n \"def get_classes(self):\\n out_classes = ()\\n classes = super(NamedEntityRecognizerModel, self).get_classes()\\n\\n for c in classes:\\n out_classes += (c[:2],)\\n\\n return ((self.outside_class, self.outside_class_display),) + out_classes\",\n \"def one_hot_encode_soy(soy_data, classes):\\n\\n print('[ INFO ]: One-hot-encoding soy data...')\\n\\n for col in soy_data.columns:\\n if col not in ['index', 'attr_35']:\\n\\n # Find the min and max values in each column to account for all values\\n col_min = min(soy_data[col])\\n col_max = max(soy_data[col]) + 1\\n for u in range(col_min, col_max):\\n soy_data[col + '_' + str(u)] = (soy_data[col] == u).astype(int)\\n soy_data = soy_data.drop(col, axis=1)\\n if col == 'attr_35':\\n\\n # Create new columns for each unique class\\n for u in soy_data[col].unique():\\n soy_data['{}_class'.format(u)] = np.where(soy_data[col] == u, 1, 0)\\n classes = np.char.replace(classes, u, u + '_class')\\n soy_data = soy_data.drop(col, axis=1)\\n\\n return soy_data, classes\",\n \"def __init__(self, classes, alpha=1.0):\\n self.alpha_ = alpha\\n self.classes_ = classes.tolist()\\n self.class_counts_ = self.alpha_*np.ones(len(self.classes_))\\n self.features_ = []\",\n \"def change_class_labels_to_given(classes,given):\\n classes=np.asarray(classes)\\n classes_new=np.zeros(classes.shape,dtype=object)\\n for i in given:\\n classes_new[classes==i]=given[i]\\n return classes_new\",\n \"def mix_labellers(labellers, class_name=\\\"MixtureLabeller\\\"):\\n return type(class_name, labellers, {})\",\n \"def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):\\n box_list = [b for b in cls_boxes if len(b) > 0]\\n if len(box_list) > 0:\\n boxes = np.concatenate(box_list)\\n else:\\n boxes = None\\n if cls_segms is not None:\\n segms = [s for slist in cls_segms for s in slist]\\n else:\\n segms = None\\n if cls_keyps is not None:\\n keyps = [k for klist in cls_keyps for k in klist]\\n else:\\n keyps = None\\n classes = []\\n for j in range(len(cls_boxes)):\\n classes += [j] * len(cls_boxes[j])\\n return boxes, segms, keyps, classes\",\n \"def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):\\n box_list = [b for b in cls_boxes if len(b) > 0]\\n if len(box_list) > 0:\\n boxes = np.concatenate(box_list)\\n else:\\n boxes = None\\n if cls_segms is not None:\\n segms = [s for slist in cls_segms for s in slist]\\n else:\\n segms = None\\n if cls_keyps is not None:\\n keyps = [k for klist in cls_keyps for k in klist]\\n else:\\n keyps = None\\n classes = []\\n for j in range(len(cls_boxes)):\\n classes += [j] * len(cls_boxes[j])\\n return boxes, segms, keyps, classes\",\n \"def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):\\n box_list = [b for b in cls_boxes if len(b) > 0]\\n if len(box_list) > 0:\\n boxes = np.concatenate(box_list)\\n else:\\n boxes = None\\n if cls_segms is not None:\\n segms = [s for slist in cls_segms for s in slist]\\n else:\\n segms = None\\n if cls_keyps is not None:\\n keyps = [k for klist in cls_keyps for k in klist]\\n else:\\n keyps = None\\n classes = []\\n for j in range(len(cls_boxes)):\\n classes += [j] * len(cls_boxes[j])\\n return boxes, segms, keyps, classes\",\n \"def class_labels(self):\\n return self._class_labels\",\n \"def n_classes(self):\\n raise NotImplementedError()\",\n \"def __init__(self):\\n self.label = \\\"Combine NNOutput Files \\\"\\n self.description = \\\"Combines PNN, FUZ, and RBN files generated from partitions of the class.dta file.\\\"\\n self.canRunInBackground = False\\n self.category = \\\"Neural network\\\"\",\n \"def _classifier(self, classes):\\n # Initialize key variables\\n pseudo = np.linalg.pinv(self.data)\\n result = np.dot(pseudo, classes)\\n return result\",\n \"def prepare(self, class_map=None):\\n\\n def clean_name(name):\\n \\\"\\\"\\\"Returns a shorter version of object names for cleaner display.\\\"\\\"\\\"\\n return \\\",\\\".join(name.split(\\\",\\\")[:1])\\n\\n # Build (or rebuild) everything else from the info dicts.\\n self.num_classes = len(self.class_info)\\n self.class_ids = np.arange(self.num_classes)\\n self.class_names = [clean_name(c[\\\"name\\\"]) for c in self.class_info]\\n self.num_images = len(self.image_info)\\n self._image_ids = np.arange(self.num_images)\\n\\n # Mapping from source class and image IDs to internal IDs\\n self.class_from_source_map = {\\\"{}.{}\\\".format(info['source'], info['id']): id\\n for info, id in zip(self.class_info, self.class_ids)}\\n self.image_from_source_map = {\\\"{}.{}\\\".format(info['source'], info['id']): id\\n for info, id in zip(self.image_info, self.image_ids)}\\n\\n # Map sources to class_ids they support\\n self.sources = list(set([i['source'] for i in self.class_info]))\\n self.source_class_ids = {}\\n # Loop over datasets\\n for source in self.sources:\\n self.source_class_ids[source] = []\\n # Find classes that belong to this dataset\\n for i, info in enumerate(self.class_info):\\n # Include BG class in all datasets\\n if i == 0 or source == info['source']:\\n self.source_class_ids[source].append(i)\",\n \"def set_sclasses(self, w: Wrapper, classes: Any) -> None:\\n w.setProperty(self.style_sclass_property, f\\\" {' '.join(set(classes))} \\\")\",\n \"def classes(self):\\n raise NotImplementedError(\\\"Please implement this yourself.\\\")\",\n \"def __multilabel_processing(self):\\n # read the raw dataset\\n self.data['image_name'] = self.data['image_name'].map(lambda x: '{}.{}'.format(x, img_format))\\n self.data['tags'] = self.data['tags'].map(lambda x: x.split())\\n\\n # create a df with the same number of rows as the dataset filled with the name of the unique values in tags\\n label_names = self.data['tags'].explode().unique().tolist()\\n label_df = pd.DataFrame([label_names] * self.data.shape[0], columns=label_names)\\n\\n # binarize the labels according to if they exist for each image or not\\n self.data = pd.concat([self.data, label_df], axis=1)\\n self.data[['image_name'] + label_names] = self.data.apply(lambda x: pd.Series([x[0]] + [1 if label in x[1] else 0 for label in x[2:]]), axis=1)\",\n \"def __init__(\\n self, \\n dim_feat_raw, \\n dim_feat_smooth, \\n dim_label_raw, \\n dim_label_smooth, \\n arch_gnn, \\n aug_feat,\\n num_ensemble, \\n train_params\\n ):\\n super().__init__()\\n self.mulhead = 1\\n self.num_layers = arch_gnn[\\\"num_layers\\\"]\\n self.dropout, self.dropedge = train_params[\\\"dropout\\\"], train_params['dropedge']\\n self.mulhead = int(arch_gnn[\\\"heads\\\"]) # only useful for GAT\\n\\n self.branch_sharing = arch_gnn['branch_sharing'] # only for ensemble\\n\\n self.type_feature_augment = aug_feat\\n assert dim_feat_raw <= dim_feat_smooth, \\\"smoothened feature cannot have smaller shape than the original one\\\"\\n # NOTE: dim_label_raw may be larger than dim_label_smooth ==> label is not used as input\\n self.num_classes = dim_label_raw\\n self.dim_label_in = dim_label_smooth\\n self.dim_feat_in = dim_feat_smooth\\n self.dim_hidden = arch_gnn['dim']\\n # build the model below\\n dim, act = arch_gnn['dim'], arch_gnn['act']\\n self.aug_layers, self.conv_layers, self.res_pool_layers = [], [], []\\n for i in range(num_ensemble):\\n # feat aug\\n if len(self.type_feature_augment) > 0:\\n self.aug_layers.append(nn.ModuleList(\\n nn.Linear(_dim, self.dim_feat_in) for _, _dim in self.type_feature_augment\\n ))\\n # graph convs\\n convs = []\\n if i == 0 or not self.branch_sharing:\\n for j in range(arch_gnn['num_layers']):\\n cls_gconv = DeepGNN.NAME2CLS[arch_gnn['aggr']]\\n dim_in = (self.dim_feat_in + self.dim_label_in) if j == 0 else dim\\n convs.append(cls_gconv(dim_in, dim, dropout=self.dropout, act=act, mulhead=self.mulhead))\\n self.conv_layers.append(nn.Sequential(*convs))\\n else: # i > 0 and branch_sharing\\n self.conv_layers.append(self.conv_layers[-1])\\n # skip-pooling layer\\n type_res = arch_gnn['residue'].lower()\\n type_pool = arch_gnn['pooling'].split('-')[0].lower()\\n cls_res_pool = layers.ResPool\\n args_pool = {}\\n if type_pool == 'sort':\\n args_pool['k'] = int(arch_gnn['pooling'].split('-')[1])\\n self.res_pool_layers.append(\\n cls_res_pool(dim, dim, arch_gnn['num_layers'], type_res, type_pool,\\n dropout=self.dropout, act=act, args_pool=args_pool\\n ))\\n if len(self.aug_layers) > 0:\\n self.aug_layers = nn.ModuleList(self.aug_layers)\\n self.conv_layers = nn.ModuleList(self.conv_layers)\\n self.res_pool_layers = nn.ModuleList(self.res_pool_layers)\\n # ------- ensembler + classifier -------\\n if num_ensemble == 1:\\n self.ensembler = layers.EnsembleDummy()\\n else:\\n self.ensembler = layers.EnsembleAggregator(dim, dim, num_ensemble, dropout=self.dropout, \\n type_dropout=train_params[\\\"ensemble_dropout\\\"], act=arch_gnn[\\\"ensemble_act\\\"])\\n self.classifier = DeepGNN.NAME2CLS['mlp'](dim, self.num_classes, act='I', dropout=0.)\\n # ---- optimizer, etc. ----\\n self.lr = train_params[\\\"lr\\\"]\\n self.sigmoid_loss = arch_gnn[\\\"loss\\\"] == \\\"sigmoid\\\"\\n self.loss, self.opt_op = 0, None\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)\\n\\n self.num_ensemble = num_ensemble\",\n \"def class_and_replace(org_label, classes):\\r\\n # Classify and replace\\r\\n keys = np.unique(org_label)\\r\\n values = classes #0 for non veg, 1 for veg\\r\\n dictionary = dict(zip(keys, values))\\r\\n classified = replace(org_label, dictionary)\\r\\n \\r\\n # Label merged regions with unique ID\\r\\n labeld = label(classified)\\r\\n number_of_labels = np.unique(labeld)\\r\\n newvals = np.asarray(list(range(1,(len(number_of_labels) + 1))))\\r\\n keys_ID = number_of_labels\\r\\n values_ID = newvals\\r\\n dictionary_ID = dict(zip(keys_ID, values_ID))\\r\\n classified_ID = replace(labeld, dictionary_ID)\\r\\n \\r\\n del(labeld)\\r\\n \\r\\n return classified, classified_ID\",\n \"def draw_all_labels(df,root_folder_path,root_folder_name,logger):\\n # df=df[df.type==\\\"Color\\\"]\\n len_images=df['file_id'].nunique()\\n perc_list=[i*0.05 for i in range(0,20,1)]\\n grouped_df=df.groupby(['file_id','class'])\\n coordinate_names=['x_max','x_min','y_max','y_min']\\n group_len=len(grouped_df)\\n\\n class_label_dict={}\\n label_info_list=[]\\n for ind,(name, group) in enumerate(grouped_df):\\n img_name,class_name=name\\n img_type=group['type'].values[0]\\n bb_list=group[coordinate_names].values.astype(int)\\n if class_name not in class_label_dict.keys():\\n class_label_dict[class_name]=get_random_color()\\n bb_color=class_label_dict[class_name]\\n label_info_list.append([img_name,img_type,class_name,bb_color,bb_list])\\n draw_label_on_image(root_folder_path,root_folder_name,img_name,img_type,class_name,bb_color,bb_list)\\n perc=float(\\\"{:.2f}\\\".format((ind+1)/group_len))\\n if perc in perc_list:\\n perc_list.remove(perc)\\n logger.write(\\\"Classes annotated: \\\"+str(ind+1)+\\\"/\\\"+str(group_len))\\n # print(\\\"Label list generated.\\\")\\n # pool = Pool(1)\\n # pool.starmap(draw_label_on_one_image, zip(\\n # label_info_list, itertools.repeat(root_folder_path), itertools.repeat(root_folder_name)))\\n # pool.close()\\n # pool.join()\\n # print(\\\"Drawing labels is finished.\\\")\",\n \"def compute_mask_class(y_true: Tensor):\\n batch_size = y_true.size(0)\\n num_classes = y_true.size(1)\\n if num_classes == 1:\\n y_true = y_true.view(batch_size, -1)\\n elif num_classes == 2:\\n y_true = y_true[:, 1, ...].contiguous().view(batch_size, -1) # Take salt class\\n else:\\n raise ValueError('Unknown num_classes')\\n\\n img_area = float(y_true.size(1))\\n percentage = y_true.sum(dim=1) / img_area\\n class_index = (percentage * 4).round().byte()\\n return class_index\",\n \"def classesAndFrames(self):\\n classes = defaultdict(int)\\n with open(self.inputfile) as fin:\\n for line in fin:\\n arr = line.strip().split()\\n y = int(arr[1])\\n classes[y] += 1\\n return classes\",\n \"def __init__(self, num_classes):\\n super(VGG16, self).__init__()\\n self.vgg16_feature_extractor = VGG16FeatureExtraction(weights_update=True)\\n self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)\\n self.classifier = VGG16Classfier()\\n self.fc3 = _fc(in_channels=4096, out_channels=num_classes)\",\n \"def create_classification_graf(\\n inputs,\\n num_classes,\\n pyramid_feature_size=256,\\n classification_feature_size=256,\\n name='classification_submodel'\\n):\\n options = {\\n 'kernel_size': 3,\\n 'strides': 1,\\n 'padding': 'same',\\n }\\n outputs = inputs\\n for i in range(4):\\n outputs = keras.layers.Conv2D(\\n filters=classification_feature_size,\\n activation='relu',\\n name='pyramid_classification_{}'.format(i),\\n kernel_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None),\\n bias_initializer='zeros',\\n **options\\n )(outputs)\\n\\n outputs = keras.layers.Conv2D(\\n filters=num_classes,\\n #activation='relu',\\n kernel_initializer=keras.initializers.zeros(),\\n bias_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None), #initializers.PriorProbability(probability=prior_probability),\\n name='pyramid_classification',\\n **options\\n )(outputs)\\n\\n outputs = keras.layers.Activation('sigmoid', name='pyramid_classification_sigmoid')(outputs)\\n\\n return outputs\",\n \"def __init__(self, in_channels=3, in_channels1=3, n_classes=21):\\n super(SegNet, self).__init__()\\n\\n self.layer_1 = SegnetLayer_Encoder(in_channels, 64, 2)\\n self.layer_2 = SegnetLayer_Encoder(64, 128, 2)\\n self.layer_3 = SegnetLayer_Encoder(128, 256, 3)\\n self.layer_4 = SegnetLayer_Encoder(256, 512, 3)\\n self.layer_5 = SegnetLayer_Encoder(512, 512, 3)\\n\\n self.layer_6 = SegnetLayer_Decoder(512, 512, 3)\\n self.layer_7 = SegnetLayer_Decoder(512, 256, 3)\\n self.layer_8 = SegnetLayer_Decoder(256, 128, 3)\\n self.layer_9 = SegnetLayer_Decoder(128, 64, 2)\\n self.layer_10 = SegnetLayer_Decoder(64, n_classes, 2)\\n\\n self.layer_11 = SegnetLayer_Encoder(in_channels1, 64, 2)\\n self.layer_12 = SegnetLayer_Encoder(64, 128, 2)\\n self.layer_13 = SegnetLayer_Encoder(128, 256, 3)\\n self.layer_14 = SegnetLayer_Encoder(256, 512, 3)\\n self.layer_15 = SegnetLayer_Encoder(512, 512, 3)\\n\\n self.layer_16 = SegnetLayer_Decoder(512, 512, 3)\\n self.layer_17 = SegnetLayer_Decoder(512, 256, 3)\\n self.layer_18 = SegnetLayer_Decoder(256, 128, 3)\\n self.layer_19 = SegnetLayer_Decoder(128, 64, 2)\\n self.layer_110 = SegnetLayer_Decoder(64, n_classes, 2)\\n\\n self.layer_1110 = UNet_Decoder_Particular(n_classes * 2, n_classes)\",\n \"def set_hypercubes_classes(self):\\n print(\\\"Setting the Hypercubes' classes of grid at level: \\\" + str(self.level))\\n for hypercube in self.hypercubes.flatten():\\n coordinates = []\\n for coord in hypercube.coords:\\n coordinates.append([2 * coord, 2 * coord + 1])\\n parents_list = []\\n for indices in list(itertools.product(*coordinates)):\\n parents_list.append(self.parent_hypercubes[tuple(reversed(indices))])\\n hypercube.set_lower_level_hypercube_class(parent_hypercubes=parents_list, threshold=self.threshold)\\n if self.child_grid:\\n self.child_grid.set_hypercubes_classes()\",\n \"def reconcile(self):\\r\\n\\t\\tclass_A = np.empty((self.basis.nK,self.basis.nK),float)\\r\\n\\t\\tclass_G = np.empty((self.basis.nK,self.basis.nK),float)\\r\\n\\t\\tclass_koop = np.empty((self.basis.nK,self.basis.nK),float)\\r\\n\\t\\tclass_num = len(self.koop_cluster_list)\\r\\n\\t\\tfor i in range(class_num):\\r\\n\\t\\t\\tclass_mem_num = len(self.koop_cluster_list[i])\\r\\n\\t\\t\\tclass_counter = 0.0\\r\\n\\t\\t\\tfor j in range(class_mem_num):\\r\\n\\t\\t\\t\\tclass_A += (self.koop_cluster_list[i][j]._A*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\\r\\n\\t\\t\\t\\tclass_G += (self.koop_cluster_list[i][j]._G*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\\r\\n\\t\\t\\t\\tclass_counter += self.koop_cluster_list[i][j].counter\\r\\n\\t\\t\\tclass_koop = np.dot(np.linalg.pinv(class_G),class_A)\\r\\n\\t\\t\\tself.koopman_hybrid_modes.append(KoopmanOperator(self.basis, class_koop, class_A, class_G, class_counter))\",\n \"def nms_per_class(box_data, nms_thresh=.45, conf_thresh=0.01, top_k=200):\\n decoded_boxes, class_predictions = box_data[:, :4], box_data[:, 4:]\\n num_classes = class_predictions.shape[1]\\n output = np.zeros((num_classes, top_k, 5))\\n\\n # skip the background class (start counter in 1)\\n for class_arg in range(1, num_classes):\\n conf_mask = class_predictions[:, class_arg] >= conf_thresh\\n scores = class_predictions[:, class_arg][conf_mask]\\n if len(scores) == 0:\\n continue\\n boxes = decoded_boxes[conf_mask]\\n indices, count = apply_non_max_suppression(\\n boxes, scores, nms_thresh, top_k)\\n scores = np.expand_dims(scores, -1)\\n selected_indices = indices[:count]\\n selections = np.concatenate(\\n (boxes[selected_indices], scores[selected_indices]), axis=1)\\n output[class_arg, :count, :] = selections\\n return output\",\n \"def rij(self):\\n for i, c in zip(range(len(self.classes)), self.classes):\\n print(\\\"[\\\" + str(i+1) + \\\"] \\\" + repr(c)) #+ \\\" --- \\\" + str(c) \",\n \"def num_classes():\\n return NUM_CLASSES\",\n \"def preprocess(self):\\n print(\\\"processing content images...\\\")\\n for dir_item in self.selectedContent:\\n join_path = Path(self.content_image_dir,dir_item.replace('/','_'))\\n if join_path.exists():\\n print(\\\"processing %s\\\"%dir_item,end='\\\\r')\\n images = join_path.glob('*.%s'%(self.subffix))\\n for item in images:\\n self.content_dataset.append(item)\\n else:\\n print(\\\"%s dir does not exist!\\\"%dir_item,end='\\\\r')\\n label_index = 0\\n print(\\\"processing style images...\\\")\\n for class_item in self.selectedStyle:\\n images = Path(self.style_image_dir).glob('%s/*.%s'%(class_item, self.subffix))\\n for item in images:\\n self.art_dataset.append([item, label_index])\\n label_index += 1\\n random.seed(self.random_seed)\\n random.shuffle(self.content_dataset)\\n random.shuffle(self.art_dataset)\\n # self.dataset = images\\n print('Finished preprocessing the Art Works dataset, total image number: %d...'%len(self.art_dataset))\\n print('Finished preprocessing the Content dataset, total image number: %d...'%len(self.content_dataset))\",\n \"def decode_labels(mask, num_images=1, num_classes=21, task='seg'):\\n n, h, w, c = mask.shape\\n assert (n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (n, num_images)\\n outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)\\n for i in range(num_images):\\n if task == 'normal':\\n outputs[i] = mask[i]\\n elif task == 'seg':\\n img = Image.new('RGB', (w, h), (255, 255, 255)) # unlabeled part is white (255, 255, 255)\\n pixels = img.load()\\n for j_, j in enumerate(mask[i, :, :, 0]):\\n for k_, k in enumerate(j):\\n if k < num_classes:\\n pixels[k_, j_] = label_colours[k]\\n outputs[i] = np.array(img)\\n else:\\n raise Exception('task name is not recognized!')\\n\\n return outputs\",\n \"def get_class_labels(self):\\r\\n \\r\\n y = self.get_data()['y']\\r\\n if type(y) == torch.Tensor:\\r\\n return y.unique().numpy()\\r\\n else:\\r\\n return sorted(list(set(y)))\",\n \"def create_heads(x, upsample_feature, num_classes, hg_id, num_channels):\\n hg_name = 'hg' + str(hg_id)\\n\\n head = Conv2D(num_channels, kernel_size=(1, 1), activation='relu', padding='same', name=hg_name+'_conv_1x1_1')(upsample_feature)\\n head = BatchNormalization()(head)\\n\\n # for head as intermediate supervision, use 'linear' as activation.\\n head_predict = Conv2D(num_classes, kernel_size=(1, 1), activation='linear', padding='same',\\n name=hg_name+'_conv_1x1_predict')(head)\\n\\n # use linear activation\\n head = Conv2D(num_channels, kernel_size=(1, 1), activation='linear', padding='same',\\n name=hg_name+'_conv_1x1_2')(head)\\n head_m = Conv2D(num_channels, kernel_size=(1, 1), activation='linear', padding='same',\\n name=hg_name+'_conv_1x1_3')(head_predict)\\n\\n # merge heads for next stage\\n head_next_stage = Add()([head, head_m, x])\\n\\n return head_next_stage, head_predict\",\n \"def __init__(self, classes, smoothing=0.0, dim=-1, weight = None):\\n super(LabelSmoothingLoss, self).__init__()\\n self.confidence = 1.0 - smoothing\\n self.smoothing = smoothing\\n self.weight = weight\\n self.cls = classes\\n self.dim = dim\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5646296","0.5563238","0.55517465","0.524863","0.5160917","0.5154303","0.51411086","0.5111963","0.5110147","0.50583875","0.50512093","0.50234336","0.50105685","0.50064385","0.5000355","0.49941373","0.49783427","0.4972571","0.49269307","0.49222225","0.49197936","0.49143174","0.490244","0.48890448","0.48827296","0.48472926","0.4840798","0.4832726","0.4830663","0.4822485","0.47261724","0.4716574","0.4699897","0.46970624","0.46905228","0.4686739","0.46695027","0.46685514","0.46624136","0.46575534","0.46547833","0.46544892","0.46538782","0.46362862","0.46314","0.4628299","0.46269777","0.46184853","0.46176574","0.4614632","0.46064776","0.46064776","0.46064776","0.4598895","0.45886078","0.45715526","0.45714495","0.45707908","0.45692953","0.4567456","0.4567347","0.45645982","0.45596367","0.45591748","0.45570433","0.45542756","0.45542756","0.4540542","0.45329744","0.45294377","0.45285285","0.45160314","0.45144004","0.45144004","0.45144004","0.45134693","0.45131594","0.45113668","0.4511186","0.4507287","0.45001006","0.449247","0.44912973","0.44878545","0.44835344","0.44835058","0.44825205","0.44781545","0.44694287","0.44688743","0.44655713","0.44625524","0.4461709","0.44616598","0.4458594","0.4456111","0.4454621","0.44535905","0.44494754","0.4447861","0.4446887"],"string":"[\n \"0.5646296\",\n \"0.5563238\",\n \"0.55517465\",\n \"0.524863\",\n \"0.5160917\",\n \"0.5154303\",\n \"0.51411086\",\n \"0.5111963\",\n \"0.5110147\",\n \"0.50583875\",\n \"0.50512093\",\n \"0.50234336\",\n \"0.50105685\",\n \"0.50064385\",\n \"0.5000355\",\n \"0.49941373\",\n \"0.49783427\",\n \"0.4972571\",\n \"0.49269307\",\n \"0.49222225\",\n \"0.49197936\",\n \"0.49143174\",\n \"0.490244\",\n \"0.48890448\",\n \"0.48827296\",\n \"0.48472926\",\n \"0.4840798\",\n \"0.4832726\",\n \"0.4830663\",\n \"0.4822485\",\n \"0.47261724\",\n \"0.4716574\",\n \"0.4699897\",\n \"0.46970624\",\n \"0.46905228\",\n \"0.4686739\",\n \"0.46695027\",\n \"0.46685514\",\n \"0.46624136\",\n \"0.46575534\",\n \"0.46547833\",\n \"0.46544892\",\n \"0.46538782\",\n \"0.46362862\",\n \"0.46314\",\n \"0.4628299\",\n \"0.46269777\",\n \"0.46184853\",\n \"0.46176574\",\n \"0.4614632\",\n \"0.46064776\",\n \"0.46064776\",\n \"0.46064776\",\n \"0.4598895\",\n \"0.45886078\",\n \"0.45715526\",\n \"0.45714495\",\n \"0.45707908\",\n \"0.45692953\",\n \"0.4567456\",\n \"0.4567347\",\n \"0.45645982\",\n \"0.45596367\",\n \"0.45591748\",\n \"0.45570433\",\n \"0.45542756\",\n \"0.45542756\",\n \"0.4540542\",\n \"0.45329744\",\n \"0.45294377\",\n \"0.45285285\",\n \"0.45160314\",\n \"0.45144004\",\n \"0.45144004\",\n \"0.45144004\",\n \"0.45134693\",\n \"0.45131594\",\n \"0.45113668\",\n \"0.4511186\",\n \"0.4507287\",\n \"0.45001006\",\n \"0.449247\",\n \"0.44912973\",\n \"0.44878545\",\n \"0.44835344\",\n \"0.44835058\",\n \"0.44825205\",\n \"0.44781545\",\n \"0.44694287\",\n \"0.44688743\",\n \"0.44655713\",\n \"0.44625524\",\n \"0.4461709\",\n \"0.44616598\",\n \"0.4458594\",\n \"0.4456111\",\n \"0.4454621\",\n \"0.44535905\",\n \"0.44494754\",\n \"0.4447861\",\n \"0.4446887\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93489,"cells":{"query":{"kind":"string","value":"The loss of PanopticFPN head. Things classes will be merged to one class in PanopticFPN."},"document":{"kind":"string","value":"def loss(self, seg_preds, gt_semantic_seg):\n gt_semantic_seg = self._set_things_to_void(gt_semantic_seg)\n return super().loss(seg_preds, gt_semantic_seg)"},"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_loss(self):\n raise NotImplementedError","def get_loss(self):\n raise NotImplementedError","def compute_loss(self):","def loss(self):\n return self._loss","def loss(self) -> KernelLoss:\n return self._loss","def loss(self):\n return self._get(\"loss\")","def loss(self, **kwargs):\n pass","def loss_op(self):\n return self.loss","def add_loss(self):\n \n raise RuntimeError(\"Must define function add_loss(self)\")","def _get_loss_fn(self):\n msg = (\n \"Abstract class: _get_loss_fn() must be implemented by a child \"\n \"class of Classifier.\"\n )\n raise NotImplementedError(msg)","def get_loss(self):\r\n\r\n if F.loss_type==\"cosine\":\r\n self.losscos = r2d*tf.acos(1-tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1))\r\n self.loss = tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1)\r\n elif F.loss_type==\"mse2d\":\r\n xl, yl, zl = tf.split(self.labels, 3, axis=1)\r\n xo, yo, zo = tf.split(self.out, 3, axis=1)\r\n thetal, thetao = tf.asin(-yl), tf.asin(-yo)\r\n phil, phio = tf.atan2(-zl, -xl), tf.atan2(-zo, -xo)\r\n self.lb = tf.concat([thetal, phil], axis=1)\r\n self.ob = tf.concat([thetao, phio], axis=1)\r\n self.loss = tf.scalar_mul(tf.constant(r2d), tf.losses.mean_squared_error(self.lb, self.ob, 2))\r\n elif F.loss_type==\"mse3d\":\r\n self.loss = tf.losses.mean_squared_error(tf.nn.l2_normalize(self.labels, 0), tf.nn.l2_normalize(self.out, 0))","def genLoss(self, *data):\r\n _, (x_unlab, _) = data\r\n z = self.getInputNoise(self.hypers['ul_BS'])\r\n fake_logits = self.D(self.G(z))\r\n g_losses = -1*logOneMinusSoftmax(fake_logits)[:,self.D.numClasses-1]\r\n return torch.mean(g_losses)","def _loss_out(self, e_out):\n prior_out = 1 # self.prior\n\n if self.loss_type_out == 'exponential':\n loss = torch.sum(e_out, -1, keepdim=True)\n\n elif self.loss_type_out == 'chi_squared':\n a_out = e_out + prior_out\n df = prior_out + 2\n loss = torch.sum((df / 2 - 1) * torch.log(a_out) + a_out / 2, dim=-1, keepdim=True)\n\n elif self.loss_type_out == 'uncertainty':\n S_out = (e_out + prior_out).sum(-1, keepdim=True)\n unc = self.n_classes / S_out\n loss = -unc\n\n elif self.loss_type_out == 'kl':\n a_out = e_out + prior_out\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\n kl = kl_dirichlet(a_out, a_target)\n loss = kl\n\n elif self.loss_type_out == 'kl_reverse':\n a_out = e_out + prior_out\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\n kl = kl_dirichlet(a_target, a_out)\n loss = kl\n\n elif self.loss_type_out == 'kl_symmetric':\n a_out = e_out + prior_out\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\n kl = .5*(kl_dirichlet(a_out, a_target) + kl_dirichlet(a_target, a_out))\n loss = kl\n\n elif self.loss_type_out == 'chernoff_distance':\n a_out = e_out + prior_out\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\n dist = chernoff_distance(a_out, a_target)\n loss = dist\n\n return loss","def get_loss_fn(self):\n raise NotImplementedError()","def get_loss(self):\n return self.loss / self.cnt","def compute_loss(self):\n self.prototypes = self.compute_prototypes()\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.episode.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def loss_names(self):\n return ['loss']","def loss_weights(self):\n return None","def loss_(self, batch):\n raise NotImplementedError","def loss(self, X, labels):\n features = self.get_conv_feats(X)\n loss = blah\n return loss","def loss(self, X, labels):\n features = self.get_conv_features(X)\n loss = blah\n return loss","def setup_loss(self):\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\n #self.loss = nn.CrossEntropyLoss()","def loss(self):\n if not self.run:\n self._run()\n return self.model_loss","def get_loss(self, Loss, results, inputs, device):\n return","def get_loss_fn():\n return reconstruction","def loss(self):\n return 'mse'","def build_loss(self):\n if self.mode != \"encode\":\n total_loss = tf.losses.get_total_loss()\n tf.summary.scalar(\"losses/total\", total_loss)\n\n self.total_loss = total_loss","def _init_loss(self) -> None:\n labels_one_hot = tf.one_hot(self.labels, depth=Data.num_classes)\n cross_entropy_loss = tf.losses.softmax_cross_entropy(labels_one_hot, self.logits)\n # cross_entropy_loss is a scalar\n tf.add_to_collection(tf.GraphKeys.LOSSES, cross_entropy_loss)\n self.loss = tf.add_n(tf.get_collection(tf.GraphKeys.LOSSES))\n self.logger_factory.add_scalar('loss', self.loss, log_frequency=10)\n self.logger_factory.add_scalar('cross_entropy_loss', cross_entropy_loss, log_frequency=25)","def lfads_training_loss(params, lfads_hps, key, x_bxt, kl_scale, keep_rate):\n losses = lfads_losses(params, lfads_hps, key, x_bxt, kl_scale, keep_rate)\n return losses['total']","def compute_loss(self, **kwargs):\n raise NotImplementedError","def losses(self):\n pass","def configure_loss_fn(self) -> nn.Module:\n pass","def loss(self, T, mode):\n self.circuit.loss(T, mode)","def _loss(self):\n\n cross_entropy = tf.reduce_mean(-tf.log(self.probability + epsilon) * self.y)\n self.loss = cross_entropy\n\n self.accuracy = tf.reduce_mean(\n tf.cast(tf.equal(tf.argmax(self.y, 1), self.prediction), tf.float32))","def logloss(self,tple):\n feats = self.dataset.input_features\n res = 0\n cc = self.class_counts\n fc = self.feature_counts\n for c in range(self.num_classes):\n res += prod(fc[i][feat(tple)][c]\n for (i,feat) in enumerate(feats))/(cc[c]**(len(feats)-1))\n if res>0:\n return -math.log2(res/len(self.dataset.train))\n else:\n return float(\"inf\") #infinity","def _create_loss(self):\n\n with tf.name_scope(\"loss\"):\n \n # gini=(tf.nn.l2_loss( self.score))/100000\n gini = tf.losses.softmax_cross_entropy(self.score, 0*self.score)\n \n promo_prob=tf.reduce_sum(tf.multiply(self.score, self.cohort_weight),\n axis=1)\n inc_value = tf.reduce_mean(tf.multiply(promo_prob, self.value))- self.control_value\n inc_cost = tf.reduce_mean( tf.multiply(promo_prob, self.cost)) - self.control_cost\n \n\n\n # determine loss function based on self.obj_rule\n if self.obj_rule == 'cpiv':\n self.objective = inc_cost / inc_value\n\n elif self.obj_rule == 'ivc':\n # maximize ivc\n self.objective = - inc_value / inc_cost\n\n elif self.obj_rule == 'lagrangian':\n assert self.shadow is not None, 'Need to pass in shadow value if use lagrangian as obj_rule.'\n self.objective = inc_cost - self.shadow * inc_value\n\n elif self.obj_rule == 'value':\n # maximize delta values\n self.objective = - inc_value\n\n # use only cost as objective\n elif self.obj_rule == 'cost':\n # maximize delta cost\n self.objective = - inc_cost\n\n else:\n raise Exception('Invalid obj_rule!')\n\n # regularization\n reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n # weights = tf.trainable_variables() # all vars of your graph\n # reg_loss = tf.norm( weights,ord=1)\n\n # final loss\n self.loss = self.objective +reg_loss+.1*gini","def loss(self, forward, rating):\n return self.loss_fn(forward, rating.float().view(-1))","def getLoss(self, x_test, t_test):\n x_t = Variable(x_test, requires_grad=False)\n #Feed inputes into neural network\n t_pred = self.model(x_t)\n #Now lets compute out loss\n loss = self.loss_fn(t_pred, t_test)\n return loss","def profit_loss(self) -> float:\n return self.net_worth / self.initial_net_worth","def compute_loss(self, features, mode, params, precomputed):\n raise NotImplementedError(\"Model does not implement loss.\")","def model_loss(inp, fake, real_label, fake_label):\n \n \n Dreal,realcls,R1 = gradpen(inp)\n [Dfake,fakecls] = D(fake)\n # 1. Adversarial loss\n \n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\n \n \n \n # D has no sigmoid activation: \"from_logits=True\"\n real_loss = tf.keras.losses.binary_crossentropy(\n dlabelr, Dreal, from_logits=True)\n real_loss = tf.reduce_mean(real_loss)\n \n fake_loss = tf.keras.losses.binary_crossentropy(\n dlabelf, Dfake, from_logits=True)\n fake_loss = tf.reduce_mean(fake_loss)\n \n Dadv = 0.5*(real_loss+fake_loss)\n \n Gadv = tf.keras.losses.binary_crossentropy(\n glabel, Dfake, from_logits=True)\n Gadv = tf.reduce_mean(Gadv)\n \n # 2. Classification loss\n \n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\n Dcls = tf.reduce_mean(Dcls)\n \n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\n Gcls = tf.reduce_mean(Gcls)\n \n # 3. Total loss\n \n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\n \n Gloss = Gadv + LAMBDA_CLS*Gcls\n \n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)","def _initLoss(self):\n\n pass","def get_loss(self, xs, y):\n \"*** YOUR CODE HERE question 4 ***\"\n return nn.SoftmaxLoss(self.run(xs), y)","def compute_loss(self, obs, returns):","def get_probability_loss(self):\n return sum(self._loss)/len(self._loss)","def loss(self, prediction_dict, groundtruth_lists):\r\n pass","def loss(self, X, y):\n\n # Initialize the loss to zero.\n loss = 0.0\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n exp_a = np.zeros((num_classes,num_train))\n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the normalized softmax loss. Store it as the variable loss.\n # (That is, calculate the sum of the losses of all the training \n # set margins, and then normalize the loss by the number of \n # training examples.)\n # ================================================================ #\n \n \n for i in np.arange(num_train):\n \n Loss = 0.0\n\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\n\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\n\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\n \n\n #p[:,i] = exp_a[:,i]/np.sum(exp_a[:,i]) # p now is a valid probability matrix\n #print(p[:,i])\n\n loss += Loss \n #print(Loss,i) \n \n pass\n loss /= num_train\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss","def _initLoss(self):\n\n return torch.nn.MSELoss()","def compute_loss(self, *args, **kwargs):\n raise NotImplementedError","def loss(self, y: torch.Tensor, state: AlgorithmState) -> torch.Tensor:\n\n raise NotImplementedError()","def loss(self, T, mode):\n self.circuit.loss(T, self._remap_modes(mode))","def hpm_loss(self, x, y, t, Ex_u, Ex_v):\n\n x = x.view(-1)\n y = y.view(-1)\n t = t.view(-1)\n\n u, v, f_u, f_v = self.net_pde(x, y, t)\n\n Ex_u = Ex_u.view(-1)\n Ex_v = Ex_v.view(-1)\n\n hpmLoss = torch.mean(f_u ** 2) + torch.mean(f_v ** 2) + torch.mean((u - Ex_u) ** 2) + torch.mean((v - Ex_v) ** 2) \n return hpmLoss","def compute_loss(self, x, gt):\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\n return loss","def detector_loss(self, input, target, mask=None, loss_type=\"softmax\"):\n if loss_type == \"l2\":\n loss_func = nn.MSELoss(reduction=\"mean\")\n loss = loss_func(input, target)\n elif loss_type == \"softmax\":\n loss_func_BCE = nn.BCELoss(reduction='none').cuda()\n loss = loss_func_BCE(nn.functional.softmax(input, dim=1), target)\n loss = (loss.sum(dim=1) * mask).sum()\n loss = loss / (mask.sum() + 1e-10)\n return loss","def add_loss_op(self, preds):\n ### YOUR CODE HERE (~2-4 lines)\n trans = tf.get_variable('trans',\n shape=[Config.n_classes, Config.n_classes],\n initializer=tf.contrib.layers.xavier_initializer())\n log_likelihood, _ = crf_log_likelihood(preds,\n self.labels_placeholder,\n self.length_placeholder,\n trans)\n #log_likelihood = tf.boolean_mask(log_likelihood, self.mask_placeholder)\n loss = tf.reduce_mean(-1.0 * log_likelihood)\n \n ### END YOUR CODE\n return trans, loss","def loss(self):\n return la.norm(self.resids) / self.normX","def loss(returns, predicted_output):\n ################################\n # YOUR IMPLEMENTATION HERE #\n ################################\n raise NotImplementedError","def _auxiliary_loss(self, expert_mask, router_prob):\n # density_1's shape: (dp_group, self.expert_dim)\n density_1 = self.reduce_mean(expert_mask, 1)\n # density_1_proxy's shape: (dp_group, self.expert_dim)\n density_1_proxy = self.reduce_mean2(router_prob, 1)\n loss = self.mul(density_1, density_1_proxy)\n loss = self.reduce_mean3(loss)\n loss = self.mul3(self.mul2(loss, self.expert_dim), self.expert_dim)\n return loss","def loss_fn(self, targets, outputs, model):","def loss(self, input_data, fwd_out):\n logger.debug(\"GumBolt::loss\")\n \n kl_loss, cross_entropy, pos_energy, neg_energy = self.kl_divergence(fwd_out.post_logits,\n fwd_out.post_samples)\n \n ae_loss_matrix = -fwd_out.output_distribution.log_prob_per_var(input_data.view(-1, self._flat_input_size))\n ae_loss_per_sample = torch.sum(ae_loss_matrix,1)\n ae_loss = torch.mean(ae_loss_per_sample)\n \n loss = ae_loss + kl_loss\n \n return {\"loss\":loss, \"ae_loss\":ae_loss, \"kl_loss\":kl_loss,\n \"cross_entropy\":cross_entropy, \"pos_energy\":pos_energy, \"neg_energy\":neg_energy}","def get_loss(self, xs, y):\n \"*** YOUR CODE HERE ***\"\n predictedY = self.run(xs)\n return nn.SoftmaxLoss(predictedY, y)\n # return nn.SquareLoss(predictedY, y)","def get_loss(self):\n return categorical_cross_entropy.get_loss(loss_key=self.loss_key,\n output_name=self.args.output_name)","def ss_loss_(self, batch):\n raise NotImplementedError","def verbose_loss(self, feedback: _Feedback, extra_info) -> Dict[str, _Array]:\n hint_preds, diff_logits, gt_diffs = extra_info\n\n for inp in feedback.features.inputs:\n if inp.location in [_Location.NODE, _Location.EDGE]:\n nb_nodes = inp.data.shape[1]\n break\n\n total_loss = 0.0\n lengths = feedback.features.lengths\n\n losses = {}\n if self.decode_diffs:\n for loc in _Location:\n for i in range(len(gt_diffs)):\n is_not_done = _is_not_done_broadcast(lengths, i, gt_diffs[i][loc])\n diff_loss = (\n jnp.maximum(diff_logits[i][loc], 0) -\n diff_logits[i][loc] * gt_diffs[i][loc] +\n jnp.log1p(jnp.exp(-jnp.abs(diff_logits[i][loc]))) * is_not_done)\n losses[loc.name + '_diff_%d' % i] = jnp.mean(diff_loss)\n\n if self.decode_hints:\n for truth in feedback.features.hints:\n for i in range(truth.data.shape[0] - 1):\n assert truth.name in hint_preds[i]\n pred = hint_preds[i][truth.name]\n is_not_done = _is_not_done_broadcast(lengths, i, truth.data[i + 1])\n if truth.type_ == _Type.SCALAR:\n if self.decode_diffs:\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 *\n gt_diffs[i][truth.location] * is_not_done)\n else:\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 * is_not_done)\n elif truth.type_ == _Type.MASK:\n if self.decode_diffs:\n total_loss = jnp.mean(\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\n jnp.log1p(jnp.exp(-jnp.abs(pred))) *\n gt_diffs[i][truth.location] * is_not_done)\n else:\n total_loss = jnp.mean(\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\n jnp.log1p(jnp.exp(-jnp.abs(pred))) * is_not_done)\n elif truth.type_ == _Type.MASK_ONE:\n if self.decode_diffs:\n total_loss = jnp.mean(\n -jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(\n pred) * is_not_done, axis=-1, keepdims=True) *\n gt_diffs[i][truth.location])\n else:\n total_loss = jnp.mean(-jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(\n pred) * is_not_done, axis=-1))\n elif truth.type_ == _Type.CATEGORICAL:\n if self.decode_diffs:\n total_loss = jnp.mean(\n -jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(\n pred), axis=-1, keepdims=True) *\n jnp.expand_dims(gt_diffs[i][truth.location], -1) *\n is_not_done)\n else:\n total_loss = jnp.mean(-jnp.sum(\n truth.data[i + 1] * jax.nn.log_softmax(pred), axis=-1) *\n is_not_done)\n elif truth.type_ == _Type.POINTER:\n if self.decode_diffs:\n total_loss = jnp.mean(-jnp.sum(\n hk.one_hot(truth.data[i + 1], nb_nodes) *\n jax.nn.log_softmax(pred),\n axis=-1) * gt_diffs[i][truth.location] * is_not_done)\n else:\n total_loss = jnp.mean(-jnp.sum(\n hk.one_hot(truth.data[i + 1], nb_nodes) *\n jax.nn.log_softmax(pred),\n axis=-1) * is_not_done)\n else:\n raise ValueError('Incorrect type')\n losses[truth.name + '_%d' % i] = total_loss\n return losses","def pointnet_loss(preds, targets, chamfer_lambda, physical_lambda, joint_lambda, has_anno=None, joint_idxs=None):\n\n gen_pc = preds[0]\n out_idxs = preds[1]\n coords_pred = preds[2]\n seg_out = preds[8]\n seg_out = seg_out.argmin(-1)\n bone_weights = preds[9]\n target_pc = targets[1]\n\n if joint_idxs is not None:\n bone_weights = bone_weights[joint_idxs]\n if has_anno is not None:\n coords_pred = coords_pred[has_anno]\n if joint_idxs is not None:\n coords_pred = coords_pred[:, joint_idxs]\n\n # Chamfer loss\n N = gen_pc.shape[1]\n M = target_pc.shape[1]\n\n pc1_expand = gen_pc.unsqueeze(2).repeat(1, 1, M, 1)\n pc2_expand = target_pc.unsqueeze(1).repeat(1, N, 1, 1)\n pc_diff = pc1_expand - pc2_expand\n pc_dist = (pc_diff ** 2).sum(-1)\n pc_dist = torch.sqrt(pc_dist)\n dist1, idx1 = pc_dist.min(2)\n dist2, idx2 = pc_dist.min(1)\n chamfer_loss = (dist1 + dist2).mean()\n loss = chamfer_lambda * chamfer_loss\n\n # Joint loss\n joint_loss = []\n for i in range(bone_weights.shape[0]):\n # Gen mask\n joint_weight = bone_weights[i]\n joint_weight = joint_weight.unsqueeze(0).expand(coords_pred.shape[0], -1)\n joint_weight = torch.gather(joint_weight, -1, out_idxs)\n joint_weight[joint_weight > 0.15] = 1 # threshold\n joint_weight[joint_weight < 1] = 0\n joint_weight_exp = joint_weight.unsqueeze(-1).expand(joint_weight.shape[0], joint_weight.shape[1], joint_weight.shape[1]).byte()\n\n # Target mask TODO: clean up masking\n part_mask = seg_out.clone()\n part_mask[part_mask != i] = -1\n part_mask[part_mask == i] = 1\n part_mask[part_mask == -1] = 0\n part_mask_exp = part_mask.byte().unsqueeze(1).expand(part_mask.shape[0], part_mask.shape[1], part_mask.shape[1])\n mask = joint_weight_exp & part_mask_exp\n part_dist = pc_dist.clone()\n part_dist[mask == 0] = 10\n\n d1, _ = part_dist.min(2)\n d2, _ = part_dist.min(1)\n\n # This is very hacky and I suspect it will cause all points to acquire\n # a gradient value.\n d1[d1 == 10] = 0\n d2[d2 == 10] = 0\n joint_loss.append((d1 + d2).mean())\n\n joint_loss = torch.tensor(joint_loss, device=target_pc.device)\n loss += (joint_lambda * joint_loss.mean())\n\n # Coord Loss Only\n coord_loss = F.mse_loss(preds[2], targets[0])\n loss += coord_loss\n\n # with torch.no_grad():\n # coord_loss = F.mse_loss(coords_pred, targets[0])\n\n # Physical loss\n p_loss = physical_loss(preds[6])\n loss += (physical_lambda * p_loss)\n\n return loss, coord_loss, joint_loss, chamfer_loss, p_loss","def get_loss(self, x, y):\n \"*** YOUR CODE HERE question 3 ***\"\n return nn.SoftmaxLoss(self.run(x), y)","def loss_total(self, mask):\n\n def loss(y_true, y_pred):\n\n # Compute predicted image with non-hole pixels set to ground truth\n y_comp = mask * y_true + (1-mask) * y_pred\n\n # Compute the vgg features. \n if self.vgg_device:\n with tf.device(self.vgg_device):\n vgg_out = self.vgg(y_pred)\n vgg_gt = self.vgg(y_true)\n vgg_comp = self.vgg(y_comp)\n else:\n vgg_out = self.vgg(y_pred)\n vgg_gt = self.vgg(y_true)\n vgg_comp = self.vgg(y_comp)\n \n # Compute loss components\n l1 = self.loss_valid(mask, y_true, y_pred)\n l2 = self.loss_hole(mask, y_true, y_pred)\n l3 = self.loss_perceptual(vgg_out, vgg_gt, vgg_comp)\n l4 = self.loss_tv(mask, y_comp)\n l5 = - 0.5 * K.sum(1 + self.z_log_var -self.cl - K.square(self.z_mean)/K.exp(self.cl) - K.exp(self.z_log_var)/K.exp(self.cl))\n # Return loss function\n return l1 + 6*l2 + 0.05*l3 + 0.1*l4 +l5 \n return loss","def _get_loss_weight(self) -> torch.Tensor:\n n_pos: torch.Tensor = 0.0\n n_neg: torch.Tensor = 0.0\n\n for _, ground_truth in self.train_loader:\n n_poss_curr = ground_truth.sum()\n n_pos += n_poss_curr\n n_neg += ground_truth.numel() - n_poss_curr\n\n eps = torch.finfo(n_pos.dtype).eps\n return n_neg / (n_pos + eps)","def _build_loss(self, **kwargs):\n pass","def compute_loss(self):\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.data.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def add_loss_op(self, pred):\n ### YOUR CODE HERE\n loss = cross_entropy_loss(self.labels_placeholder,pred)\n ### END YOUR CODE\n return loss","def _build_loss(self):\n self._build_loss_D()\n self._build_loss_G()\n tf.add_to_collection('losses', self.loss_D)\n tf.add_to_collection('losses', self.loss_G)","def setup_loss(self):\n with vs.variable_scope(\"loss\"):\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))","def backward_G(self):\n # Calculate regularzation loss to make transformed feature and target image feature in the same latent space\n self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization\n\n # Calculate l1 loss \n loss_app_gen = self.L1loss(self.img_gen, self.input_P2)\n self.loss_app_gen = loss_app_gen * self.opt.lambda_rec \n \n # parsing loss\n label_P2 = self.label_P2.squeeze(1).long()\n #print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())\n self.loss_par = self.parLoss(self.parsav,label_P2)# * 20. \n self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100 \n\n # Calculate GAN loss\n base_function._freeze(self.net_D)\n D_fake = self.net_D(self.img_gen)\n self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g\n\n # Calculate perceptual loss\n loss_content_gen, loss_style_gen = self.Vggloss(self.img_gen, self.input_P2) \n self.loss_style_gen = loss_style_gen*self.opt.lambda_style\n self.loss_content_gen = loss_content_gen*self.opt.lambda_content\n\n total_loss = 0\n\n for name in self.loss_names:\n if name != 'dis_img_gen':\n #print(getattr(self, \"loss_\" + name))\n total_loss += getattr(self, \"loss_\" + name)\n total_loss.backward()","def get_loss(self, xs, y):\n \"*** YOUR CODE HERE ***\"\n y_pred = self.run(xs)\n return nn.SoftmaxLoss(y_pred,y)","def cross_entropy_loss():\n return nn.CrossEntropyLoss()","def loss_fun(model: GPModel, params: dict) -> float:\n py = model.module.call(params, train_ds['index_points'])\n return -py.log_prob(train_ds['y'])","def D_loss_basic(self, netD, real, fake):\n # Real\n D_real = netD(real)\n D_real_loss = self.GANLoss(D_real, True, True)\n # fake\n D_fake = netD(fake)\n D_fake_loss = self.GANLoss(D_fake, False, True)\n # loss for discriminator\n D_loss = (D_real_loss + D_fake_loss) * 0.5\n # gradient penalty for wgan-gp\n if self.gan_mode == 'wgangp':\n gradient_penalty, gradients = base_function.cal_gradient_penalty(netD, real, fake)\n D_loss +=gradient_penalty\n\n D_loss = D_loss * self.loss_d_weight\n D_loss.backward()\n\n return D_loss","def loss_function(self, train_head, train_tail, train_relation, train_head_corrupted, train_tail_corrupted):\n\n # train_head = tf.nn.l2_normalize(train_head, 1)\n # train_tail = tf.nn.l2_normalize(train_tail, 1)\n # train_head_corrupted = tf.nn.l2_normalize(train_head_corrupted, 1)\n # train_tail_corrupted = tf.nn.l2_normalize(train_tail_corrupted, 1)\n\n # loss = tf.reduce_mean(\n # tf.maximum(self.dict_paras['margin']\n # + self.distance(tf.add(train_head, train_relation), train_tail)\n # - self.distance(tf.add(train_head_corrupted, train_relation), train_tail_corrupted), 0.))\n\n loss = tf.reduce_mean(self.distance(tf.add(train_head, train_relation), train_tail))\n\n return loss","def _create_loss(self):\n with tf.device('/cpu:0'):\n with tf.name_scope('loss'):\n self.loss = tf.reduce_mean(\n tf.nn.softmax_cross_entropy_with_logits(\n labels=self.labels_placeholder, \n logits=self.logits, name='loss'))","def loss(self, z1_rec):\n pass","def get_loss(self, inputs, outputs, add_summary=True):\n cfg = self.cfg()\n torch.autograd.set_detect_anomaly(True)\n # g_loss = tf.zeros(dtype=tf.float32, shape=[])\n g_loss = self.add_proj_loss(inputs, outputs, cfg.proj_weight, add_summary)\n r_loss = self.regularization_loss(cfg)\n# print(g_loss, r_loss)\n g_loss += r_loss\n # if cfg.proj_weight:\n # g_loss += self.add_proj_loss(inputs, outputs, cfg.proj_weight, add_summary)\n\n # if cfg.drc_weight:\n # g_loss += add_drc_loss(cfg, inputs, outputs, cfg.drc_weight, add_summary)\n #\n # if cfg.pc_rgb:\n # g_loss += add_proj_rgb_loss(cfg, inputs, outputs, cfg.proj_rgb_weight, add_summary, self._sigma_rel)\n #\n # if cfg.proj_depth_weight:\n # g_loss += add_proj_depth_loss(cfg, inputs, outputs, cfg.proj_depth_weight, self._sigma_rel, add_summary)\n #\n # if add_summary:\n # tf.contrib.summary.scalar(\"losses/total_task_loss\", g_loss)\n\n return g_loss","def loss(self, X, y):\n pass","def loss(self, y_pred: Dict[str, torch.Tensor], target: torch.Tensor) -> torch.Tensor:\n raise NotImplementedError()","def get_loss(name: str):\n if name == 'mse' or name is None:\n loss = nn.MSELoss()\n elif name == 'cp':\n loss = CosineProximityLoss()\n elif name == 'mae':\n loss = nn.L1Loss()\n elif name == 'bce':\n loss = nn.BCEWithLogitsLoss()\n else:\n raise ValueError(f'Loss function {name} not supported.')\n return loss","def reconstruction_loss(self):\n return self._reconstruction_loss","def loss_creator(config):\n return torch.nn.BCELoss()","def compute_loss(self):\n def calc_loss(inputs, outputs):\n reconstruction_loss = tf.metrics.binary_crossentropy(\n tf_flat(inputs), tf_flat(outputs))\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\n self.mu) - tf.exp(self.log_sigma), 1)\n return tf.reduce_mean(reconstruction_loss + kl_loss)\n return calc_loss","def tower_loss(scope):\n\t# Get images and flows for Flownet.\n \timg1, img2, flo = flownet_input.inputs(False, FLAGS.data_dir, FLAGS.batch_size)\n\n\t# Build a Graph that computes predictions from the inference model.\n\tlogits = flowNet.inference(img1, img2, FLAGS.batch_size)\n\n\t# Add to the Graph the Ops for loss calculation.\n\t_ = flowNet.loss(logits, flo)\n\n\t# Assemble all of the losses for the current tower only.\n\tlosses = tf.get_collection('losses', scope)\n\n\t# Calculate the total loss for the current tower.\n\ttotal_loss = tf.add_n(losses, name='total_loss')\n\n\t# Attach a scalar summary to all individual losses and the total loss; do the\n\t# same for the averaged version of the losses.\n\tfor l in losses + [total_loss]:\n\t\t# Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\n\t\t# session. This helps the clarity of presentation on tensorboard.\n\t\tloss_name = re.sub('%s_[0-9]*/' % flowNet.TOWER_NAME, '', l.op.name)\n\t\ttf.summary.scalar(loss_name, l)\n\n\treturn total_loss","def get_loss_names(self):\n losses = [tns.name[:-2].replace('loss_', '').split('/')[-1] for tns in tf.get_collection('losses')]\n return \"Losses: {}\".format(' '.join(losses))","def calculate_loss(self, output, target, **kwargs):\n ##dont do aggregation\n raise NotImplementedError","def calculate_loss(self, output, target, **kwargs):\n ##dont do aggregation\n raise NotImplementedError","def losses(self):\n # compute all kinds of losses \n\n # 1. Logits losses for classification \n\n # 2. regression loss for bbox \n\n return classification_loss, bbox_reg_loss","def loss_fn(gr_truth, pred):\n return 100 * dice_loss(pred, gr_truth) + softmax_weighted_loss(pred, gr_truth)","def compute_loss(self, x, label):\n # Forward propagation\n y_hat = self.forward_pass(x)\n return -np.log(y_hat[label])","def get_loss(self, x, y):\n \"*** YOUR CODE HERE ***\"\n y_pred = self.run(x)\n return nn.SoftmaxLoss(y_pred,y)","def define_loss(self, loss_exp):\n\n raise NotImplementedError","def log_loss(self):\n probabilities = self.probability_array().copy()\n # need to flip the probabilities for p < 0.5 with this binary case.\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\n probabilities[np.equal(0, self.y)] *= -1\n probabilities[np.equal(0, self.y)] += 1\n # when multiclass: np.amax(probabilities, 1)\n return np.log(probabilities).sum()","def _classification_loss(self, logits, labels, num_classes):\n labels = tf.to_int64(labels)\n onehot_labels = tf.one_hot(labels, num_classes)\n with tf.name_scope('finetuning_loss'):\n cross_entropy = tf.losses.softmax_cross_entropy(\n onehot_labels=onehot_labels, logits=logits)\n cross_entropy = tf.reduce_mean(cross_entropy)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy + self.weight_decay * regularization\n return loss","def but_test(self):\n if not self.path:\n tk.messagebox.showerror(\"Error\", \"Open file first\")\n return\n elif not self.nn_obj:\n tk.messagebox.showerror(\"Error\", \"Create or open NN\")\n return\n elif not self.nn_obj and not self.nn_in:\n tk.messagebox.showerror(\"Error\", \"Open file and create NN\")\n return\n if isinstance(self.nn_obj, dict):\n y_pred=pred(self.nn_obj, self.nn_in).reshape(self.nn_out.shape)\n test_loss=loss(y_pred, self.nn_out, self.nn_obj) \n elif isinstance(self.nn_obj, Net_tr):\n y_pred=pred(self.nn_obj, self.nn_in)\n test_loss=loss(y_pred, self.nn_out, self.nn_obj).item()\n tk.messagebox.showinfo(\"Loss\", \"Loss=\" + str(test_loss)+\" %\")","def loss(self, X, y=None):\n\n # In dev testing, the loss fnc stops at \"scores\" , unfollowed by \"softmax\" probability prediction.\n # In real testing, \"self.predict()\" needs to be implemented in Solver() class.\n \n if y is None:\n for bn_param in self.bn_params:\n bn_param[\"mode\"] = \"test\"\n\n\n W1, b1 = self.params['W1'], self.params['b1']\n gamma1, beta1 = self.params[\"sbnGamma1\"], self.params[\"sbnBeta1\"]\n bn_param1 = self.bn_params[0]\n\n W2, b2 = self.params['W2'], self.params['b2']\n gamma2, beta2 = self.params[\"sbnGamma2\"], self.params[\"sbnBeta2\"]\n bn_param2 = self.bn_params[1]\n\n W3, b3 = self.params['W3'], self.params['b3']\n gamma3, beta3 = self.params[\"bnGamma3\"], self.params[\"bnBeta3\"]\n bn_param3 = self.bn_params[2]\n\n W4, b4 = self.params['W4'], self.params['b4']\n \n # pass conv_param to the forward pass for the convolutional layer\n conv_param = self.conv_param\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = self.maxpool_params\n\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n \n scores = None \n cache = {}\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\n out, cache[\"layer1\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \n out, cache[\"layer2\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\n\n # def max_pool_forward_fast(x, pool_param): return out, cache;\n out, cache[\"maxpool\"] = fast_layers.max_pool_forward_fast(out, pool_param)\n\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\n \n out, cache[\"layer3\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\n\n # def affine_forward(x, w, b): return out, cache;\n scores, cache[\"layer4\"] = layers.affine_forward(out, W4, b4)\n\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n if y is None:\n return scores\n \n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n \n loss, grads = 0, {}\n\n # def softmax_loss(x, y): return loss, dscore;\n loss, dscores = layers.softmax_loss(scores, y)\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\n\n # def affine_backward(dout, cache): return dx, dw, db;\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\"layer4\"]) \n\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\"layer3\"])\n\n # print cache[\"layer3\"]\n\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\n # def max_pool_backward_im2col(dout, cache): return dx;\n dout = fast_layers.max_pool_backward_fast(dout, cache[\"maxpool\"])\n\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer2\"])\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer1\"])\n\n # reg\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\n \n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\n grads[\"bnGamma3\"], grads[\"bnBeta3\"] = dgamma3, dbeta3\n\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\n grads[\"sbnGamma2\"], grads[\"sbnBeta2\"] = dgamma2, dbeta2\n\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\n grads[\"sbnGamma1\"], grads[\"sbnBeta1\"] = dgamma1, dbeta1\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n return loss, grads"],"string":"[\n \"def _get_loss(self):\\n raise NotImplementedError\",\n \"def get_loss(self):\\n raise NotImplementedError\",\n \"def compute_loss(self):\",\n \"def loss(self):\\n return self._loss\",\n \"def loss(self) -> KernelLoss:\\n return self._loss\",\n \"def loss(self):\\n return self._get(\\\"loss\\\")\",\n \"def loss(self, **kwargs):\\n pass\",\n \"def loss_op(self):\\n return self.loss\",\n \"def add_loss(self):\\n \\n raise RuntimeError(\\\"Must define function add_loss(self)\\\")\",\n \"def _get_loss_fn(self):\\n msg = (\\n \\\"Abstract class: _get_loss_fn() must be implemented by a child \\\"\\n \\\"class of Classifier.\\\"\\n )\\n raise NotImplementedError(msg)\",\n \"def get_loss(self):\\r\\n\\r\\n if F.loss_type==\\\"cosine\\\":\\r\\n self.losscos = r2d*tf.acos(1-tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1))\\r\\n self.loss = tf.losses.cosine_distance(tf.nn.l2_normalize(self.labels,1), tf.nn.l2_normalize(self.out, 1), dim=1)\\r\\n elif F.loss_type==\\\"mse2d\\\":\\r\\n xl, yl, zl = tf.split(self.labels, 3, axis=1)\\r\\n xo, yo, zo = tf.split(self.out, 3, axis=1)\\r\\n thetal, thetao = tf.asin(-yl), tf.asin(-yo)\\r\\n phil, phio = tf.atan2(-zl, -xl), tf.atan2(-zo, -xo)\\r\\n self.lb = tf.concat([thetal, phil], axis=1)\\r\\n self.ob = tf.concat([thetao, phio], axis=1)\\r\\n self.loss = tf.scalar_mul(tf.constant(r2d), tf.losses.mean_squared_error(self.lb, self.ob, 2))\\r\\n elif F.loss_type==\\\"mse3d\\\":\\r\\n self.loss = tf.losses.mean_squared_error(tf.nn.l2_normalize(self.labels, 0), tf.nn.l2_normalize(self.out, 0))\",\n \"def genLoss(self, *data):\\r\\n _, (x_unlab, _) = data\\r\\n z = self.getInputNoise(self.hypers['ul_BS'])\\r\\n fake_logits = self.D(self.G(z))\\r\\n g_losses = -1*logOneMinusSoftmax(fake_logits)[:,self.D.numClasses-1]\\r\\n return torch.mean(g_losses)\",\n \"def _loss_out(self, e_out):\\n prior_out = 1 # self.prior\\n\\n if self.loss_type_out == 'exponential':\\n loss = torch.sum(e_out, -1, keepdim=True)\\n\\n elif self.loss_type_out == 'chi_squared':\\n a_out = e_out + prior_out\\n df = prior_out + 2\\n loss = torch.sum((df / 2 - 1) * torch.log(a_out) + a_out / 2, dim=-1, keepdim=True)\\n\\n elif self.loss_type_out == 'uncertainty':\\n S_out = (e_out + prior_out).sum(-1, keepdim=True)\\n unc = self.n_classes / S_out\\n loss = -unc\\n\\n elif self.loss_type_out == 'kl':\\n a_out = e_out + prior_out\\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\\n kl = kl_dirichlet(a_out, a_target)\\n loss = kl\\n\\n elif self.loss_type_out == 'kl_reverse':\\n a_out = e_out + prior_out\\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\\n kl = kl_dirichlet(a_target, a_out)\\n loss = kl\\n\\n elif self.loss_type_out == 'kl_symmetric':\\n a_out = e_out + prior_out\\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\\n kl = .5*(kl_dirichlet(a_out, a_target) + kl_dirichlet(a_target, a_out))\\n loss = kl\\n\\n elif self.loss_type_out == 'chernoff_distance':\\n a_out = e_out + prior_out\\n a_target = torch.full(a_out.size(), prior_out, dtype=float, device=e_out.device)\\n dist = chernoff_distance(a_out, a_target)\\n loss = dist\\n\\n return loss\",\n \"def get_loss_fn(self):\\n raise NotImplementedError()\",\n \"def get_loss(self):\\n return self.loss / self.cnt\",\n \"def compute_loss(self):\\n self.prototypes = self.compute_prototypes()\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.episode.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def loss_names(self):\\n return ['loss']\",\n \"def loss_weights(self):\\n return None\",\n \"def loss_(self, batch):\\n raise NotImplementedError\",\n \"def loss(self, X, labels):\\n features = self.get_conv_feats(X)\\n loss = blah\\n return loss\",\n \"def loss(self, X, labels):\\n features = self.get_conv_features(X)\\n loss = blah\\n return loss\",\n \"def setup_loss(self):\\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\\n #self.loss = nn.CrossEntropyLoss()\",\n \"def loss(self):\\n if not self.run:\\n self._run()\\n return self.model_loss\",\n \"def get_loss(self, Loss, results, inputs, device):\\n return\",\n \"def get_loss_fn():\\n return reconstruction\",\n \"def loss(self):\\n return 'mse'\",\n \"def build_loss(self):\\n if self.mode != \\\"encode\\\":\\n total_loss = tf.losses.get_total_loss()\\n tf.summary.scalar(\\\"losses/total\\\", total_loss)\\n\\n self.total_loss = total_loss\",\n \"def _init_loss(self) -> None:\\n labels_one_hot = tf.one_hot(self.labels, depth=Data.num_classes)\\n cross_entropy_loss = tf.losses.softmax_cross_entropy(labels_one_hot, self.logits)\\n # cross_entropy_loss is a scalar\\n tf.add_to_collection(tf.GraphKeys.LOSSES, cross_entropy_loss)\\n self.loss = tf.add_n(tf.get_collection(tf.GraphKeys.LOSSES))\\n self.logger_factory.add_scalar('loss', self.loss, log_frequency=10)\\n self.logger_factory.add_scalar('cross_entropy_loss', cross_entropy_loss, log_frequency=25)\",\n \"def lfads_training_loss(params, lfads_hps, key, x_bxt, kl_scale, keep_rate):\\n losses = lfads_losses(params, lfads_hps, key, x_bxt, kl_scale, keep_rate)\\n return losses['total']\",\n \"def compute_loss(self, **kwargs):\\n raise NotImplementedError\",\n \"def losses(self):\\n pass\",\n \"def configure_loss_fn(self) -> nn.Module:\\n pass\",\n \"def loss(self, T, mode):\\n self.circuit.loss(T, mode)\",\n \"def _loss(self):\\n\\n cross_entropy = tf.reduce_mean(-tf.log(self.probability + epsilon) * self.y)\\n self.loss = cross_entropy\\n\\n self.accuracy = tf.reduce_mean(\\n tf.cast(tf.equal(tf.argmax(self.y, 1), self.prediction), tf.float32))\",\n \"def logloss(self,tple):\\n feats = self.dataset.input_features\\n res = 0\\n cc = self.class_counts\\n fc = self.feature_counts\\n for c in range(self.num_classes):\\n res += prod(fc[i][feat(tple)][c]\\n for (i,feat) in enumerate(feats))/(cc[c]**(len(feats)-1))\\n if res>0:\\n return -math.log2(res/len(self.dataset.train))\\n else:\\n return float(\\\"inf\\\") #infinity\",\n \"def _create_loss(self):\\n\\n with tf.name_scope(\\\"loss\\\"):\\n \\n # gini=(tf.nn.l2_loss( self.score))/100000\\n gini = tf.losses.softmax_cross_entropy(self.score, 0*self.score)\\n \\n promo_prob=tf.reduce_sum(tf.multiply(self.score, self.cohort_weight),\\n axis=1)\\n inc_value = tf.reduce_mean(tf.multiply(promo_prob, self.value))- self.control_value\\n inc_cost = tf.reduce_mean( tf.multiply(promo_prob, self.cost)) - self.control_cost\\n \\n\\n\\n # determine loss function based on self.obj_rule\\n if self.obj_rule == 'cpiv':\\n self.objective = inc_cost / inc_value\\n\\n elif self.obj_rule == 'ivc':\\n # maximize ivc\\n self.objective = - inc_value / inc_cost\\n\\n elif self.obj_rule == 'lagrangian':\\n assert self.shadow is not None, 'Need to pass in shadow value if use lagrangian as obj_rule.'\\n self.objective = inc_cost - self.shadow * inc_value\\n\\n elif self.obj_rule == 'value':\\n # maximize delta values\\n self.objective = - inc_value\\n\\n # use only cost as objective\\n elif self.obj_rule == 'cost':\\n # maximize delta cost\\n self.objective = - inc_cost\\n\\n else:\\n raise Exception('Invalid obj_rule!')\\n\\n # regularization\\n reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n # weights = tf.trainable_variables() # all vars of your graph\\n # reg_loss = tf.norm( weights,ord=1)\\n\\n # final loss\\n self.loss = self.objective +reg_loss+.1*gini\",\n \"def loss(self, forward, rating):\\n return self.loss_fn(forward, rating.float().view(-1))\",\n \"def getLoss(self, x_test, t_test):\\n x_t = Variable(x_test, requires_grad=False)\\n #Feed inputes into neural network\\n t_pred = self.model(x_t)\\n #Now lets compute out loss\\n loss = self.loss_fn(t_pred, t_test)\\n return loss\",\n \"def profit_loss(self) -> float:\\n return self.net_worth / self.initial_net_worth\",\n \"def compute_loss(self, features, mode, params, precomputed):\\n raise NotImplementedError(\\\"Model does not implement loss.\\\")\",\n \"def model_loss(inp, fake, real_label, fake_label):\\n \\n \\n Dreal,realcls,R1 = gradpen(inp)\\n [Dfake,fakecls] = D(fake)\\n # 1. Adversarial loss\\n \\n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\\n \\n \\n \\n # D has no sigmoid activation: \\\"from_logits=True\\\"\\n real_loss = tf.keras.losses.binary_crossentropy(\\n dlabelr, Dreal, from_logits=True)\\n real_loss = tf.reduce_mean(real_loss)\\n \\n fake_loss = tf.keras.losses.binary_crossentropy(\\n dlabelf, Dfake, from_logits=True)\\n fake_loss = tf.reduce_mean(fake_loss)\\n \\n Dadv = 0.5*(real_loss+fake_loss)\\n \\n Gadv = tf.keras.losses.binary_crossentropy(\\n glabel, Dfake, from_logits=True)\\n Gadv = tf.reduce_mean(Gadv)\\n \\n # 2. Classification loss\\n \\n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\\n Dcls = tf.reduce_mean(Dcls)\\n \\n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\\n Gcls = tf.reduce_mean(Gcls)\\n \\n # 3. Total loss\\n \\n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\\n \\n Gloss = Gadv + LAMBDA_CLS*Gcls\\n \\n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)\",\n \"def _initLoss(self):\\n\\n pass\",\n \"def get_loss(self, xs, y):\\n \\\"*** YOUR CODE HERE question 4 ***\\\"\\n return nn.SoftmaxLoss(self.run(xs), y)\",\n \"def compute_loss(self, obs, returns):\",\n \"def get_probability_loss(self):\\n return sum(self._loss)/len(self._loss)\",\n \"def loss(self, prediction_dict, groundtruth_lists):\\r\\n pass\",\n \"def loss(self, X, y):\\n\\n # Initialize the loss to zero.\\n loss = 0.0\\n num_classes = self.W.shape[0] # C = num_classes\\n num_train = X.shape[0]\\n \\n exp_a = np.zeros((num_classes,num_train))\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the normalized softmax loss. Store it as the variable loss.\\n # (That is, calculate the sum of the losses of all the training \\n # set margins, and then normalize the loss by the number of \\n # training examples.)\\n # ================================================================ #\\n \\n \\n for i in np.arange(num_train):\\n \\n Loss = 0.0\\n\\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\\n\\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\\n\\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\\n \\n\\n #p[:,i] = exp_a[:,i]/np.sum(exp_a[:,i]) # p now is a valid probability matrix\\n #print(p[:,i])\\n\\n loss += Loss \\n #print(Loss,i) \\n \\n pass\\n loss /= num_train\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss\",\n \"def _initLoss(self):\\n\\n return torch.nn.MSELoss()\",\n \"def compute_loss(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def loss(self, y: torch.Tensor, state: AlgorithmState) -> torch.Tensor:\\n\\n raise NotImplementedError()\",\n \"def loss(self, T, mode):\\n self.circuit.loss(T, self._remap_modes(mode))\",\n \"def hpm_loss(self, x, y, t, Ex_u, Ex_v):\\n\\n x = x.view(-1)\\n y = y.view(-1)\\n t = t.view(-1)\\n\\n u, v, f_u, f_v = self.net_pde(x, y, t)\\n\\n Ex_u = Ex_u.view(-1)\\n Ex_v = Ex_v.view(-1)\\n\\n hpmLoss = torch.mean(f_u ** 2) + torch.mean(f_v ** 2) + torch.mean((u - Ex_u) ** 2) + torch.mean((v - Ex_v) ** 2) \\n return hpmLoss\",\n \"def compute_loss(self, x, gt):\\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\\n return loss\",\n \"def detector_loss(self, input, target, mask=None, loss_type=\\\"softmax\\\"):\\n if loss_type == \\\"l2\\\":\\n loss_func = nn.MSELoss(reduction=\\\"mean\\\")\\n loss = loss_func(input, target)\\n elif loss_type == \\\"softmax\\\":\\n loss_func_BCE = nn.BCELoss(reduction='none').cuda()\\n loss = loss_func_BCE(nn.functional.softmax(input, dim=1), target)\\n loss = (loss.sum(dim=1) * mask).sum()\\n loss = loss / (mask.sum() + 1e-10)\\n return loss\",\n \"def add_loss_op(self, preds):\\n ### YOUR CODE HERE (~2-4 lines)\\n trans = tf.get_variable('trans',\\n shape=[Config.n_classes, Config.n_classes],\\n initializer=tf.contrib.layers.xavier_initializer())\\n log_likelihood, _ = crf_log_likelihood(preds,\\n self.labels_placeholder,\\n self.length_placeholder,\\n trans)\\n #log_likelihood = tf.boolean_mask(log_likelihood, self.mask_placeholder)\\n loss = tf.reduce_mean(-1.0 * log_likelihood)\\n \\n ### END YOUR CODE\\n return trans, loss\",\n \"def loss(self):\\n return la.norm(self.resids) / self.normX\",\n \"def loss(returns, predicted_output):\\n ################################\\n # YOUR IMPLEMENTATION HERE #\\n ################################\\n raise NotImplementedError\",\n \"def _auxiliary_loss(self, expert_mask, router_prob):\\n # density_1's shape: (dp_group, self.expert_dim)\\n density_1 = self.reduce_mean(expert_mask, 1)\\n # density_1_proxy's shape: (dp_group, self.expert_dim)\\n density_1_proxy = self.reduce_mean2(router_prob, 1)\\n loss = self.mul(density_1, density_1_proxy)\\n loss = self.reduce_mean3(loss)\\n loss = self.mul3(self.mul2(loss, self.expert_dim), self.expert_dim)\\n return loss\",\n \"def loss_fn(self, targets, outputs, model):\",\n \"def loss(self, input_data, fwd_out):\\n logger.debug(\\\"GumBolt::loss\\\")\\n \\n kl_loss, cross_entropy, pos_energy, neg_energy = self.kl_divergence(fwd_out.post_logits,\\n fwd_out.post_samples)\\n \\n ae_loss_matrix = -fwd_out.output_distribution.log_prob_per_var(input_data.view(-1, self._flat_input_size))\\n ae_loss_per_sample = torch.sum(ae_loss_matrix,1)\\n ae_loss = torch.mean(ae_loss_per_sample)\\n \\n loss = ae_loss + kl_loss\\n \\n return {\\\"loss\\\":loss, \\\"ae_loss\\\":ae_loss, \\\"kl_loss\\\":kl_loss,\\n \\\"cross_entropy\\\":cross_entropy, \\\"pos_energy\\\":pos_energy, \\\"neg_energy\\\":neg_energy}\",\n \"def get_loss(self, xs, y):\\n \\\"*** YOUR CODE HERE ***\\\"\\n predictedY = self.run(xs)\\n return nn.SoftmaxLoss(predictedY, y)\\n # return nn.SquareLoss(predictedY, y)\",\n \"def get_loss(self):\\n return categorical_cross_entropy.get_loss(loss_key=self.loss_key,\\n output_name=self.args.output_name)\",\n \"def ss_loss_(self, batch):\\n raise NotImplementedError\",\n \"def verbose_loss(self, feedback: _Feedback, extra_info) -> Dict[str, _Array]:\\n hint_preds, diff_logits, gt_diffs = extra_info\\n\\n for inp in feedback.features.inputs:\\n if inp.location in [_Location.NODE, _Location.EDGE]:\\n nb_nodes = inp.data.shape[1]\\n break\\n\\n total_loss = 0.0\\n lengths = feedback.features.lengths\\n\\n losses = {}\\n if self.decode_diffs:\\n for loc in _Location:\\n for i in range(len(gt_diffs)):\\n is_not_done = _is_not_done_broadcast(lengths, i, gt_diffs[i][loc])\\n diff_loss = (\\n jnp.maximum(diff_logits[i][loc], 0) -\\n diff_logits[i][loc] * gt_diffs[i][loc] +\\n jnp.log1p(jnp.exp(-jnp.abs(diff_logits[i][loc]))) * is_not_done)\\n losses[loc.name + '_diff_%d' % i] = jnp.mean(diff_loss)\\n\\n if self.decode_hints:\\n for truth in feedback.features.hints:\\n for i in range(truth.data.shape[0] - 1):\\n assert truth.name in hint_preds[i]\\n pred = hint_preds[i][truth.name]\\n is_not_done = _is_not_done_broadcast(lengths, i, truth.data[i + 1])\\n if truth.type_ == _Type.SCALAR:\\n if self.decode_diffs:\\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 *\\n gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean((pred - truth.data[i + 1])**2 * is_not_done)\\n elif truth.type_ == _Type.MASK:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\\n jnp.log1p(jnp.exp(-jnp.abs(pred))) *\\n gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean(\\n jnp.maximum(pred, 0) - pred * truth.data[i + 1] +\\n jnp.log1p(jnp.exp(-jnp.abs(pred))) * is_not_done)\\n elif truth.type_ == _Type.MASK_ONE:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n -jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred) * is_not_done, axis=-1, keepdims=True) *\\n gt_diffs[i][truth.location])\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred) * is_not_done, axis=-1))\\n elif truth.type_ == _Type.CATEGORICAL:\\n if self.decode_diffs:\\n total_loss = jnp.mean(\\n -jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(\\n pred), axis=-1, keepdims=True) *\\n jnp.expand_dims(gt_diffs[i][truth.location], -1) *\\n is_not_done)\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n truth.data[i + 1] * jax.nn.log_softmax(pred), axis=-1) *\\n is_not_done)\\n elif truth.type_ == _Type.POINTER:\\n if self.decode_diffs:\\n total_loss = jnp.mean(-jnp.sum(\\n hk.one_hot(truth.data[i + 1], nb_nodes) *\\n jax.nn.log_softmax(pred),\\n axis=-1) * gt_diffs[i][truth.location] * is_not_done)\\n else:\\n total_loss = jnp.mean(-jnp.sum(\\n hk.one_hot(truth.data[i + 1], nb_nodes) *\\n jax.nn.log_softmax(pred),\\n axis=-1) * is_not_done)\\n else:\\n raise ValueError('Incorrect type')\\n losses[truth.name + '_%d' % i] = total_loss\\n return losses\",\n \"def pointnet_loss(preds, targets, chamfer_lambda, physical_lambda, joint_lambda, has_anno=None, joint_idxs=None):\\n\\n gen_pc = preds[0]\\n out_idxs = preds[1]\\n coords_pred = preds[2]\\n seg_out = preds[8]\\n seg_out = seg_out.argmin(-1)\\n bone_weights = preds[9]\\n target_pc = targets[1]\\n\\n if joint_idxs is not None:\\n bone_weights = bone_weights[joint_idxs]\\n if has_anno is not None:\\n coords_pred = coords_pred[has_anno]\\n if joint_idxs is not None:\\n coords_pred = coords_pred[:, joint_idxs]\\n\\n # Chamfer loss\\n N = gen_pc.shape[1]\\n M = target_pc.shape[1]\\n\\n pc1_expand = gen_pc.unsqueeze(2).repeat(1, 1, M, 1)\\n pc2_expand = target_pc.unsqueeze(1).repeat(1, N, 1, 1)\\n pc_diff = pc1_expand - pc2_expand\\n pc_dist = (pc_diff ** 2).sum(-1)\\n pc_dist = torch.sqrt(pc_dist)\\n dist1, idx1 = pc_dist.min(2)\\n dist2, idx2 = pc_dist.min(1)\\n chamfer_loss = (dist1 + dist2).mean()\\n loss = chamfer_lambda * chamfer_loss\\n\\n # Joint loss\\n joint_loss = []\\n for i in range(bone_weights.shape[0]):\\n # Gen mask\\n joint_weight = bone_weights[i]\\n joint_weight = joint_weight.unsqueeze(0).expand(coords_pred.shape[0], -1)\\n joint_weight = torch.gather(joint_weight, -1, out_idxs)\\n joint_weight[joint_weight > 0.15] = 1 # threshold\\n joint_weight[joint_weight < 1] = 0\\n joint_weight_exp = joint_weight.unsqueeze(-1).expand(joint_weight.shape[0], joint_weight.shape[1], joint_weight.shape[1]).byte()\\n\\n # Target mask TODO: clean up masking\\n part_mask = seg_out.clone()\\n part_mask[part_mask != i] = -1\\n part_mask[part_mask == i] = 1\\n part_mask[part_mask == -1] = 0\\n part_mask_exp = part_mask.byte().unsqueeze(1).expand(part_mask.shape[0], part_mask.shape[1], part_mask.shape[1])\\n mask = joint_weight_exp & part_mask_exp\\n part_dist = pc_dist.clone()\\n part_dist[mask == 0] = 10\\n\\n d1, _ = part_dist.min(2)\\n d2, _ = part_dist.min(1)\\n\\n # This is very hacky and I suspect it will cause all points to acquire\\n # a gradient value.\\n d1[d1 == 10] = 0\\n d2[d2 == 10] = 0\\n joint_loss.append((d1 + d2).mean())\\n\\n joint_loss = torch.tensor(joint_loss, device=target_pc.device)\\n loss += (joint_lambda * joint_loss.mean())\\n\\n # Coord Loss Only\\n coord_loss = F.mse_loss(preds[2], targets[0])\\n loss += coord_loss\\n\\n # with torch.no_grad():\\n # coord_loss = F.mse_loss(coords_pred, targets[0])\\n\\n # Physical loss\\n p_loss = physical_loss(preds[6])\\n loss += (physical_lambda * p_loss)\\n\\n return loss, coord_loss, joint_loss, chamfer_loss, p_loss\",\n \"def get_loss(self, x, y):\\n \\\"*** YOUR CODE HERE question 3 ***\\\"\\n return nn.SoftmaxLoss(self.run(x), y)\",\n \"def loss_total(self, mask):\\n\\n def loss(y_true, y_pred):\\n\\n # Compute predicted image with non-hole pixels set to ground truth\\n y_comp = mask * y_true + (1-mask) * y_pred\\n\\n # Compute the vgg features. \\n if self.vgg_device:\\n with tf.device(self.vgg_device):\\n vgg_out = self.vgg(y_pred)\\n vgg_gt = self.vgg(y_true)\\n vgg_comp = self.vgg(y_comp)\\n else:\\n vgg_out = self.vgg(y_pred)\\n vgg_gt = self.vgg(y_true)\\n vgg_comp = self.vgg(y_comp)\\n \\n # Compute loss components\\n l1 = self.loss_valid(mask, y_true, y_pred)\\n l2 = self.loss_hole(mask, y_true, y_pred)\\n l3 = self.loss_perceptual(vgg_out, vgg_gt, vgg_comp)\\n l4 = self.loss_tv(mask, y_comp)\\n l5 = - 0.5 * K.sum(1 + self.z_log_var -self.cl - K.square(self.z_mean)/K.exp(self.cl) - K.exp(self.z_log_var)/K.exp(self.cl))\\n # Return loss function\\n return l1 + 6*l2 + 0.05*l3 + 0.1*l4 +l5 \\n return loss\",\n \"def _get_loss_weight(self) -> torch.Tensor:\\n n_pos: torch.Tensor = 0.0\\n n_neg: torch.Tensor = 0.0\\n\\n for _, ground_truth in self.train_loader:\\n n_poss_curr = ground_truth.sum()\\n n_pos += n_poss_curr\\n n_neg += ground_truth.numel() - n_poss_curr\\n\\n eps = torch.finfo(n_pos.dtype).eps\\n return n_neg / (n_pos + eps)\",\n \"def _build_loss(self, **kwargs):\\n pass\",\n \"def compute_loss(self):\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.data.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def add_loss_op(self, pred):\\n ### YOUR CODE HERE\\n loss = cross_entropy_loss(self.labels_placeholder,pred)\\n ### END YOUR CODE\\n return loss\",\n \"def _build_loss(self):\\n self._build_loss_D()\\n self._build_loss_G()\\n tf.add_to_collection('losses', self.loss_D)\\n tf.add_to_collection('losses', self.loss_G)\",\n \"def setup_loss(self):\\n with vs.variable_scope(\\\"loss\\\"):\\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))\",\n \"def backward_G(self):\\n # Calculate regularzation loss to make transformed feature and target image feature in the same latent space\\n self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization\\n\\n # Calculate l1 loss \\n loss_app_gen = self.L1loss(self.img_gen, self.input_P2)\\n self.loss_app_gen = loss_app_gen * self.opt.lambda_rec \\n \\n # parsing loss\\n label_P2 = self.label_P2.squeeze(1).long()\\n #print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())\\n self.loss_par = self.parLoss(self.parsav,label_P2)# * 20. \\n self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100 \\n\\n # Calculate GAN loss\\n base_function._freeze(self.net_D)\\n D_fake = self.net_D(self.img_gen)\\n self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g\\n\\n # Calculate perceptual loss\\n loss_content_gen, loss_style_gen = self.Vggloss(self.img_gen, self.input_P2) \\n self.loss_style_gen = loss_style_gen*self.opt.lambda_style\\n self.loss_content_gen = loss_content_gen*self.opt.lambda_content\\n\\n total_loss = 0\\n\\n for name in self.loss_names:\\n if name != 'dis_img_gen':\\n #print(getattr(self, \\\"loss_\\\" + name))\\n total_loss += getattr(self, \\\"loss_\\\" + name)\\n total_loss.backward()\",\n \"def get_loss(self, xs, y):\\n \\\"*** YOUR CODE HERE ***\\\"\\n y_pred = self.run(xs)\\n return nn.SoftmaxLoss(y_pred,y)\",\n \"def cross_entropy_loss():\\n return nn.CrossEntropyLoss()\",\n \"def loss_fun(model: GPModel, params: dict) -> float:\\n py = model.module.call(params, train_ds['index_points'])\\n return -py.log_prob(train_ds['y'])\",\n \"def D_loss_basic(self, netD, real, fake):\\n # Real\\n D_real = netD(real)\\n D_real_loss = self.GANLoss(D_real, True, True)\\n # fake\\n D_fake = netD(fake)\\n D_fake_loss = self.GANLoss(D_fake, False, True)\\n # loss for discriminator\\n D_loss = (D_real_loss + D_fake_loss) * 0.5\\n # gradient penalty for wgan-gp\\n if self.gan_mode == 'wgangp':\\n gradient_penalty, gradients = base_function.cal_gradient_penalty(netD, real, fake)\\n D_loss +=gradient_penalty\\n\\n D_loss = D_loss * self.loss_d_weight\\n D_loss.backward()\\n\\n return D_loss\",\n \"def loss_function(self, train_head, train_tail, train_relation, train_head_corrupted, train_tail_corrupted):\\n\\n # train_head = tf.nn.l2_normalize(train_head, 1)\\n # train_tail = tf.nn.l2_normalize(train_tail, 1)\\n # train_head_corrupted = tf.nn.l2_normalize(train_head_corrupted, 1)\\n # train_tail_corrupted = tf.nn.l2_normalize(train_tail_corrupted, 1)\\n\\n # loss = tf.reduce_mean(\\n # tf.maximum(self.dict_paras['margin']\\n # + self.distance(tf.add(train_head, train_relation), train_tail)\\n # - self.distance(tf.add(train_head_corrupted, train_relation), train_tail_corrupted), 0.))\\n\\n loss = tf.reduce_mean(self.distance(tf.add(train_head, train_relation), train_tail))\\n\\n return loss\",\n \"def _create_loss(self):\\n with tf.device('/cpu:0'):\\n with tf.name_scope('loss'):\\n self.loss = tf.reduce_mean(\\n tf.nn.softmax_cross_entropy_with_logits(\\n labels=self.labels_placeholder, \\n logits=self.logits, name='loss'))\",\n \"def loss(self, z1_rec):\\n pass\",\n \"def get_loss(self, inputs, outputs, add_summary=True):\\n cfg = self.cfg()\\n torch.autograd.set_detect_anomaly(True)\\n # g_loss = tf.zeros(dtype=tf.float32, shape=[])\\n g_loss = self.add_proj_loss(inputs, outputs, cfg.proj_weight, add_summary)\\n r_loss = self.regularization_loss(cfg)\\n# print(g_loss, r_loss)\\n g_loss += r_loss\\n # if cfg.proj_weight:\\n # g_loss += self.add_proj_loss(inputs, outputs, cfg.proj_weight, add_summary)\\n\\n # if cfg.drc_weight:\\n # g_loss += add_drc_loss(cfg, inputs, outputs, cfg.drc_weight, add_summary)\\n #\\n # if cfg.pc_rgb:\\n # g_loss += add_proj_rgb_loss(cfg, inputs, outputs, cfg.proj_rgb_weight, add_summary, self._sigma_rel)\\n #\\n # if cfg.proj_depth_weight:\\n # g_loss += add_proj_depth_loss(cfg, inputs, outputs, cfg.proj_depth_weight, self._sigma_rel, add_summary)\\n #\\n # if add_summary:\\n # tf.contrib.summary.scalar(\\\"losses/total_task_loss\\\", g_loss)\\n\\n return g_loss\",\n \"def loss(self, X, y):\\n pass\",\n \"def loss(self, y_pred: Dict[str, torch.Tensor], target: torch.Tensor) -> torch.Tensor:\\n raise NotImplementedError()\",\n \"def get_loss(name: str):\\n if name == 'mse' or name is None:\\n loss = nn.MSELoss()\\n elif name == 'cp':\\n loss = CosineProximityLoss()\\n elif name == 'mae':\\n loss = nn.L1Loss()\\n elif name == 'bce':\\n loss = nn.BCEWithLogitsLoss()\\n else:\\n raise ValueError(f'Loss function {name} not supported.')\\n return loss\",\n \"def reconstruction_loss(self):\\n return self._reconstruction_loss\",\n \"def loss_creator(config):\\n return torch.nn.BCELoss()\",\n \"def compute_loss(self):\\n def calc_loss(inputs, outputs):\\n reconstruction_loss = tf.metrics.binary_crossentropy(\\n tf_flat(inputs), tf_flat(outputs))\\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\\n self.mu) - tf.exp(self.log_sigma), 1)\\n return tf.reduce_mean(reconstruction_loss + kl_loss)\\n return calc_loss\",\n \"def tower_loss(scope):\\n\\t# Get images and flows for Flownet.\\n \\timg1, img2, flo = flownet_input.inputs(False, FLAGS.data_dir, FLAGS.batch_size)\\n\\n\\t# Build a Graph that computes predictions from the inference model.\\n\\tlogits = flowNet.inference(img1, img2, FLAGS.batch_size)\\n\\n\\t# Add to the Graph the Ops for loss calculation.\\n\\t_ = flowNet.loss(logits, flo)\\n\\n\\t# Assemble all of the losses for the current tower only.\\n\\tlosses = tf.get_collection('losses', scope)\\n\\n\\t# Calculate the total loss for the current tower.\\n\\ttotal_loss = tf.add_n(losses, name='total_loss')\\n\\n\\t# Attach a scalar summary to all individual losses and the total loss; do the\\n\\t# same for the averaged version of the losses.\\n\\tfor l in losses + [total_loss]:\\n\\t\\t# Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\\n\\t\\t# session. This helps the clarity of presentation on tensorboard.\\n\\t\\tloss_name = re.sub('%s_[0-9]*/' % flowNet.TOWER_NAME, '', l.op.name)\\n\\t\\ttf.summary.scalar(loss_name, l)\\n\\n\\treturn total_loss\",\n \"def get_loss_names(self):\\n losses = [tns.name[:-2].replace('loss_', '').split('/')[-1] for tns in tf.get_collection('losses')]\\n return \\\"Losses: {}\\\".format(' '.join(losses))\",\n \"def calculate_loss(self, output, target, **kwargs):\\n ##dont do aggregation\\n raise NotImplementedError\",\n \"def calculate_loss(self, output, target, **kwargs):\\n ##dont do aggregation\\n raise NotImplementedError\",\n \"def losses(self):\\n # compute all kinds of losses \\n\\n # 1. Logits losses for classification \\n\\n # 2. regression loss for bbox \\n\\n return classification_loss, bbox_reg_loss\",\n \"def loss_fn(gr_truth, pred):\\n return 100 * dice_loss(pred, gr_truth) + softmax_weighted_loss(pred, gr_truth)\",\n \"def compute_loss(self, x, label):\\n # Forward propagation\\n y_hat = self.forward_pass(x)\\n return -np.log(y_hat[label])\",\n \"def get_loss(self, x, y):\\n \\\"*** YOUR CODE HERE ***\\\"\\n y_pred = self.run(x)\\n return nn.SoftmaxLoss(y_pred,y)\",\n \"def define_loss(self, loss_exp):\\n\\n raise NotImplementedError\",\n \"def log_loss(self):\\n probabilities = self.probability_array().copy()\\n # need to flip the probabilities for p < 0.5 with this binary case.\\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\\n probabilities[np.equal(0, self.y)] *= -1\\n probabilities[np.equal(0, self.y)] += 1\\n # when multiclass: np.amax(probabilities, 1)\\n return np.log(probabilities).sum()\",\n \"def _classification_loss(self, logits, labels, num_classes):\\n labels = tf.to_int64(labels)\\n onehot_labels = tf.one_hot(labels, num_classes)\\n with tf.name_scope('finetuning_loss'):\\n cross_entropy = tf.losses.softmax_cross_entropy(\\n onehot_labels=onehot_labels, logits=logits)\\n cross_entropy = tf.reduce_mean(cross_entropy)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy + self.weight_decay * regularization\\n return loss\",\n \"def but_test(self):\\n if not self.path:\\n tk.messagebox.showerror(\\\"Error\\\", \\\"Open file first\\\")\\n return\\n elif not self.nn_obj:\\n tk.messagebox.showerror(\\\"Error\\\", \\\"Create or open NN\\\")\\n return\\n elif not self.nn_obj and not self.nn_in:\\n tk.messagebox.showerror(\\\"Error\\\", \\\"Open file and create NN\\\")\\n return\\n if isinstance(self.nn_obj, dict):\\n y_pred=pred(self.nn_obj, self.nn_in).reshape(self.nn_out.shape)\\n test_loss=loss(y_pred, self.nn_out, self.nn_obj) \\n elif isinstance(self.nn_obj, Net_tr):\\n y_pred=pred(self.nn_obj, self.nn_in)\\n test_loss=loss(y_pred, self.nn_out, self.nn_obj).item()\\n tk.messagebox.showinfo(\\\"Loss\\\", \\\"Loss=\\\" + str(test_loss)+\\\" %\\\")\",\n \"def loss(self, X, y=None):\\n\\n # In dev testing, the loss fnc stops at \\\"scores\\\" , unfollowed by \\\"softmax\\\" probability prediction.\\n # In real testing, \\\"self.predict()\\\" needs to be implemented in Solver() class.\\n \\n if y is None:\\n for bn_param in self.bn_params:\\n bn_param[\\\"mode\\\"] = \\\"test\\\"\\n\\n\\n W1, b1 = self.params['W1'], self.params['b1']\\n gamma1, beta1 = self.params[\\\"sbnGamma1\\\"], self.params[\\\"sbnBeta1\\\"]\\n bn_param1 = self.bn_params[0]\\n\\n W2, b2 = self.params['W2'], self.params['b2']\\n gamma2, beta2 = self.params[\\\"sbnGamma2\\\"], self.params[\\\"sbnBeta2\\\"]\\n bn_param2 = self.bn_params[1]\\n\\n W3, b3 = self.params['W3'], self.params['b3']\\n gamma3, beta3 = self.params[\\\"bnGamma3\\\"], self.params[\\\"bnBeta3\\\"]\\n bn_param3 = self.bn_params[2]\\n\\n W4, b4 = self.params['W4'], self.params['b4']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n conv_param = self.conv_param\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = self.maxpool_params\\n\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n scores = None \\n cache = {}\\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\\n out, cache[\\\"layer1\\\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \\n out, cache[\\\"layer2\\\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\\n\\n # def max_pool_forward_fast(x, pool_param): return out, cache;\\n out, cache[\\\"maxpool\\\"] = fast_layers.max_pool_forward_fast(out, pool_param)\\n\\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\\n \\n out, cache[\\\"layer3\\\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\\n\\n # def affine_forward(x, w, b): return out, cache;\\n scores, cache[\\\"layer4\\\"] = layers.affine_forward(out, W4, b4)\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n loss, grads = 0, {}\\n\\n # def softmax_loss(x, y): return loss, dscore;\\n loss, dscores = layers.softmax_loss(scores, y)\\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\\n\\n # def affine_backward(dout, cache): return dx, dw, db;\\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\\\"layer4\\\"]) \\n\\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\\\"layer3\\\"])\\n\\n # print cache[\\\"layer3\\\"]\\n\\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\\n # def max_pool_backward_im2col(dout, cache): return dx;\\n dout = fast_layers.max_pool_backward_fast(dout, cache[\\\"maxpool\\\"])\\n\\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer2\\\"])\\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer1\\\"])\\n\\n # reg\\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\\n \\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\\n grads[\\\"bnGamma3\\\"], grads[\\\"bnBeta3\\\"] = dgamma3, dbeta3\\n\\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\\n grads[\\\"sbnGamma2\\\"], grads[\\\"sbnBeta2\\\"] = dgamma2, dbeta2\\n\\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\\n grads[\\\"sbnGamma1\\\"], grads[\\\"sbnBeta1\\\"] = dgamma1, dbeta1\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70618695","0.69945925","0.6858851","0.67771924","0.6720419","0.67067975","0.6667089","0.66429305","0.6599716","0.65971327","0.65931565","0.6573648","0.65692914","0.65643126","0.649664","0.6443536","0.6420886","0.64154387","0.64138764","0.6337381","0.62886983","0.62812173","0.6276657","0.6242397","0.6241657","0.62393296","0.62318987","0.6185116","0.6146677","0.6144731","0.6129349","0.6098134","0.6085642","0.60808146","0.6075364","0.6065852","0.6042028","0.6040298","0.6038857","0.60380024","0.6037146","0.60370874","0.6029634","0.6017714","0.60170853","0.601091","0.6007968","0.6005488","0.6001378","0.5997135","0.59861314","0.59789145","0.59506524","0.5950411","0.5943123","0.59420913","0.5940359","0.59365445","0.5935989","0.5935533","0.5933791","0.5932814","0.59223026","0.5913513","0.5911562","0.5907542","0.589927","0.58990407","0.58818275","0.587998","0.5867068","0.58654326","0.5859844","0.5859646","0.5853266","0.5852541","0.5852258","0.5852118","0.5849183","0.58309036","0.58235765","0.5822409","0.5812709","0.581266","0.5807635","0.5792833","0.5790748","0.57721376","0.57693523","0.57654893","0.5765442","0.5765442","0.57484704","0.5747125","0.5740685","0.57326907","0.57316005","0.57293427","0.5726601","0.57250065","0.57243156"],"string":"[\n \"0.70618695\",\n \"0.69945925\",\n \"0.6858851\",\n \"0.67771924\",\n \"0.6720419\",\n \"0.67067975\",\n \"0.6667089\",\n \"0.66429305\",\n \"0.6599716\",\n \"0.65971327\",\n \"0.65931565\",\n \"0.6573648\",\n \"0.65692914\",\n \"0.65643126\",\n \"0.649664\",\n \"0.6443536\",\n \"0.6420886\",\n \"0.64154387\",\n \"0.64138764\",\n \"0.6337381\",\n \"0.62886983\",\n \"0.62812173\",\n \"0.6276657\",\n \"0.6242397\",\n \"0.6241657\",\n \"0.62393296\",\n \"0.62318987\",\n \"0.6185116\",\n \"0.6146677\",\n \"0.6144731\",\n \"0.6129349\",\n \"0.6098134\",\n \"0.6085642\",\n \"0.60808146\",\n \"0.6075364\",\n \"0.6065852\",\n \"0.6042028\",\n \"0.6040298\",\n \"0.6038857\",\n \"0.60380024\",\n \"0.6037146\",\n \"0.60370874\",\n \"0.6029634\",\n \"0.6017714\",\n \"0.60170853\",\n \"0.601091\",\n \"0.6007968\",\n \"0.6005488\",\n \"0.6001378\",\n \"0.5997135\",\n \"0.59861314\",\n \"0.59789145\",\n \"0.59506524\",\n \"0.5950411\",\n \"0.5943123\",\n \"0.59420913\",\n \"0.5940359\",\n \"0.59365445\",\n \"0.5935989\",\n \"0.5935533\",\n \"0.5933791\",\n \"0.5932814\",\n \"0.59223026\",\n \"0.5913513\",\n \"0.5911562\",\n \"0.5907542\",\n \"0.589927\",\n \"0.58990407\",\n \"0.58818275\",\n \"0.587998\",\n \"0.5867068\",\n \"0.58654326\",\n \"0.5859844\",\n \"0.5859646\",\n \"0.5853266\",\n \"0.5852541\",\n \"0.5852258\",\n \"0.5852118\",\n \"0.5849183\",\n \"0.58309036\",\n \"0.58235765\",\n \"0.5822409\",\n \"0.5812709\",\n \"0.581266\",\n \"0.5807635\",\n \"0.5792833\",\n \"0.5790748\",\n \"0.57721376\",\n \"0.57693523\",\n \"0.57654893\",\n \"0.5765442\",\n \"0.5765442\",\n \"0.57484704\",\n \"0.5747125\",\n \"0.5740685\",\n \"0.57326907\",\n \"0.57316005\",\n \"0.57293427\",\n \"0.5726601\",\n \"0.57250065\",\n \"0.57243156\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93490,"cells":{"query":{"kind":"string","value":"Split A at q and merge together in order."},"document":{"kind":"string","value":"def merge(A, p, q, r):\n n_1 = q-p+1\n n_2 = r-q\n L = []\n R = []\n for i in range(n_1):\n L.append(A[p+i])\n for j in range(n_2):\n R.append(A[q+j+1])\n L.append(math.inf)\n R.append(math.inf)\n i = 0\n j = 0\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 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 merge(A, p, q, r):\n\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\n n1 = q - p + 1 # will hold A[p..q]\n n2 = r - q # will hold A[q+1..r]\n\n L = [0] * (n1 + 1)\n R = [0] * (n2 + 1)\n \n for i in range(n1):\n L[i] = A[p+i]\n for j in range(n2):\n R[j] = A[q+j+1]\n\n # add sentinels\n L[n1] = float('inf')\n R[n2] = float('inf')\n\n # instead of sentinels, we can check if either L or R is empty,\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\n \n # indices of subarrays L and R (both already previously sorted)\n i = 0\n j = 0\n\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 1","def merge_in_place(A, p, q, r):\n n_1 = q - p + 1\n n_2 = r - q\n L = 0\n R = 0\n for k in range(p, r+1):\n if A[p] <= A[q + 1]:\n A.insert(r+1, A[p])\n del A[p]\n L += 1\n q -= 1\n else:\n A.insert(r+1, A[q+1])\n del A[q+1]\n R += 1\n\n if L == n_1:\n A[r+1:r+1] = A[p:p+n_2-R]\n del A[p:p+n_2-R]\n break\n\n if R == n_2:\n A[r+1:r+1] = A[p:q+1]\n del A[p:q+1]\n break","def merge(A, p, q, r):\n left, right = [], []\n for i in range(p, q + 1):\n left.append(A[i])\n\n for j in range(q + 1, r + 1):\n right.append(A[j])\n\n i, j = 0, 0\n for k in range(p, r + 1):\n if i > q - p:\n A[k] = right[j]\n j += 1\n continue\n if j > r - q - 1:\n A[k] = left[i]\n i += 1\n continue\n\n if left[i] <= right[j]:\n A[k] = left[i]\n i += 1\n else:\n A[k] = right[j]\n j += 1","def merge(arr, p, q, r):\r\n assist = np.zeros(r-p+1)\r\n s = p\r\n t = q+1\r\n k = 0\r\n while s<=q and t<=r:\r\n if arr[s] < arr[t]:\r\n assist[k] = arr[s]\r\n s = s+1\r\n else:\r\n assist[k] = arr[t]\r\n t = t+1\r\n k = k+1\r\n if s == q+1:\r\n assist[k:r-p+1] = arr[t:r+1]\r\n else:\r\n assist[k:r-p+1] = arr[s:q+1]\r\n return assist","def union(p, q):\n for i in q:\n if i not in p:\n p.append(i)","def union(p,q):\n\tfor e in q:\n\t\tif e not in p:\n\t\t\tp.append(e)","def union(self, p, q):\n p_id = self._root(p)\n q_id = self._root(q)\n if (p_id == q_id):\n return;\n if (self._sz[p_id] < self._sz[q_id]):\n self._id[p_id] = q_id\n self._sz[q_id] += self._sz[p_id]\n else:\n self._id[q_id] = p_id\n self._sz[p_id] += self._sz[q_id]","def merge(*in_qs, **kwargs):\n out_q = Queue(**kwargs)\n threads = [Thread(target=push, args=(q, out_q)) for q in in_qs]\n for t in threads:\n t.daemon = True\n t.start()\n return out_q","def union(self, p, q):\n pass","def merge_arrays_as_queues(array1, array2):\n q_a = deque(array1)\n q_b = deque(array2)\n res = [-1 for _ in xrange(len(array1)+len(array2))]\n for idx in xrange(0, len(res)):\n print q_a, q_b\n print res\n if (not q_a) or (q_b[0] < q_a[0]):\n res[idx] = q_b.popleft()\n elif (not q_b) or (q_a[0] < q_b[0]):\n res[idx] = q_a.popleft()\n else:\n res[idx] = q_b.popleft()\n\n return res","def temp_split(filename):\n filename, ext = filename.rsplit('.')\n data = np.load(filename + \".\" + ext)\n # define basic constants from parent\n A = data['a']\n A_SIZE = A.shape[0]\n A_SHAPE = A.shape\n ORIGINAL_SIZE = data['original_size']\n B = data['b']\n # basics\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\n # eval & evec\n eval, evec = linalg.eigh(B)\n # split\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\n # threshold (q)\n q1 = create_q(A_SIZE, B, g1_order, m)\n q2 = create_q(A_SIZE, B, g2_order, m)\n # B of G\n b1 = create_b_of_g(B, g1_order)\n b2 = create_b_of_g(B, g2_order)\n # a_elems\n a1_elems = []\n a2_elems = []\n original_elems = data['a_elems']\n for i in g1_order:\n a1_elems.append(original_elems[i])\n for i in g2_order:\n a2_elems.append(original_elems[i])\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))","def _concatenate_inner(self, chunks, direction):\n tmp_bucket = []\n source_chunks = chunks if direction else chunks[::-1]\n target_chunks = ChunkList()\n for chunk in source_chunks:\n if (\n # if the chunk has matched dependency, do concatenation.\n chunk.dependency == direction or\n # if the chunk is SPACE, concatenate to the previous chunk.\n (direction == False and chunk.is_space())\n ):\n tmp_bucket.append(chunk)\n continue\n tmp_bucket.append(chunk)\n if not direction: tmp_bucket = tmp_bucket[::-1]\n new_word = ''.join([tmp_chunk.word for tmp_chunk in tmp_bucket])\n chunk.update_word(new_word)\n target_chunks.append(chunk)\n tmp_bucket = []\n if tmp_bucket: target_chunks += tmp_bucket\n return target_chunks if direction else target_chunks[::-1]","def merge_plays(a, b, k=10):\n x = []\n while len(a) and len(b):\n if b[0].points > a[0].points:\n x.append(b.pop(0))\n else:\n x.append(a.pop(0))\n\n if len(x) >= k:\n return x\n while len(a):\n x.append(a.pop(0))\n while len(b):\n x.append(b.pop(0))\n return x","def split(self, X):","def solve_inplace(array1, array2):\n # append all b values to end of a and then sort\n pass","def split(self) -> GQASplit:\n return self._split","def merge(self, A, ind, p, q, r, rc_array):\n\n left = ind[p:q + 1]\n right = ind[q + 1:r + 1]\n\n i = 0\n j = 0\n ic = 0\n k = p\n\n while i < len(left) and j < len(right):\n if A[left[i]] > A[right[j]]:\n ind[k] = right[j]\n ic += 1\n k += 1\n j += 1\n else:\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n i += 1\n k += 1\n\n while i < len(left):\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n k += 1\n i += 1\n while j < len(right):\n ind[k] = right[j]\n k += 1\n j += 1","def unify(self, p, q):\n root1, root2 = self.find(p), self.find(q)\n\n # If the elements are already in the same set\n if root1 == root2:\n return\n\n # Merge the smaller component/set into the larger one.\n if self.comp_size[root1] < self.comp_size[root2]:\n self.comp_size[root2] += self.comp_size[root1]\n self.id[root1] = root2\n else:\n self.comp_size[root1] += self.comp_size[root2]\n self.id[root2] = root1\n\n # Since the roots found were different, we know that the\n # number of components/sets has decreased by one.\n self.num_components -= 1","def merge(a, b):\r\n # your code here\r\n \r\n m = []\r\n i, j = 0, 0\r\n \r\n while i < len(a) and j < len(b):\r\n if a[i] < b[j]:\r\n m.append(a[i])\r\n i += 1\r\n else:\r\n m.append(b[j])\r\n j += 1\r\n \r\n m += a[i:] + b[j:]\r\n \r\n return m","def merge_quick_sort(L):\n list1 = []\n list2 = []\n (evens, odds) = merge_sort.split(L)\n list1 += quick_sort.quick_sort(evens)\n list2 += quick_sort.quick_sort(odds)\n x = merge_sort.merge(list1,list2)\n return x","def split(filename, initial=False, optimize=False):\n # load data\n filename, ext = filename.rsplit('.')\n data = np.load(filename + \".\" + ext)\n # define constants and load A if initial\n A = data['a']\n A_SIZE = A.shape[0]\n A_SHAPE = A.shape\n if initial:\n ORIGINAL_SIZE = A_SIZE\n else:\n ORIGINAL_SIZE = data['original_size']\n # basics\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\n # create B if initial, if not, import from archive\n if initial:\n p1 = create_p1(A_SHAPE, ki, kj)\n p = create_p(p1, m)\n B = A - p\n else:\n B = data['b']\n if A_SIZE <= 1:\n raise CannotSplit\n # eval & evec\n eval, evec = linalg.eigh(B)\n # split\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\n # threshold (q)\n q1 = create_q(A_SIZE, B, g1_order, m)\n q2 = create_q(A_SIZE, B, g2_order, m)\n # B of G\n b1 = create_b_of_g(B, g1_order)\n b2 = create_b_of_g(B, g2_order)\n # a elems\n a1_elems = []\n a2_elems = []\n if initial:\n a1_elems = g1_order\n a2_elems = g2_order\n else:\n original_elems = data['a_elems']\n for i in g1_order:\n a1_elems.append(original_elems[i])\n for i in g2_order:\n a2_elems.append(original_elems[i])\n # save\n if not g1_order or not g2_order:\n raise CannotSplit(message='One group is empty, cannot split.')\n if initial:\n # save files\n np.savez('g1.npz', a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\n np.savez('g2.npz', a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\n # create File records\n files.File.create(filename='g1', ext=ext, q=q1, shape=g1.shape[0], a_elems=','.join([str(x) for x in a1_elems]))\n files.File.create(filename='g2', ext=ext, q=q2, shape=g2.shape[0], a_elems=','.join([str(x) for x in a2_elems]))\n # create Item records for burning\n files.Item.create(filename='.'.join(('g1', ext)))\n files.Item.create(filename='.'.join(('g2', ext)))\n if optimize:\n opt_table = []\n for idx, elem in enumerate(g1_order):\n # create copies of new arrays\n new_g1_order, new_g1_arrays, new_g2_order, new_g2_arrays = g1_order[:], g1_arrays[:], g2_order[:], g2_arrays[:]\n # first append new material to other array\n new_g2_order.append(elem) # TODO: check if need to be sorted\n new_g2_arrays.append(new_g1_arrays[idx]) # TODO: check if insert instead if size g2 size is >= g1 size?\n # delete material from new_g1_*\n del new_g1_order[idx]\n del new_g1_arrays[idx]\n # create new Qs\n new_q1, new_q2 = create_q(A_SIZE, B, new_g1_order, m), create_q(A_SIZE, B, new_g2_order, m)\n opt_table.append((elem, new_q1, new_q2))\n return sorted(opt_table, key=lambda x: x[0])\n else:\n # return to manager to set parents\n np.savez(filename + \",1\" + \".\" + ext, a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\n np.savez(filename + \",2\" + \".\" + ext, a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\n # save filenames for burn regardless if saved or not, why didn't I do this before in master?\n files.Item.create(filename=filename + ',2.' + ext)\n files.Item.create(filename=filename + ',1.' + ext)\n # return so we can manipulate\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))","def qu_union(self, p, q):\n pID = self.qu_findroot(p)\n qID = self.qu_findroot(q)\n\n if pID == qID: return\n\n if p > q: self.id[qID] = pID\n else: self.id[pID] = qID\n return 1","def splice(i, j, data):\n n = len(data)\n out = ()\n splice_a = []\n splice_b = []\n i = idx(i, n)\n j = idx(j, n)\n i+=1\n j+=1\n if(i < j):\n splice_a = data[i:j]\n splice_b = data[j:] + data[0:i]\n else:\n splice_a = data[i:] + data[0:j]\n splice_b = data[j:i]\n\n return (splice_a, splice_b)","def test_merge(self):\n A = [1,4,6,7,8,2,3,4,5,7]\n p = 0\n q = 5\n r = 10\n A_merged = mst.merge(A, p, q, r)\n expected = [1, 2, 3, 4, 4, 5, 6, 7, 7, 8] \n self.assertEqual(A, A_merged)","def wqu_union(self, p, q):\n pID = self.qu_findroot(p)\n qID = self.qu_findroot(q)\n\n if pID == qID: return\n if(self.sz[pID] < self.sz[qID]):\n self.id[pID] = qID\n self.sz[qID] += self.sz[pID]\n else:\n self.id[qID] = pID\n self.sz[pID] += self.sz[qID]\n return 1","def merge(a, b):\n result = []\n\n # Append smallest values to result until either list is exhausted\n i = j = 0\n while i < len(a) and j < len(b):\n if compare(a[i], b[j]) < 0:\n result.append(a[i])\n i += 1\n else:\n result.append(b[j])\n j += 1\n\n # Append all remaining values from the unexhausted list\n if i < len(a):\n result.extend(a[i:])\n else:\n result.extend(b[j:])\n\n return result","def _merge_intent_fragments(self, start_offset, upload_intents, copy_intents):\n upload_intents = deque(upload_intents)\n copy_intents = deque(copy_intents)\n while True:\n upload_intent = copy_intent = None\n if upload_intents:\n upload_intent, upload_end, _ = upload_intents[0]\n if copy_intents:\n copy_intent, copy_end, copy_protected = copy_intents[0]\n\n if upload_intent is not None and copy_intent is not None:\n if not copy_protected:\n yield_intent = upload_intent\n else:\n yield_intent = copy_intent\n start_offset = min(upload_end, copy_end)\n yield yield_intent, start_offset\n if start_offset >= upload_end:\n upload_intents.popleft()\n if start_offset >= copy_end:\n copy_intents.popleft()\n elif upload_intent is not None:\n yield upload_intent, upload_end\n upload_intents.popleft()\n elif copy_intent is not None:\n yield copy_intent, copy_end\n copy_intents.popleft()\n else:\n return","def wpqu_union(self, p, q):\n pID = self.pqu_findroot(p)\n qID = self.pqu_findroot(q)\n\n if pID == qID: return\n if (self.sz[pID] < self.sz[qID]):\n self.id[pID] = qID\n self.sz[qID] += self.sz[pID]\n else:\n self.id[qID] = pID\n self.sz[pID] += self.sz[qID]\n return 1","def spliter(temp,split1,split2):\n for x in range(len(temp)):\n if x<len(temp)/2:\n split1.append(temp[x])\n else:\n split2.append(temp[x])","def qsort(A, l, r):\n if l < r:\n q = partition(A, l, r)\n qsort(A, l, q-1)\n qsort(A, q+1, r)","def union(self, p, q):\n self._validate(p)\n self._validate(q)\n p_parent = self.find(p)\n q_parent = self.find(q)\n if p_parent == q_parent:\n return\n for i in range(len(self.parents)):\n if self.parents[i] == q_parent:\n self.parents[i] = p_parent\n self.n -= 1","def split_chunk(chunk, *a, **kw):\n return split_chunk(chunk, *a, **kw)","def pqu_union(self, p, q):\n pID = self.pqu_findroot(p)\n qID = self.pqu_findroot(q)\n\n if pID == qID: return\n\n if p > q:\n self.id[qID] = pID\n else:\n self.id[pID] = qID\n return 1","def qids_to_splits(qids):\n qidmap = {}\n i = 0\n for qid in qids:\n if not qid in qidmap:\n qidmap[qid] = i\n i+=1\n new_qids = []\n for qid in qids:\n new_qids.append(qidmap[qid])\n qidcount = np.max(new_qids)+1\n splits = [[] for i in range(qidcount)]\n for i, qid in enumerate(new_qids):\n splits[qid].append(i) \n return splits","def merge_sort(alist):\n print(\"Splitting \", alist)\n # Temporary list to store sorted list\n work = [None] * len(alist)\n rec_merge_sort(work, start=0, end=len(alist)-1)","def split(aDeck,location):\r\n newDeck=[]\r\n for x in range(location):\r\n newDeck.append(aDeck.pop())\r\n return (newDeck)","def union(self, p, q):\n p_id = self._root(p)\n q_id = self._root(q)\n self._id[p_id] = q_id","def splits_array_switcher(trajectory1, trajectory2, index_of_cut):\r\n\r\n trajectory1_a, trajectory2_b = trajectory1[:index_of_cut], trajectory1[index_of_cut:]\r\n trajectory2_a, trajectory1_b = trajectory2[:index_of_cut], trajectory2[index_of_cut:]\r\n\r\n trajectory1 = np.concatenate((trajectory1_a, trajectory1_b), axis=0)\r\n trajectory2 = np.concatenate((trajectory2_a, trajectory2_b), axis=0)\r\n\r\n return trajectory1, trajectory2","def _intermediates(q, results):\n # type: (np.ndarray, List[Tuple[Kernel, np.ndarray, Optional[Callable]]]) -> OrderedDict[str, Any]\n parts = OrderedDict()\n for part_num, (kernel, Iq, intermediates) in enumerate(results):\n part_id = chr(ord('A') + part_num) + \"_\" + kernel.info.name + \"(Q)\"\n parts[part_id] = (q, Iq)\n if intermediates is not None:\n parts[part_id + \" parts\"] = intermediates()\n return parts","def sortbatch(q_batch, a_batch, q_lens, a_lens):\n maxlen_q = max(q_lens)\n maxlen_a = max(a_lens)\n q=q_batch[:,:maxlen_q-1]\n a=a_batch[:,:maxlen_a-1]\n sorted_idx = torch.LongTensor(a_lens.numpy().argsort()[::-1].copy())\n return q[sorted_idx], a[sorted_idx], q_lens[sorted_idx], a_lens[sorted_idx]","def _group_chunks_by_entities(self, chunks, entities):\n for entity in entities:\n chunks_to_concat = chunks.get_overlaps(\n entity['beginOffset'], len(entity['content']))\n if not chunks_to_concat: continue\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\n new_chunk = Chunk(new_chunk_word)\n chunks.swap(chunks_to_concat, new_chunk)\n return chunks","def _group_chunks_by_entities(self, chunks, entities):\n for entity in entities:\n chunks_to_concat = chunks.get_overlaps(\n entity['beginOffset'], len(entity['content']))\n if not chunks_to_concat:\n continue\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\n new_chunk = Chunk(new_chunk_word)\n chunks.swap(chunks_to_concat, new_chunk)\n return chunks","def wpqu_union(self, p, q):\n if self.wpqu_connected(p,q):\n return True;\n \n p_pa,q_pa = self.id[p],self.id[q]\n \n if self.sz[p_pa] >= self.sz[q_pa]:\n self.id[q_pa] = p_pa\n self.sz[p_pa] += self.sz[q_pa] \n else:\n self.id[p_pa] = q_pa\n self.sz[q_pa] += self.sz[p_pa] \n return True","def d_j(self,q):\n dj = q.shift(y=-1) - q # works with chunks too\n return dj","def _load_data(l, q, nproc):\n for element in l:\n q.put(element)\n for _ in range(nproc):\n q.put(FINISHED)","def busca_base(A, a, q):\n \n \n nrow = np.shape(A)[0]\n zeros = np.zeros((nrow, 1))\n B0, _ = householder(power(A-a*np.identity(nrow), q), zeros)\n \n # calcula el rango de la matriz B0\n r = rango_matrix(B0)\n \n # G = [G1, G2, ..., Gn-r], donde Gi: i-esimo vector generador de N((A-aI)^{q})\n # NOTA: No esta garanizado que {G1, G2, ..., Gn-r}, sean li\n G = np.zeros((nrow, nrow-r))\n for k in range(r):\n # coeff(k, i): coeficiente de xi en la combinacion lineal de los xr+1,xr+2,...,xn, para obtener -B0[k,k]xk\n G[k,:] = - np.array([coeff(k,r+i, B0) for i in range(1, nrow-r+1)])/B0[k,k]\n G[nrow:, :] = np.identity(nrow-r)\n \n return vectores_li(G, r) # retorna solo los vectore li de {G1, G2, ..., Gn-r}, en una matriz","def wqu_union(self, p, q):\n \n if self.wqu_connected(p, q):\n return True\n \n p_pa,q_pa = p,q\n while p_pa != self.id[p_pa]:\n p_pa = self.id[p_pa]\n while q_pa != self.id[q_pa]:\n q_pa = self.id[q_pa]\n \n if self.sz[p_pa] >= self.sz[q_pa]:\n self.id[q_pa] = p_pa\n self.sz[p_pa] += self.sz[q_pa] \n else:\n self.id[p_pa] = q_pa\n self.sz[q_pa] += self.sz[p_pa] \n return True","def pqu_union(self, p, q):\n if self.pqu_connected(p,q):\n return True\n self.id[self.id[p]] = self.id[q]\n return True","def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\n A[m:] = B\n A.sort()","def mergesort(A, p, r):\n if p < r:\n q = (p+r)//2\n mergesort(A, p, q)\n mergesort(A, q + 1, r)\n merge(A, p, q, r)","def split_segments(old_seg_ends, B):\n new_segment_ends = []\n for q in range(0, B.size):\n new_ends = list(np.linspace(old_seg_ends[q], old_seg_ends[q + 1], B[q] + 1))\n new_segment_ends.extend(new_ends[:-1])\n new_segment_ends.extend([1])\n new_segment_ends = np.asarray(new_segment_ends)\n return new_segment_ends","def merge(li: Sequence, left_index: int, mid_index: int, right_index: int) -> None:\n left_li = li[left_index : mid_index]\n right_li = li[mid_index : right_index]\n i, j, k = 0, 0, left_index\n \n while i < len(left_li) and j < len(right_li):\n if left_li[i] <= right_li[j]:\n li[k] = left_li[i]\n i += 1\n else:\n li[k] = right_li[j]\n j += 1\n k += 1\n \n # Copy the remainders\n while i < len(left_li):\n li[k] = left_li[i]\n i += 1\n k += 1\n while j < len(right_li):\n li[k] = right_li[j]\n j += 1\n k += 1","def merge_recs(part_one, part_two, output):\n start_op_length = 28\n with open(part_one, 'rb') as a_handle, \\\n open(part_two, 'rb') as b_handle, \\\n open(output, 'wb') as merged:\n\n a_data = a_handle.read()\n b_data = b_handle.read()\n\n postgame_pos, _ = find_postgame(a_data, len(a_data))\n if postgame_pos:\n a_data_end = postgame_pos - LOOKAHEAD\n else:\n a_data_end = len(a_data)\n b_header_len, = struct.unpack('<I', b_data[:4])\n chapter = mgz.body.operation.build({\n 'type': 'action',\n 'op': 1,\n 'length': 2,\n 'action': {\n 'type': 'chapter',\n 'player_id': 0xff # our merge marker\n }\n })\n\n # part A with no postgame struct\n merged.write(a_data[:a_data_end])\n # chapter action\n merged.write(chapter)\n # offset to start of part B operations\n merged.write(struct.pack('<I', a_data_end + len(chapter) + b_header_len))\n # part B header (now a \"saved chapter\")\n merged.write(b_data[4:b_header_len])\n # part B operations with no start operation\n merged.write(b_data[b_header_len + start_op_length:])","def mergeSeq(left, right):\n i = j = 0\n result = []\n while i < len(left) and j < len(right):\n if left[i] <= right[j]:\n result.append(left[i])\n i += 1\n else:\n result.append(right[j])\n j += 1\n\n result += left[i:]\n result += right[j:]\n return result","def _get_pmx_crossed_sequence(sequence_a: OrderedSet, sequence_b: OrderedSet,\n part_from_a: OrderedSet, part_from_b: OrderedSet,\n start_index: int, end_index: int) -> List[int]:\n new_sequence = list(sequence_b)\n\n elements_requiring_correction = {}\n\n uniques_from_b_part = part_from_b - part_from_a\n for unique_from_b_part in uniques_from_b_part:\n index_in_part = part_from_b.index(unique_from_b_part)\n elements_requiring_correction[unique_from_b_part] = part_from_a[index_in_part]\n\n for elem_from_b, elem_from_a in elements_requiring_correction.items():\n while elem_from_a in part_from_b:\n index_of_elem_from_b = sequence_b.index(elem_from_a)\n elem_from_a = sequence_a[index_of_elem_from_b]\n\n new_index = sequence_b.index(elem_from_a)\n new_sequence[new_index] = elem_from_b\n\n new_sequence[start_index:end_index] = part_from_a\n\n return new_sequence","def push(self, x):\n # enqueue new element to q2\n self.q2.enqueue(x)\n # dequeue from q1 and enqueue in q2\n\n while self.q1.qlist:\n self.q2.enqueue(self.q1.dequeue())\n # swap q1 and q2\n temp = self.q1.qlist\n self.q1.qlist = self.q2.qlist\n self.q2.qlist = temp","def merge(a,b):\n c = []\n while len(a) != 0 and len(b) != 0:\n if a[0] < b[0]:\n c.append(a[0])\n a.remove(a[0])\n else:\n c.append(b[0])\n b.remove(b[0])\n if len(a) == 0:\n c += b\n else:\n c += a\n return c","def interval_split(a,b,split_ps):\n ps = [a] + [s for s in sorted(split_ps) if a < s < b] + [b]\n return [(p1,p2) for p1,p2 in zip(ps,ps[1:])]","def addToBq(self, p):\n self.allJobs.append(p)\n p.submitToQueue()\n if len(self.circQ) < self.maxLength - 1:\n self.circQ.append(p)","def addToBq(self, p):\n self.allJobs.append(p)\n p.submitToQueue()\n if len(self.circQ) < self.maxLength - 1:\n self.circQ.append(p)","def merge_ranges():","def qf_union(self, p, q):\n pID = self.id[p]\n\n for x in range(len(self.id)):\n if self.id[x] == pID:\n self.id[x] = self.id[q]\n return 1","def merge_reads(s1, s2, q1, q2, amplen):\n # If the amplicon is of length L and the reads are lengths l1, l2 then:\n # - read 1 from 0 to L-l2-1 inclusive doesn't overlap\n # - read 1 from L-l2 to l1-1 inclusive overlaps with read 2\n # - read 2 from 0 to l1+l2-L-1 inclusive overlaps with read 1\n # - read 2 from l1+l2-L to its end doesn't overlap\n\n # A picture for clarity:\n # s1 coords: 0 l1-1\n # | |\n # ----------------------------------------\n # ------------------------------\n # | | |\n # s1 coords: L-l2 | L-1\n # s2 coords: 0 l1+l2-L-1\n\n # Reverse complement read 2 and reverse its quality scores.\n s2 = reverse_complement(s2)\n q2 = q2[::-1]\n\n # This is where we'll put the merged sequence and quality score.\n s = np.zeros(amplen, dtype=np.int8)\n q = np.zeros(amplen, dtype=np.int8)\n\n # If the reads overlap correctly, then s1[offset+i] == s2[i], assuming s2 is\n # the reverse complement of the reverse read.\n offset = amplen - len(s2)\n\n # Fill in the parts of the merged sequence where the reads don't overlap.\n s[:offset] = s1[:offset]\n q[:offset] = q1[:offset]\n s[len(s1):] = s2[len(s1)+len(s2)-amplen:]\n q[len(s1):] = q2[len(s1)+len(s2)-amplen:]\n\n # Create a set of views into the overlapping region. We can directly compare\n # vs1[i] to vs2[i] and use that to fill in vs[i] with all indexing taken\n # care of.\n vs1 = s1[offset:]\n vq1 = q1[offset:]\n vs2 = s2[:len(vs1)]\n vq2 = q2[:len(vs1)]\n vs = s[offset:len(s1)]\n vq = q[offset:len(s1)]\n\n # Quality score of matching bases is the larger of the two quality\n # scores (this is a somewhat conservative low estimate). Quality\n # score of mismatched bases is the difference of the two quality\n # scores. If the mismatched bases have equal quality scores, the\n # base is written as an N with the minimum possible quality.\n\n # Positions where the reads agree.\n ieq = vs1 == vs2\n vs[ieq] = vs1[ieq]\n vq[ieq] = np.maximum(vq1[ieq], vq2[ieq])\n\n # Positions where the reads disagree.\n ineq = vs1 != vs2\n mismatches = ineq.sum()\n\n # Positions where the reads disagree and read 1 has the higher quality.\n ir1 = np.logical_and(ineq, vq1 > vq2)\n vs[ir1] = vs1[ir1]\n vq[ir1] = MIN_QUAL + vq1[ir1] - vq2[ir1]\n\n # Positions where the reads disagree and read 2 has the higher quality.\n ir2 = np.logical_and(ineq, vq2 > vq1)\n vs[ir2] = vs2[ir2]\n vq[ir2] = MIN_QUAL + vq2[ir2] - vq1[ir2]\n\n # Positions where the reads disagree and they have equal qualities.\n irn = np.logical_and(ineq, vq1 == vq2)\n vs[irn] = bN\n vq[irn] = MIN_QUAL\n\n return s, q, mismatches","def sort(self, A, index, p, r, rc_arr):\n\n if p < r:\n q = (p + r) // 2\n\n self.sort(A, index, p, q, rc_arr)\n self.sort(A, index, q + 1, r, rc_arr)\n self.merge(A, index, p, q, r, rc_arr)","def _prepare(self, q):\n # store it in _lastr which is consulted in BasePDFGenerator.__call__\n self._lastr = q\n self._calc.qstep = q[1] - q[0]\n self._calc.qmin = q[0]\n self._calc.qmax = q[-1] + 0.5*self._calc.qstep\n return","def __init__(self):\n self.A = [] # 大顶堆，存放较小的元素\n self.B = [] # 小顶堆，存放较大的元素，使得B的最小的元素也比A中最大的元素大，保证数据流保持有序","def merge(self, parallel_seq):\n return _OSeq(sorted(self._elements + parallel_seq._elements, key=lambda x: x.get(offset_attr, 0)))","def mconcat(a, b):\r\n if a is None:\r\n return b\r\n if b is None:\r\n return a\r\n for key in b.keyset:\r\n value=get(b,key)\r\n put(a,key,value)\r\n return a","def merge(items, start, end, subarray_size):\n mid = start + subarray_size\n assert is_sorted(items[start:mid])\n assert is_sorted(items[start+subarray_size:end])\n\n aux = []\n i = start\n j = mid\n\n while i < mid and j < end:\n if items[i] < items[j]:\n aux.append(items[i])\n i += 1\n else:\n aux.append(items[j])\n j += 1\n aux.extend(items[i:mid] or items[j:end])\n assert is_sorted(aux)\n\n ## Overwrite elements in subarrays in their correctly sorted order\n for i in range(start, end):\n items[i] = aux[i-start]","def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\n # # solution one: sort\n # A[m:] = B\n # A.sort()\n\n # solution two: two point\n if n == 0: # B = []\n return\n i, j, k = m - 1, n - 1, m + n - 1\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\n if A[i] <= B[j]:\n A[k] = B[j]\n k -= 1\n j -= 1\n else:\n A[k] = A[i]\n k -= 1\n i -= 1\n if j > -1:\n A[:j + 1] = B[:j + 1] # A = [], B = [1]","def test_merge():\n\n q1 = PriorityQueue()\n q2 = PriorityQueue()\n\n # input list (obj, priority) should be reversed\n # in the priority_queue\n input_list = [((1), 9), ((2), 8), ((3), 7),\n ((4), 6), ((5), 5), ((6), 4),\n ((7), 3), ((8), 2), ((9), 1)]\n\n # insert the items into the queues\n for idx, (obj, p) in enumerate(input_list):\n if idx < 4:\n q1.push(obj, p)\n else:\n q2.push(obj, p)\n\n # merge the queues\n q1.merge(q2)\n\n # dump the queue into a list\n output = []\n while q1._queue:\n output.append(q1.pop())\n\n # validate the expected behavior\n eq_(output, range(1, 10)[::-1])","def subsample(self, dQ):\n # Assumes self contains sorted Qo and associated T, L\n # Note: calc_Qo is already sorted\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\n idx = np.unique(np.searchsorted(self.Qo, Q))\n #print len(idx), len(self.Qo)\n\n self.T, self.dT = self.T[idx], self.dT[idx]\n self.L, self.dL = self.L[idx], self.dL[idx]\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\n if self.R is not None:\n self.R = self.R[idx]\n if self.dR is not None:\n self.dR = self.dR[idx]\n self._set_calc(self.T, self.L)","def test_three_split():\n run_mergesort([3, 0, 3], [0, 3, 3])","def concatenate(self):\n if not self.match_count:\n # No concatenating if there are no matches\n return []\n if self.match_count <= 1:\n # Can't combine a single match\n return self.match_list\n # Setup for iterating through\n cont = True\n first = self.match_list[self.i]\n second = self.match_list[self.j]\n while cont and self.match_count > 2:\n first, second, cont = self._process_main()\n\n # Last block is a special case\n self._process_last(first, second)\n return self.combined","def mergesort(input):\n\n if len(input) <= 1:\n return input\n\n cut = len(input) // 2 # floored quotient\n top = mergesort(input[:cut])\n bottom = mergesort(input[cut:])\n\n i = 0\n j = 0\n\n output = []\n for x in range(len(input)):\n if top[i] < bottom[j]:\n output.append(top[i])\n i += 1\n if i >= len(top):\n output += bottom[j:]\n break\n else:\n output.append(bottom[j])\n j += 1\n if j >= len(bottom):\n output += top[i:]\n break\n\n return output","def quick_sort_helper(a_list, first_position, last_position):\n if first_position < last_position:\n\n split_point = partition(a_list, first_position, last_position)\n\n quick_sort_helper(a_list, first_position, split_point)\n quick_sort_helper(a_list, split_point + 1, last_position)\n\n return a_list","def q_append_non_leaf(node, q):\n for i in range(q-1):\n node.addkid(Node(\"*\"), before=True)\n node.addkid(Node(\"*\"))","def union(self,i,j):\n ii, jj = self.find(i), self.find(j)\n if ii != jj:\n\n if self.rank[ii] > self.rank[jj]: \n ii,jj = jj,ii\n\n if self.rank[ii] == self.rank[jj]: \n self.rank[jj]+=1\n\n self.size[jj] += self.size[ii]\n self.par[ii] = jj\n\n self.cMax = max(self.size[jj],self.cMax)\n self.nComp -=1\n\n del self.size[ii]","def merge(work, start_left, start_right, upper_bound):\n # Keep track of index in temporary list\n # whose length is the same as the original list\n i = 0\n lower_bound = start_left\n mid = start_right - 1\n # size of list after merge\n n = upper_bound - lower_bound + 1\n\n # compare two sub lists per item\n # and insert in original list\n while start_left <= mid and start_right <= upper_bound:\n work[i] = min(a_list[start_left], a_list[start_right])\n if work[i] == a_list[start_left]:\n start_left += 1\n else:\n start_right += 1\n i += 1\n\n # If all items from second list are in original list\n # insert all of the items from the first list\n # as list is already sorted\n while start_left <= mid:\n work[i] = a_list[start_left]\n i += 1\n start_left += 1\n\n # If all items from first list are in original list\n # insert all of the items from the second list\n # as list is already sorted\n while start_right <= upper_bound:\n work[i] = a_list[start_right]\n i += 1\n start_right += 1\n\n # Transfer the temporary list \"work\" back to original\n # list \"a_list\"\n for k in range(0, n):\n a_list[lower_bound+k] = work[k]","def union(self, p, q):\n root_p = self.find(p)\n root_q = self.find(q)\n if root_p == root_q:\n return\n \n #if the sites were isolated make them un-isolated\n if self._nodes[p] == 1:\n self._nodes[p] = 0\n self._iso -= 1\n if self._nodes[q] == 1:\n self._nodes[q] = 0\n self._iso -= 1\n\n # make root of smaller rank point to root of larger rank\n if self._rank[root_p] < self._rank[root_q]:\n self._parent[root_p] = root_q\n #add the small root size to the big root size\n self._size[root_q] += self._size[root_p]\n #check if the big root size is now the biggest\n if self._size[root_q] > self._max:\n self._max = self._size[root_q]\n elif self._rank[root_p] > self._rank[root_q]:\n self._parent[root_q] = root_p\n self._size[root_p] += self._size[root_q]\n if self._size[root_p] > self._max:\n self._max = self._size[root_p]\n else:\n self._parent[root_q] = root_p\n self._size[root_p] += self._size[root_q]\n if self._size[root_p] > self._max:\n self._max = self._size[root_p]\n self._rank[root_p] += 1\n\n self._count -= 1","def qu_union(self, p, q):\n\n if self.qu_connected(p, q):\n return True\n\n p_pa,q_pa = p,q\n while p_pa != self.id[p_pa]:\n p_pa = self.id[p_pa]\n while q_pa != self.id[q_pa]:\n q_pa = self.id[q_pa]\n self.id[p_pa] = q_pa\n\n return True","def split_sort_merge(items):\n # TODO: Split items list into approximately equal halves\n pivot = len(items) // 2\n # TODO: Sort each half using any other sorting algorithm\n # sort first half in-place (insertion sort)\n left = insertion_sort(items[:pivot])\n\n right = insertion_sort(items[pivot:])\n # TODO: Merge sorted halves into one list in sorted order\n # merge the two half list (merge function but this does this in-place)\n sorted_list = merge(left, right)\n # change the input items\n items[:] = sorted_list\n return items","def split(self):\n\n # FIXME: user should be able to change the default behavior of\n # this function (for instance user may require one filter not\n # to split the content of the input file and the same input \n # to be used by the next filter.\n \n utils.split_file(self.files['hit_ids'],\n self.files['input'],\n self.files['filtered_reads'],\n self.files['survived_reads'])","def merge(A, left, middle, right):\n leftSubArray = A[left:middle]\n rightSubArray = A[middle:right+1]\n leftSubArray.append(float(\"inf\"))\n rightSubArray.append(float(\"inf\"))\n i = j = 0\n for k in xrange(left, right + 1):\n if leftSubArray[i] < rightSubArray[j]:\n A[k] = leftSubArray[i]\n i += 1\n else:\n A[k] = rightSubArray[j]\n j += 1\n return A","def queued(values, qsize):\n values = [_normalize(v) for v in values]\n if qsize < 1:\n raise ValueError(\"qsize must be 1 or larger\")\n q = []\n it = iter(values)\n try:\n for i in range(qsize):\n q.append(next(it))\n for i in cycle(range(qsize)):\n yield q[i]\n q[i] = next(it)\n except StopIteration:\n pass","def rejoin(l0,l1=None):\r\n while len(l0) != 0:\r\n if l1 is None:\r\n l1 = []\r\n if l0[0] == '<':\r\n if len(l0) >= 3:\r\n if l0[2] == '>':\r\n l1 += [l0.pop(0) + l0.pop(0) + l0.pop(0)]\r\n else:\r\n l1 += [l0.pop(0)]\r\n return l1","def fastq_qc(demultiplex_result, out_dir, config):\n\n pigz_cores = int(config['fastqTrim']['pigz_cores'])\n cutadapt_cores = int(config['fastqTrim']['cutadapt_cores'])\n\n r1_adapter = config['fastqTrim']['r1_adapter']\n r2_adapter = config['fastqTrim']['r1_adapter']\n length_threshold = config['fastqTrim']['length_threshold']\n quality_threshold = config['fastqTrim']['quality_threshold']\n r1_left_cut = config['fastqTrim']['r1_left_cut']\n r1_right_cut = config['fastqTrim']['r1_right_cut']\n r2_left_cut = config['fastqTrim']['r2_left_cut']\n r2_right_cut = config['fastqTrim']['r2_right_cut']\n overlap = config['fastqTrim']['overlap']\n total_reads_threshold = int(config['fastqTrim']['total_reads_threshold'])\n\n results = []\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\n sample_demultiplex_total = sub_df['Trimmed'].sum()\n if sample_demultiplex_total < total_reads_threshold:\n log.info(f'In uid {uid}: index {index_name} skipped '\n f'due to too less reads: {sample_demultiplex_total}')\n continue\n # process R1\n r1_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R1.fq.gz'\n r1_out = f'{out_dir}/{uid}_{index_name}_R1.trimed.fq.gz'\n r1_cmd = f'pigz -cd -p {pigz_cores} {r1_path_pattern} | ' \\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\n f'-q {quality_threshold} -u {r1_left_cut} ' \\\n f'-u -{r1_right_cut} -m {length_threshold} ' \\\n f'-a {r1_adapter} -o {r1_out} -'\n r1_result = subprocess.run(r1_cmd, stdout=subprocess.PIPE,\n encoding='utf8', shell=True, check=True)\n\n # get R1 result stat\n lines = []\n for line in r1_result.stdout.split('\\n'):\n ll = line.split('\\t')\n if len(ll) > 1:\n lines.append(ll)\n s = pd.Series({name: number for name, number in zip(*lines)})\n s['uid'] = uid\n s['index_name'] = index_name\n s['read_type'] = 'R1'\n results.append(s)\n\n # process R2\n r2_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R2.fq.gz'\n r2_out = f'{out_dir}/{uid}_{index_name}_R2.trimed.fq.gz'\n r2_cmd = f'pigz -cd -p {pigz_cores} {r2_path_pattern} | ' \\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\n f'-q {quality_threshold} -u {r2_left_cut} ' \\\n f'-u -{r2_right_cut} -m {length_threshold} ' \\\n f'-a {r2_adapter} -o {r2_out} -'\n r2_result = subprocess.run(r2_cmd, stdout=subprocess.PIPE,\n encoding='utf8', shell=True, check=True)\n # get R2 result stat\n lines = []\n for line in r2_result.stdout.split('\\n'):\n ll = line.split('\\t')\n if len(ll) > 1:\n lines.append(ll)\n s = pd.Series({name: number for name, number in zip(*lines)})\n s['uid'] = uid\n s['index_name'] = index_name\n s['read_type'] = 'R2'\n results.append(s)\n\n fastq_final_result = pd.DataFrame(results)\n if len(results) == 0:\n # all sample skipped\n return fastq_final_result\n fastq_final_result['out_reads_rate'] = \\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\n fastq_final_result['out_bp_rate'] = \\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\n\n # clean up\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\n r_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R*.fq.gz'\n r_rm_cmd = f'rm -f {r_path_pattern}'\n subprocess.run(r_rm_cmd, shell=True)\n # remove unknown reads\n r_path_pattern = f'{out_dir}/{uid}_L*_unknown_R*.fq.gz'\n r_rm_cmd = f'rm -f {r_path_pattern}'\n subprocess.run(r_rm_cmd, shell=True)\n\n return fastq_final_result","def array_to_pq(pq, source):\r\n temp = None\r\n \r\n while source != []:\r\n temp = source.pop(0)\r\n pq.insert(temp)\r\n\r\n return","def split_by(data_set, question, entropy_before):\r\n yea_set = []\r\n nay_set = []\r\n abstain_set = []\r\n\r\n for data_point in data_set:\r\n vote = data_point.dat_votes[ord(question)-97] #the way this representative voted is the data_point's votes indexed by question\r\n party = data_point.dat_party\r\n\r\n if vote == \"+\":\r\n yea_set.append(data_point)\r\n if vote == \"-\":\r\n nay_set.append(data_point)\r\n if vote == \".\":\r\n abstain_set.append(data_point)\r\n\r\n yea_entropy = abs(calc_entropy(yea_set) * (len(yea_set))/len(data_set))\r\n nay_entropy = abs(calc_entropy(nay_set) * (len(nay_set))/len(data_set))\r\n abstain_entropy = abs(calc_entropy(abstain_set) * (len(abstain_set))/len(data_set))\r\n calc_gain = entropy_before - (yea_entropy + nay_entropy + abstain_entropy)\r\n return (calc_gain,(yea_set, nay_set, abstain_set))","def reverse_quad(q):\n return [q[1], q[0], q[3], q[2]]","def __split0_global_q_dict_set(\n q_dict_col: Dict,\n col: Union[int, torch.Tensor],\n r_tiles: SquareDiagTiles,\n q_tiles: SquareDiagTiles,\n global_merge_dict: Dict = None,\n) -> None:\n # q is already created, the job of this function is to create the group the merging q's together\n # it takes the merge qs, splits them, then puts them into a new dictionary\n proc_tile_start = torch.cumsum(\n torch.tensor(r_tiles.tile_rows_per_process, device=r_tiles.arr.larray.device), dim=0\n )\n diag_proc = torch.nonzero(input=proc_tile_start > col, as_tuple=False)[0].item()\n proc_tile_start = torch.cat(\n (torch.tensor([0], device=r_tiles.arr.larray.device), proc_tile_start[:-1]), dim=0\n )\n\n # 1: create caqr dictionary\n # need to have empty lists for all tiles in q\n global_merge_dict = {} if global_merge_dict is None else global_merge_dict\n\n # intended to be used as [row][column] -> data\n # 2: loop over keys in the dictionary\n merge_list = list(q_dict_col.keys())\n merge_list.sort()\n # todo: possible improvement -> make the keys have the process they are on as well,\n # then can async get them if they are not on the diagonal process\n for key in merge_list:\n # this loops over all of the Qs for col and creates the dictionary for the pr Q merges\n p0 = key.find(\"p0\")\n p1 = key.find(\"p1\")\n end = key.find(\"e\")\n r0 = int(key[p0 + 2 : p1])\n r1 = int(key[p1 + 2 : end])\n lp_q = q_dict_col[key][0]\n base_size = q_dict_col[key][1]\n # cut the q into 4 bits (end of base array)\n # todo: modify this so that it will get what is needed from the process,\n # instead of gathering all the qs\n top_left = lp_q[: base_size[0], : base_size[0]]\n top_right = lp_q[: base_size[0], base_size[0] :]\n bottom_left = lp_q[base_size[0] :, : base_size[0]]\n bottom_right = lp_q[base_size[0] :, base_size[0] :]\n # need to adjust the keys to be the global row\n col1 = col if diag_proc == r0 else proc_tile_start[r0].item()\n col2 = proc_tile_start[r1].item()\n # col0 and col1 are the columns numbers\n # r0 and r1 are the ranks\n jdim = (col1, col1)\n kdim = (col1, col2)\n ldim = (col2, col1)\n mdim = (col2, col2)\n\n # if there are no elements on that location than set it as the tile\n # 1. get keys of what already has data\n curr_keys = set(global_merge_dict.keys())\n # 2. determine which tiles need to be touched/created\n # these are the keys which are to be multiplied by the q in the current loop\n # for matrix of form: | J K |\n # | L M |\n mult_keys_00 = [(i, col1) for i in range(q_tiles.tile_columns)] # (J)\n # (J) -> inds: (i, col0)(col0, col0) -> set at (i, col0)\n mult_keys_01 = [(i, col1) for i in range(q_tiles.tile_columns)] # (K)\n # (K) -> inds: (i, col0)(col0, col1) -> set at (i, col1)\n mult_keys_10 = [(i, col2) for i in range(q_tiles.tile_columns)] # (L)\n # (L) -> inds: (i, col1)(col1, col0) -> set at (i, col0)\n mult_keys_11 = [(i, col2) for i in range(q_tiles.tile_columns)] # (M)\n # (M) -> inds: (i, col1)(col1, col1) -> set at (i, col1)\n\n # if there are no elements in the mult_keys then set the element to the same place\n s00 = set(mult_keys_00) & curr_keys\n s01 = set(mult_keys_01) & curr_keys\n s10 = set(mult_keys_10) & curr_keys\n s11 = set(mult_keys_11) & curr_keys\n hold_dict = global_merge_dict.copy()\n\n # (J)\n if not len(s00):\n global_merge_dict[jdim] = top_left\n else: # -> do the mm for all of the mult keys\n for k in s00:\n global_merge_dict[k[0], jdim[1]] = hold_dict[k] @ top_left\n # (K)\n if not len(s01):\n # check that we are not overwriting here\n global_merge_dict[kdim] = top_right\n else: # -> do the mm for all of the mult keys\n for k in s01:\n global_merge_dict[k[0], kdim[1]] = hold_dict[k] @ top_right\n # (L)\n if not len(s10):\n # check that we are not overwriting here\n global_merge_dict[ldim] = bottom_left\n else: # -> do the mm for all of the mult keys\n for k in s10:\n global_merge_dict[k[0], ldim[1]] = hold_dict[k] @ bottom_left\n # (M)\n if not len(s11):\n # check that we are not overwriting here\n global_merge_dict[mdim] = bottom_right\n else: # -> do the mm for all of the mult keys\n for k in s11:\n global_merge_dict[k[0], mdim[1]] = hold_dict[k] @ bottom_right\n return global_merge_dict","def compute_fragments(self):\n self.fragments = []\n for part in self.parts:\n for fragment in self.compute_digest(part):\n # The part is not a fragment if it hasn't been cut at all and\n # therefore doesn't have sticky ends. Exclude from fragments.\n if not hasattr(fragment.seq, \"left_end\"):\n continue\n fragment.original_part = part\n self.annotate_fragment_with_part(fragment)\n self.fragments.append(fragment)","def SplitQuery(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)","def creator(self, q, data, num_sub_proc):\n for d in data:\n idx = d[0]\n q.put((idx, d[1]))\n\n for i in range(0, num_sub_proc):\n q.put('DONE')","def Split(ar, size):\r\n return [ar[i:i + size] for i in range(0, len(ar), size)]","def mergeSortedArrays(nums1, m, nums2, n):","def qf_union(self, p, q):\n\n if self.qf_connected(p,q):\n return True\n\n pid = self.id[p]\n for i in range(len(self.id)):\n if self.id[i] == pid:\n self.id[i] = self.id[q]\n return True","def computeShingles(q, document):\n shingles = []\n for i in range(len(document) - q + 1):\n shingle = \"\"\n for j in range(i,i+q):\n shingle += document[j]\n shingles.append(shingle)\n return shingles","def merge(self, queue2):\n with self.mutating:\n self.queue = list(heapq.merge(self.queue, queue2))\n heapq.heapify(self.queue)","def split_sort_merge(items):\n # TODO: Running time: ??? Why and under what conditions?\n # TODO: Memory usage: ??? Why and under what conditions?\n # Split items list into approximately equal halves\n pivot = int(len(items)/2)\n first_half = items[:pivot]\n second_half = items[pivot:]\n # TODO: Sort each half using any other sorting algorithm\n while not is_sorted(first_half):\n bubble_sort(first_half)\n\n while not is_sorted(second_half):\n insertion_sort(second_half)\n # TODO: Merge sorted halves into one list in sorted order\n # Why does this mutate when we use list[:]\n items[:] = merge(first_half,second_half)"],"string":"[\n \"def merge(A, p, q, r):\\n\\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\\n n1 = q - p + 1 # will hold A[p..q]\\n n2 = r - q # will hold A[q+1..r]\\n\\n L = [0] * (n1 + 1)\\n R = [0] * (n2 + 1)\\n \\n for i in range(n1):\\n L[i] = A[p+i]\\n for j in range(n2):\\n R[j] = A[q+j+1]\\n\\n # add sentinels\\n L[n1] = float('inf')\\n R[n2] = float('inf')\\n\\n # instead of sentinels, we can check if either L or R is empty,\\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\\n \\n # indices of subarrays L and R (both already previously sorted)\\n i = 0\\n j = 0\\n\\n for k in range(p, r+1):\\n if L[i] <= R[j]:\\n A[k] = L[i]\\n i += 1\\n else:\\n A[k] = R[j]\\n j += 1\",\n \"def merge_in_place(A, p, q, r):\\n n_1 = q - p + 1\\n n_2 = r - q\\n L = 0\\n R = 0\\n for k in range(p, r+1):\\n if A[p] <= A[q + 1]:\\n A.insert(r+1, A[p])\\n del A[p]\\n L += 1\\n q -= 1\\n else:\\n A.insert(r+1, A[q+1])\\n del A[q+1]\\n R += 1\\n\\n if L == n_1:\\n A[r+1:r+1] = A[p:p+n_2-R]\\n del A[p:p+n_2-R]\\n break\\n\\n if R == n_2:\\n A[r+1:r+1] = A[p:q+1]\\n del A[p:q+1]\\n break\",\n \"def merge(A, p, q, r):\\n left, right = [], []\\n for i in range(p, q + 1):\\n left.append(A[i])\\n\\n for j in range(q + 1, r + 1):\\n right.append(A[j])\\n\\n i, j = 0, 0\\n for k in range(p, r + 1):\\n if i > q - p:\\n A[k] = right[j]\\n j += 1\\n continue\\n if j > r - q - 1:\\n A[k] = left[i]\\n i += 1\\n continue\\n\\n if left[i] <= right[j]:\\n A[k] = left[i]\\n i += 1\\n else:\\n A[k] = right[j]\\n j += 1\",\n \"def merge(arr, p, q, r):\\r\\n assist = np.zeros(r-p+1)\\r\\n s = p\\r\\n t = q+1\\r\\n k = 0\\r\\n while s<=q and t<=r:\\r\\n if arr[s] < arr[t]:\\r\\n assist[k] = arr[s]\\r\\n s = s+1\\r\\n else:\\r\\n assist[k] = arr[t]\\r\\n t = t+1\\r\\n k = k+1\\r\\n if s == q+1:\\r\\n assist[k:r-p+1] = arr[t:r+1]\\r\\n else:\\r\\n assist[k:r-p+1] = arr[s:q+1]\\r\\n return assist\",\n \"def union(p, q):\\n for i in q:\\n if i not in p:\\n p.append(i)\",\n \"def union(p,q):\\n\\tfor e in q:\\n\\t\\tif e not in p:\\n\\t\\t\\tp.append(e)\",\n \"def union(self, p, q):\\n p_id = self._root(p)\\n q_id = self._root(q)\\n if (p_id == q_id):\\n return;\\n if (self._sz[p_id] < self._sz[q_id]):\\n self._id[p_id] = q_id\\n self._sz[q_id] += self._sz[p_id]\\n else:\\n self._id[q_id] = p_id\\n self._sz[p_id] += self._sz[q_id]\",\n \"def merge(*in_qs, **kwargs):\\n out_q = Queue(**kwargs)\\n threads = [Thread(target=push, args=(q, out_q)) for q in in_qs]\\n for t in threads:\\n t.daemon = True\\n t.start()\\n return out_q\",\n \"def union(self, p, q):\\n pass\",\n \"def merge_arrays_as_queues(array1, array2):\\n q_a = deque(array1)\\n q_b = deque(array2)\\n res = [-1 for _ in xrange(len(array1)+len(array2))]\\n for idx in xrange(0, len(res)):\\n print q_a, q_b\\n print res\\n if (not q_a) or (q_b[0] < q_a[0]):\\n res[idx] = q_b.popleft()\\n elif (not q_b) or (q_a[0] < q_b[0]):\\n res[idx] = q_a.popleft()\\n else:\\n res[idx] = q_b.popleft()\\n\\n return res\",\n \"def temp_split(filename):\\n filename, ext = filename.rsplit('.')\\n data = np.load(filename + \\\".\\\" + ext)\\n # define basic constants from parent\\n A = data['a']\\n A_SIZE = A.shape[0]\\n A_SHAPE = A.shape\\n ORIGINAL_SIZE = data['original_size']\\n B = data['b']\\n # basics\\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\\n # eval & evec\\n eval, evec = linalg.eigh(B)\\n # split\\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\\n # threshold (q)\\n q1 = create_q(A_SIZE, B, g1_order, m)\\n q2 = create_q(A_SIZE, B, g2_order, m)\\n # B of G\\n b1 = create_b_of_g(B, g1_order)\\n b2 = create_b_of_g(B, g2_order)\\n # a_elems\\n a1_elems = []\\n a2_elems = []\\n original_elems = data['a_elems']\\n for i in g1_order:\\n a1_elems.append(original_elems[i])\\n for i in g2_order:\\n a2_elems.append(original_elems[i])\\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\\\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))\",\n \"def _concatenate_inner(self, chunks, direction):\\n tmp_bucket = []\\n source_chunks = chunks if direction else chunks[::-1]\\n target_chunks = ChunkList()\\n for chunk in source_chunks:\\n if (\\n # if the chunk has matched dependency, do concatenation.\\n chunk.dependency == direction or\\n # if the chunk is SPACE, concatenate to the previous chunk.\\n (direction == False and chunk.is_space())\\n ):\\n tmp_bucket.append(chunk)\\n continue\\n tmp_bucket.append(chunk)\\n if not direction: tmp_bucket = tmp_bucket[::-1]\\n new_word = ''.join([tmp_chunk.word for tmp_chunk in tmp_bucket])\\n chunk.update_word(new_word)\\n target_chunks.append(chunk)\\n tmp_bucket = []\\n if tmp_bucket: target_chunks += tmp_bucket\\n return target_chunks if direction else target_chunks[::-1]\",\n \"def merge_plays(a, b, k=10):\\n x = []\\n while len(a) and len(b):\\n if b[0].points > a[0].points:\\n x.append(b.pop(0))\\n else:\\n x.append(a.pop(0))\\n\\n if len(x) >= k:\\n return x\\n while len(a):\\n x.append(a.pop(0))\\n while len(b):\\n x.append(b.pop(0))\\n return x\",\n \"def split(self, X):\",\n \"def solve_inplace(array1, array2):\\n # append all b values to end of a and then sort\\n pass\",\n \"def split(self) -> GQASplit:\\n return self._split\",\n \"def merge(self, A, ind, p, q, r, rc_array):\\n\\n left = ind[p:q + 1]\\n right = ind[q + 1:r + 1]\\n\\n i = 0\\n j = 0\\n ic = 0\\n k = p\\n\\n while i < len(left) and j < len(right):\\n if A[left[i]] > A[right[j]]:\\n ind[k] = right[j]\\n ic += 1\\n k += 1\\n j += 1\\n else:\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n i += 1\\n k += 1\\n\\n while i < len(left):\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n k += 1\\n i += 1\\n while j < len(right):\\n ind[k] = right[j]\\n k += 1\\n j += 1\",\n \"def unify(self, p, q):\\n root1, root2 = self.find(p), self.find(q)\\n\\n # If the elements are already in the same set\\n if root1 == root2:\\n return\\n\\n # Merge the smaller component/set into the larger one.\\n if self.comp_size[root1] < self.comp_size[root2]:\\n self.comp_size[root2] += self.comp_size[root1]\\n self.id[root1] = root2\\n else:\\n self.comp_size[root1] += self.comp_size[root2]\\n self.id[root2] = root1\\n\\n # Since the roots found were different, we know that the\\n # number of components/sets has decreased by one.\\n self.num_components -= 1\",\n \"def merge(a, b):\\r\\n # your code here\\r\\n \\r\\n m = []\\r\\n i, j = 0, 0\\r\\n \\r\\n while i < len(a) and j < len(b):\\r\\n if a[i] < b[j]:\\r\\n m.append(a[i])\\r\\n i += 1\\r\\n else:\\r\\n m.append(b[j])\\r\\n j += 1\\r\\n \\r\\n m += a[i:] + b[j:]\\r\\n \\r\\n return m\",\n \"def merge_quick_sort(L):\\n list1 = []\\n list2 = []\\n (evens, odds) = merge_sort.split(L)\\n list1 += quick_sort.quick_sort(evens)\\n list2 += quick_sort.quick_sort(odds)\\n x = merge_sort.merge(list1,list2)\\n return x\",\n \"def split(filename, initial=False, optimize=False):\\n # load data\\n filename, ext = filename.rsplit('.')\\n data = np.load(filename + \\\".\\\" + ext)\\n # define constants and load A if initial\\n A = data['a']\\n A_SIZE = A.shape[0]\\n A_SHAPE = A.shape\\n if initial:\\n ORIGINAL_SIZE = A_SIZE\\n else:\\n ORIGINAL_SIZE = data['original_size']\\n # basics\\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\\n # create B if initial, if not, import from archive\\n if initial:\\n p1 = create_p1(A_SHAPE, ki, kj)\\n p = create_p(p1, m)\\n B = A - p\\n else:\\n B = data['b']\\n if A_SIZE <= 1:\\n raise CannotSplit\\n # eval & evec\\n eval, evec = linalg.eigh(B)\\n # split\\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\\n # threshold (q)\\n q1 = create_q(A_SIZE, B, g1_order, m)\\n q2 = create_q(A_SIZE, B, g2_order, m)\\n # B of G\\n b1 = create_b_of_g(B, g1_order)\\n b2 = create_b_of_g(B, g2_order)\\n # a elems\\n a1_elems = []\\n a2_elems = []\\n if initial:\\n a1_elems = g1_order\\n a2_elems = g2_order\\n else:\\n original_elems = data['a_elems']\\n for i in g1_order:\\n a1_elems.append(original_elems[i])\\n for i in g2_order:\\n a2_elems.append(original_elems[i])\\n # save\\n if not g1_order or not g2_order:\\n raise CannotSplit(message='One group is empty, cannot split.')\\n if initial:\\n # save files\\n np.savez('g1.npz', a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\\n np.savez('g2.npz', a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\\n # create File records\\n files.File.create(filename='g1', ext=ext, q=q1, shape=g1.shape[0], a_elems=','.join([str(x) for x in a1_elems]))\\n files.File.create(filename='g2', ext=ext, q=q2, shape=g2.shape[0], a_elems=','.join([str(x) for x in a2_elems]))\\n # create Item records for burning\\n files.Item.create(filename='.'.join(('g1', ext)))\\n files.Item.create(filename='.'.join(('g2', ext)))\\n if optimize:\\n opt_table = []\\n for idx, elem in enumerate(g1_order):\\n # create copies of new arrays\\n new_g1_order, new_g1_arrays, new_g2_order, new_g2_arrays = g1_order[:], g1_arrays[:], g2_order[:], g2_arrays[:]\\n # first append new material to other array\\n new_g2_order.append(elem) # TODO: check if need to be sorted\\n new_g2_arrays.append(new_g1_arrays[idx]) # TODO: check if insert instead if size g2 size is >= g1 size?\\n # delete material from new_g1_*\\n del new_g1_order[idx]\\n del new_g1_arrays[idx]\\n # create new Qs\\n new_q1, new_q2 = create_q(A_SIZE, B, new_g1_order, m), create_q(A_SIZE, B, new_g2_order, m)\\n opt_table.append((elem, new_q1, new_q2))\\n return sorted(opt_table, key=lambda x: x[0])\\n else:\\n # return to manager to set parents\\n np.savez(filename + \\\",1\\\" + \\\".\\\" + ext, a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\\n np.savez(filename + \\\",2\\\" + \\\".\\\" + ext, a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\\n # save filenames for burn regardless if saved or not, why didn't I do this before in master?\\n files.Item.create(filename=filename + ',2.' + ext)\\n files.Item.create(filename=filename + ',1.' + ext)\\n # return so we can manipulate\\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\\\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))\",\n \"def qu_union(self, p, q):\\n pID = self.qu_findroot(p)\\n qID = self.qu_findroot(q)\\n\\n if pID == qID: return\\n\\n if p > q: self.id[qID] = pID\\n else: self.id[pID] = qID\\n return 1\",\n \"def splice(i, j, data):\\n n = len(data)\\n out = ()\\n splice_a = []\\n splice_b = []\\n i = idx(i, n)\\n j = idx(j, n)\\n i+=1\\n j+=1\\n if(i < j):\\n splice_a = data[i:j]\\n splice_b = data[j:] + data[0:i]\\n else:\\n splice_a = data[i:] + data[0:j]\\n splice_b = data[j:i]\\n\\n return (splice_a, splice_b)\",\n \"def test_merge(self):\\n A = [1,4,6,7,8,2,3,4,5,7]\\n p = 0\\n q = 5\\n r = 10\\n A_merged = mst.merge(A, p, q, r)\\n expected = [1, 2, 3, 4, 4, 5, 6, 7, 7, 8] \\n self.assertEqual(A, A_merged)\",\n \"def wqu_union(self, p, q):\\n pID = self.qu_findroot(p)\\n qID = self.qu_findroot(q)\\n\\n if pID == qID: return\\n if(self.sz[pID] < self.sz[qID]):\\n self.id[pID] = qID\\n self.sz[qID] += self.sz[pID]\\n else:\\n self.id[qID] = pID\\n self.sz[pID] += self.sz[qID]\\n return 1\",\n \"def merge(a, b):\\n result = []\\n\\n # Append smallest values to result until either list is exhausted\\n i = j = 0\\n while i < len(a) and j < len(b):\\n if compare(a[i], b[j]) < 0:\\n result.append(a[i])\\n i += 1\\n else:\\n result.append(b[j])\\n j += 1\\n\\n # Append all remaining values from the unexhausted list\\n if i < len(a):\\n result.extend(a[i:])\\n else:\\n result.extend(b[j:])\\n\\n return result\",\n \"def _merge_intent_fragments(self, start_offset, upload_intents, copy_intents):\\n upload_intents = deque(upload_intents)\\n copy_intents = deque(copy_intents)\\n while True:\\n upload_intent = copy_intent = None\\n if upload_intents:\\n upload_intent, upload_end, _ = upload_intents[0]\\n if copy_intents:\\n copy_intent, copy_end, copy_protected = copy_intents[0]\\n\\n if upload_intent is not None and copy_intent is not None:\\n if not copy_protected:\\n yield_intent = upload_intent\\n else:\\n yield_intent = copy_intent\\n start_offset = min(upload_end, copy_end)\\n yield yield_intent, start_offset\\n if start_offset >= upload_end:\\n upload_intents.popleft()\\n if start_offset >= copy_end:\\n copy_intents.popleft()\\n elif upload_intent is not None:\\n yield upload_intent, upload_end\\n upload_intents.popleft()\\n elif copy_intent is not None:\\n yield copy_intent, copy_end\\n copy_intents.popleft()\\n else:\\n return\",\n \"def wpqu_union(self, p, q):\\n pID = self.pqu_findroot(p)\\n qID = self.pqu_findroot(q)\\n\\n if pID == qID: return\\n if (self.sz[pID] < self.sz[qID]):\\n self.id[pID] = qID\\n self.sz[qID] += self.sz[pID]\\n else:\\n self.id[qID] = pID\\n self.sz[pID] += self.sz[qID]\\n return 1\",\n \"def spliter(temp,split1,split2):\\n for x in range(len(temp)):\\n if x<len(temp)/2:\\n split1.append(temp[x])\\n else:\\n split2.append(temp[x])\",\n \"def qsort(A, l, r):\\n if l < r:\\n q = partition(A, l, r)\\n qsort(A, l, q-1)\\n qsort(A, q+1, r)\",\n \"def union(self, p, q):\\n self._validate(p)\\n self._validate(q)\\n p_parent = self.find(p)\\n q_parent = self.find(q)\\n if p_parent == q_parent:\\n return\\n for i in range(len(self.parents)):\\n if self.parents[i] == q_parent:\\n self.parents[i] = p_parent\\n self.n -= 1\",\n \"def split_chunk(chunk, *a, **kw):\\n return split_chunk(chunk, *a, **kw)\",\n \"def pqu_union(self, p, q):\\n pID = self.pqu_findroot(p)\\n qID = self.pqu_findroot(q)\\n\\n if pID == qID: return\\n\\n if p > q:\\n self.id[qID] = pID\\n else:\\n self.id[pID] = qID\\n return 1\",\n \"def qids_to_splits(qids):\\n qidmap = {}\\n i = 0\\n for qid in qids:\\n if not qid in qidmap:\\n qidmap[qid] = i\\n i+=1\\n new_qids = []\\n for qid in qids:\\n new_qids.append(qidmap[qid])\\n qidcount = np.max(new_qids)+1\\n splits = [[] for i in range(qidcount)]\\n for i, qid in enumerate(new_qids):\\n splits[qid].append(i) \\n return splits\",\n \"def merge_sort(alist):\\n print(\\\"Splitting \\\", alist)\\n # Temporary list to store sorted list\\n work = [None] * len(alist)\\n rec_merge_sort(work, start=0, end=len(alist)-1)\",\n \"def split(aDeck,location):\\r\\n newDeck=[]\\r\\n for x in range(location):\\r\\n newDeck.append(aDeck.pop())\\r\\n return (newDeck)\",\n \"def union(self, p, q):\\n p_id = self._root(p)\\n q_id = self._root(q)\\n self._id[p_id] = q_id\",\n \"def splits_array_switcher(trajectory1, trajectory2, index_of_cut):\\r\\n\\r\\n trajectory1_a, trajectory2_b = trajectory1[:index_of_cut], trajectory1[index_of_cut:]\\r\\n trajectory2_a, trajectory1_b = trajectory2[:index_of_cut], trajectory2[index_of_cut:]\\r\\n\\r\\n trajectory1 = np.concatenate((trajectory1_a, trajectory1_b), axis=0)\\r\\n trajectory2 = np.concatenate((trajectory2_a, trajectory2_b), axis=0)\\r\\n\\r\\n return trajectory1, trajectory2\",\n \"def _intermediates(q, results):\\n # type: (np.ndarray, List[Tuple[Kernel, np.ndarray, Optional[Callable]]]) -> OrderedDict[str, Any]\\n parts = OrderedDict()\\n for part_num, (kernel, Iq, intermediates) in enumerate(results):\\n part_id = chr(ord('A') + part_num) + \\\"_\\\" + kernel.info.name + \\\"(Q)\\\"\\n parts[part_id] = (q, Iq)\\n if intermediates is not None:\\n parts[part_id + \\\" parts\\\"] = intermediates()\\n return parts\",\n \"def sortbatch(q_batch, a_batch, q_lens, a_lens):\\n maxlen_q = max(q_lens)\\n maxlen_a = max(a_lens)\\n q=q_batch[:,:maxlen_q-1]\\n a=a_batch[:,:maxlen_a-1]\\n sorted_idx = torch.LongTensor(a_lens.numpy().argsort()[::-1].copy())\\n return q[sorted_idx], a[sorted_idx], q_lens[sorted_idx], a_lens[sorted_idx]\",\n \"def _group_chunks_by_entities(self, chunks, entities):\\n for entity in entities:\\n chunks_to_concat = chunks.get_overlaps(\\n entity['beginOffset'], len(entity['content']))\\n if not chunks_to_concat: continue\\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\\n new_chunk = Chunk(new_chunk_word)\\n chunks.swap(chunks_to_concat, new_chunk)\\n return chunks\",\n \"def _group_chunks_by_entities(self, chunks, entities):\\n for entity in entities:\\n chunks_to_concat = chunks.get_overlaps(\\n entity['beginOffset'], len(entity['content']))\\n if not chunks_to_concat:\\n continue\\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\\n new_chunk = Chunk(new_chunk_word)\\n chunks.swap(chunks_to_concat, new_chunk)\\n return chunks\",\n \"def wpqu_union(self, p, q):\\n if self.wpqu_connected(p,q):\\n return True;\\n \\n p_pa,q_pa = self.id[p],self.id[q]\\n \\n if self.sz[p_pa] >= self.sz[q_pa]:\\n self.id[q_pa] = p_pa\\n self.sz[p_pa] += self.sz[q_pa] \\n else:\\n self.id[p_pa] = q_pa\\n self.sz[q_pa] += self.sz[p_pa] \\n return True\",\n \"def d_j(self,q):\\n dj = q.shift(y=-1) - q # works with chunks too\\n return dj\",\n \"def _load_data(l, q, nproc):\\n for element in l:\\n q.put(element)\\n for _ in range(nproc):\\n q.put(FINISHED)\",\n \"def busca_base(A, a, q):\\n \\n \\n nrow = np.shape(A)[0]\\n zeros = np.zeros((nrow, 1))\\n B0, _ = householder(power(A-a*np.identity(nrow), q), zeros)\\n \\n # calcula el rango de la matriz B0\\n r = rango_matrix(B0)\\n \\n # G = [G1, G2, ..., Gn-r], donde Gi: i-esimo vector generador de N((A-aI)^{q})\\n # NOTA: No esta garanizado que {G1, G2, ..., Gn-r}, sean li\\n G = np.zeros((nrow, nrow-r))\\n for k in range(r):\\n # coeff(k, i): coeficiente de xi en la combinacion lineal de los xr+1,xr+2,...,xn, para obtener -B0[k,k]xk\\n G[k,:] = - np.array([coeff(k,r+i, B0) for i in range(1, nrow-r+1)])/B0[k,k]\\n G[nrow:, :] = np.identity(nrow-r)\\n \\n return vectores_li(G, r) # retorna solo los vectore li de {G1, G2, ..., Gn-r}, en una matriz\",\n \"def wqu_union(self, p, q):\\n \\n if self.wqu_connected(p, q):\\n return True\\n \\n p_pa,q_pa = p,q\\n while p_pa != self.id[p_pa]:\\n p_pa = self.id[p_pa]\\n while q_pa != self.id[q_pa]:\\n q_pa = self.id[q_pa]\\n \\n if self.sz[p_pa] >= self.sz[q_pa]:\\n self.id[q_pa] = p_pa\\n self.sz[p_pa] += self.sz[q_pa] \\n else:\\n self.id[p_pa] = q_pa\\n self.sz[q_pa] += self.sz[p_pa] \\n return True\",\n \"def pqu_union(self, p, q):\\n if self.pqu_connected(p,q):\\n return True\\n self.id[self.id[p]] = self.id[q]\\n return True\",\n \"def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\\n A[m:] = B\\n A.sort()\",\n \"def mergesort(A, p, r):\\n if p < r:\\n q = (p+r)//2\\n mergesort(A, p, q)\\n mergesort(A, q + 1, r)\\n merge(A, p, q, r)\",\n \"def split_segments(old_seg_ends, B):\\n new_segment_ends = []\\n for q in range(0, B.size):\\n new_ends = list(np.linspace(old_seg_ends[q], old_seg_ends[q + 1], B[q] + 1))\\n new_segment_ends.extend(new_ends[:-1])\\n new_segment_ends.extend([1])\\n new_segment_ends = np.asarray(new_segment_ends)\\n return new_segment_ends\",\n \"def merge(li: Sequence, left_index: int, mid_index: int, right_index: int) -> None:\\n left_li = li[left_index : mid_index]\\n right_li = li[mid_index : right_index]\\n i, j, k = 0, 0, left_index\\n \\n while i < len(left_li) and j < len(right_li):\\n if left_li[i] <= right_li[j]:\\n li[k] = left_li[i]\\n i += 1\\n else:\\n li[k] = right_li[j]\\n j += 1\\n k += 1\\n \\n # Copy the remainders\\n while i < len(left_li):\\n li[k] = left_li[i]\\n i += 1\\n k += 1\\n while j < len(right_li):\\n li[k] = right_li[j]\\n j += 1\\n k += 1\",\n \"def merge_recs(part_one, part_two, output):\\n start_op_length = 28\\n with open(part_one, 'rb') as a_handle, \\\\\\n open(part_two, 'rb') as b_handle, \\\\\\n open(output, 'wb') as merged:\\n\\n a_data = a_handle.read()\\n b_data = b_handle.read()\\n\\n postgame_pos, _ = find_postgame(a_data, len(a_data))\\n if postgame_pos:\\n a_data_end = postgame_pos - LOOKAHEAD\\n else:\\n a_data_end = len(a_data)\\n b_header_len, = struct.unpack('<I', b_data[:4])\\n chapter = mgz.body.operation.build({\\n 'type': 'action',\\n 'op': 1,\\n 'length': 2,\\n 'action': {\\n 'type': 'chapter',\\n 'player_id': 0xff # our merge marker\\n }\\n })\\n\\n # part A with no postgame struct\\n merged.write(a_data[:a_data_end])\\n # chapter action\\n merged.write(chapter)\\n # offset to start of part B operations\\n merged.write(struct.pack('<I', a_data_end + len(chapter) + b_header_len))\\n # part B header (now a \\\"saved chapter\\\")\\n merged.write(b_data[4:b_header_len])\\n # part B operations with no start operation\\n merged.write(b_data[b_header_len + start_op_length:])\",\n \"def mergeSeq(left, right):\\n i = j = 0\\n result = []\\n while i < len(left) and j < len(right):\\n if left[i] <= right[j]:\\n result.append(left[i])\\n i += 1\\n else:\\n result.append(right[j])\\n j += 1\\n\\n result += left[i:]\\n result += right[j:]\\n return result\",\n \"def _get_pmx_crossed_sequence(sequence_a: OrderedSet, sequence_b: OrderedSet,\\n part_from_a: OrderedSet, part_from_b: OrderedSet,\\n start_index: int, end_index: int) -> List[int]:\\n new_sequence = list(sequence_b)\\n\\n elements_requiring_correction = {}\\n\\n uniques_from_b_part = part_from_b - part_from_a\\n for unique_from_b_part in uniques_from_b_part:\\n index_in_part = part_from_b.index(unique_from_b_part)\\n elements_requiring_correction[unique_from_b_part] = part_from_a[index_in_part]\\n\\n for elem_from_b, elem_from_a in elements_requiring_correction.items():\\n while elem_from_a in part_from_b:\\n index_of_elem_from_b = sequence_b.index(elem_from_a)\\n elem_from_a = sequence_a[index_of_elem_from_b]\\n\\n new_index = sequence_b.index(elem_from_a)\\n new_sequence[new_index] = elem_from_b\\n\\n new_sequence[start_index:end_index] = part_from_a\\n\\n return new_sequence\",\n \"def push(self, x):\\n # enqueue new element to q2\\n self.q2.enqueue(x)\\n # dequeue from q1 and enqueue in q2\\n\\n while self.q1.qlist:\\n self.q2.enqueue(self.q1.dequeue())\\n # swap q1 and q2\\n temp = self.q1.qlist\\n self.q1.qlist = self.q2.qlist\\n self.q2.qlist = temp\",\n \"def merge(a,b):\\n c = []\\n while len(a) != 0 and len(b) != 0:\\n if a[0] < b[0]:\\n c.append(a[0])\\n a.remove(a[0])\\n else:\\n c.append(b[0])\\n b.remove(b[0])\\n if len(a) == 0:\\n c += b\\n else:\\n c += a\\n return c\",\n \"def interval_split(a,b,split_ps):\\n ps = [a] + [s for s in sorted(split_ps) if a < s < b] + [b]\\n return [(p1,p2) for p1,p2 in zip(ps,ps[1:])]\",\n \"def addToBq(self, p):\\n self.allJobs.append(p)\\n p.submitToQueue()\\n if len(self.circQ) < self.maxLength - 1:\\n self.circQ.append(p)\",\n \"def addToBq(self, p):\\n self.allJobs.append(p)\\n p.submitToQueue()\\n if len(self.circQ) < self.maxLength - 1:\\n self.circQ.append(p)\",\n \"def merge_ranges():\",\n \"def qf_union(self, p, q):\\n pID = self.id[p]\\n\\n for x in range(len(self.id)):\\n if self.id[x] == pID:\\n self.id[x] = self.id[q]\\n return 1\",\n \"def merge_reads(s1, s2, q1, q2, amplen):\\n # If the amplicon is of length L and the reads are lengths l1, l2 then:\\n # - read 1 from 0 to L-l2-1 inclusive doesn't overlap\\n # - read 1 from L-l2 to l1-1 inclusive overlaps with read 2\\n # - read 2 from 0 to l1+l2-L-1 inclusive overlaps with read 1\\n # - read 2 from l1+l2-L to its end doesn't overlap\\n\\n # A picture for clarity:\\n # s1 coords: 0 l1-1\\n # | |\\n # ----------------------------------------\\n # ------------------------------\\n # | | |\\n # s1 coords: L-l2 | L-1\\n # s2 coords: 0 l1+l2-L-1\\n\\n # Reverse complement read 2 and reverse its quality scores.\\n s2 = reverse_complement(s2)\\n q2 = q2[::-1]\\n\\n # This is where we'll put the merged sequence and quality score.\\n s = np.zeros(amplen, dtype=np.int8)\\n q = np.zeros(amplen, dtype=np.int8)\\n\\n # If the reads overlap correctly, then s1[offset+i] == s2[i], assuming s2 is\\n # the reverse complement of the reverse read.\\n offset = amplen - len(s2)\\n\\n # Fill in the parts of the merged sequence where the reads don't overlap.\\n s[:offset] = s1[:offset]\\n q[:offset] = q1[:offset]\\n s[len(s1):] = s2[len(s1)+len(s2)-amplen:]\\n q[len(s1):] = q2[len(s1)+len(s2)-amplen:]\\n\\n # Create a set of views into the overlapping region. We can directly compare\\n # vs1[i] to vs2[i] and use that to fill in vs[i] with all indexing taken\\n # care of.\\n vs1 = s1[offset:]\\n vq1 = q1[offset:]\\n vs2 = s2[:len(vs1)]\\n vq2 = q2[:len(vs1)]\\n vs = s[offset:len(s1)]\\n vq = q[offset:len(s1)]\\n\\n # Quality score of matching bases is the larger of the two quality\\n # scores (this is a somewhat conservative low estimate). Quality\\n # score of mismatched bases is the difference of the two quality\\n # scores. If the mismatched bases have equal quality scores, the\\n # base is written as an N with the minimum possible quality.\\n\\n # Positions where the reads agree.\\n ieq = vs1 == vs2\\n vs[ieq] = vs1[ieq]\\n vq[ieq] = np.maximum(vq1[ieq], vq2[ieq])\\n\\n # Positions where the reads disagree.\\n ineq = vs1 != vs2\\n mismatches = ineq.sum()\\n\\n # Positions where the reads disagree and read 1 has the higher quality.\\n ir1 = np.logical_and(ineq, vq1 > vq2)\\n vs[ir1] = vs1[ir1]\\n vq[ir1] = MIN_QUAL + vq1[ir1] - vq2[ir1]\\n\\n # Positions where the reads disagree and read 2 has the higher quality.\\n ir2 = np.logical_and(ineq, vq2 > vq1)\\n vs[ir2] = vs2[ir2]\\n vq[ir2] = MIN_QUAL + vq2[ir2] - vq1[ir2]\\n\\n # Positions where the reads disagree and they have equal qualities.\\n irn = np.logical_and(ineq, vq1 == vq2)\\n vs[irn] = bN\\n vq[irn] = MIN_QUAL\\n\\n return s, q, mismatches\",\n \"def sort(self, A, index, p, r, rc_arr):\\n\\n if p < r:\\n q = (p + r) // 2\\n\\n self.sort(A, index, p, q, rc_arr)\\n self.sort(A, index, q + 1, r, rc_arr)\\n self.merge(A, index, p, q, r, rc_arr)\",\n \"def _prepare(self, q):\\n # store it in _lastr which is consulted in BasePDFGenerator.__call__\\n self._lastr = q\\n self._calc.qstep = q[1] - q[0]\\n self._calc.qmin = q[0]\\n self._calc.qmax = q[-1] + 0.5*self._calc.qstep\\n return\",\n \"def __init__(self):\\n self.A = [] # 大顶堆，存放较小的元素\\n self.B = [] # 小顶堆，存放较大的元素，使得B的最小的元素也比A中最大的元素大，保证数据流保持有序\",\n \"def merge(self, parallel_seq):\\n return _OSeq(sorted(self._elements + parallel_seq._elements, key=lambda x: x.get(offset_attr, 0)))\",\n \"def mconcat(a, b):\\r\\n if a is None:\\r\\n return b\\r\\n if b is None:\\r\\n return a\\r\\n for key in b.keyset:\\r\\n value=get(b,key)\\r\\n put(a,key,value)\\r\\n return a\",\n \"def merge(items, start, end, subarray_size):\\n mid = start + subarray_size\\n assert is_sorted(items[start:mid])\\n assert is_sorted(items[start+subarray_size:end])\\n\\n aux = []\\n i = start\\n j = mid\\n\\n while i < mid and j < end:\\n if items[i] < items[j]:\\n aux.append(items[i])\\n i += 1\\n else:\\n aux.append(items[j])\\n j += 1\\n aux.extend(items[i:mid] or items[j:end])\\n assert is_sorted(aux)\\n\\n ## Overwrite elements in subarrays in their correctly sorted order\\n for i in range(start, end):\\n items[i] = aux[i-start]\",\n \"def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\\n # # solution one: sort\\n # A[m:] = B\\n # A.sort()\\n\\n # solution two: two point\\n if n == 0: # B = []\\n return\\n i, j, k = m - 1, n - 1, m + n - 1\\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\\n if A[i] <= B[j]:\\n A[k] = B[j]\\n k -= 1\\n j -= 1\\n else:\\n A[k] = A[i]\\n k -= 1\\n i -= 1\\n if j > -1:\\n A[:j + 1] = B[:j + 1] # A = [], B = [1]\",\n \"def test_merge():\\n\\n q1 = PriorityQueue()\\n q2 = PriorityQueue()\\n\\n # input list (obj, priority) should be reversed\\n # in the priority_queue\\n input_list = [((1), 9), ((2), 8), ((3), 7),\\n ((4), 6), ((5), 5), ((6), 4),\\n ((7), 3), ((8), 2), ((9), 1)]\\n\\n # insert the items into the queues\\n for idx, (obj, p) in enumerate(input_list):\\n if idx < 4:\\n q1.push(obj, p)\\n else:\\n q2.push(obj, p)\\n\\n # merge the queues\\n q1.merge(q2)\\n\\n # dump the queue into a list\\n output = []\\n while q1._queue:\\n output.append(q1.pop())\\n\\n # validate the expected behavior\\n eq_(output, range(1, 10)[::-1])\",\n \"def subsample(self, dQ):\\n # Assumes self contains sorted Qo and associated T, L\\n # Note: calc_Qo is already sorted\\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\\n idx = np.unique(np.searchsorted(self.Qo, Q))\\n #print len(idx), len(self.Qo)\\n\\n self.T, self.dT = self.T[idx], self.dT[idx]\\n self.L, self.dL = self.L[idx], self.dL[idx]\\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\\n if self.R is not None:\\n self.R = self.R[idx]\\n if self.dR is not None:\\n self.dR = self.dR[idx]\\n self._set_calc(self.T, self.L)\",\n \"def test_three_split():\\n run_mergesort([3, 0, 3], [0, 3, 3])\",\n \"def concatenate(self):\\n if not self.match_count:\\n # No concatenating if there are no matches\\n return []\\n if self.match_count <= 1:\\n # Can't combine a single match\\n return self.match_list\\n # Setup for iterating through\\n cont = True\\n first = self.match_list[self.i]\\n second = self.match_list[self.j]\\n while cont and self.match_count > 2:\\n first, second, cont = self._process_main()\\n\\n # Last block is a special case\\n self._process_last(first, second)\\n return self.combined\",\n \"def mergesort(input):\\n\\n if len(input) <= 1:\\n return input\\n\\n cut = len(input) // 2 # floored quotient\\n top = mergesort(input[:cut])\\n bottom = mergesort(input[cut:])\\n\\n i = 0\\n j = 0\\n\\n output = []\\n for x in range(len(input)):\\n if top[i] < bottom[j]:\\n output.append(top[i])\\n i += 1\\n if i >= len(top):\\n output += bottom[j:]\\n break\\n else:\\n output.append(bottom[j])\\n j += 1\\n if j >= len(bottom):\\n output += top[i:]\\n break\\n\\n return output\",\n \"def quick_sort_helper(a_list, first_position, last_position):\\n if first_position < last_position:\\n\\n split_point = partition(a_list, first_position, last_position)\\n\\n quick_sort_helper(a_list, first_position, split_point)\\n quick_sort_helper(a_list, split_point + 1, last_position)\\n\\n return a_list\",\n \"def q_append_non_leaf(node, q):\\n for i in range(q-1):\\n node.addkid(Node(\\\"*\\\"), before=True)\\n node.addkid(Node(\\\"*\\\"))\",\n \"def union(self,i,j):\\n ii, jj = self.find(i), self.find(j)\\n if ii != jj:\\n\\n if self.rank[ii] > self.rank[jj]: \\n ii,jj = jj,ii\\n\\n if self.rank[ii] == self.rank[jj]: \\n self.rank[jj]+=1\\n\\n self.size[jj] += self.size[ii]\\n self.par[ii] = jj\\n\\n self.cMax = max(self.size[jj],self.cMax)\\n self.nComp -=1\\n\\n del self.size[ii]\",\n \"def merge(work, start_left, start_right, upper_bound):\\n # Keep track of index in temporary list\\n # whose length is the same as the original list\\n i = 0\\n lower_bound = start_left\\n mid = start_right - 1\\n # size of list after merge\\n n = upper_bound - lower_bound + 1\\n\\n # compare two sub lists per item\\n # and insert in original list\\n while start_left <= mid and start_right <= upper_bound:\\n work[i] = min(a_list[start_left], a_list[start_right])\\n if work[i] == a_list[start_left]:\\n start_left += 1\\n else:\\n start_right += 1\\n i += 1\\n\\n # If all items from second list are in original list\\n # insert all of the items from the first list\\n # as list is already sorted\\n while start_left <= mid:\\n work[i] = a_list[start_left]\\n i += 1\\n start_left += 1\\n\\n # If all items from first list are in original list\\n # insert all of the items from the second list\\n # as list is already sorted\\n while start_right <= upper_bound:\\n work[i] = a_list[start_right]\\n i += 1\\n start_right += 1\\n\\n # Transfer the temporary list \\\"work\\\" back to original\\n # list \\\"a_list\\\"\\n for k in range(0, n):\\n a_list[lower_bound+k] = work[k]\",\n \"def union(self, p, q):\\n root_p = self.find(p)\\n root_q = self.find(q)\\n if root_p == root_q:\\n return\\n \\n #if the sites were isolated make them un-isolated\\n if self._nodes[p] == 1:\\n self._nodes[p] = 0\\n self._iso -= 1\\n if self._nodes[q] == 1:\\n self._nodes[q] = 0\\n self._iso -= 1\\n\\n # make root of smaller rank point to root of larger rank\\n if self._rank[root_p] < self._rank[root_q]:\\n self._parent[root_p] = root_q\\n #add the small root size to the big root size\\n self._size[root_q] += self._size[root_p]\\n #check if the big root size is now the biggest\\n if self._size[root_q] > self._max:\\n self._max = self._size[root_q]\\n elif self._rank[root_p] > self._rank[root_q]:\\n self._parent[root_q] = root_p\\n self._size[root_p] += self._size[root_q]\\n if self._size[root_p] > self._max:\\n self._max = self._size[root_p]\\n else:\\n self._parent[root_q] = root_p\\n self._size[root_p] += self._size[root_q]\\n if self._size[root_p] > self._max:\\n self._max = self._size[root_p]\\n self._rank[root_p] += 1\\n\\n self._count -= 1\",\n \"def qu_union(self, p, q):\\n\\n if self.qu_connected(p, q):\\n return True\\n\\n p_pa,q_pa = p,q\\n while p_pa != self.id[p_pa]:\\n p_pa = self.id[p_pa]\\n while q_pa != self.id[q_pa]:\\n q_pa = self.id[q_pa]\\n self.id[p_pa] = q_pa\\n\\n return True\",\n \"def split_sort_merge(items):\\n # TODO: Split items list into approximately equal halves\\n pivot = len(items) // 2\\n # TODO: Sort each half using any other sorting algorithm\\n # sort first half in-place (insertion sort)\\n left = insertion_sort(items[:pivot])\\n\\n right = insertion_sort(items[pivot:])\\n # TODO: Merge sorted halves into one list in sorted order\\n # merge the two half list (merge function but this does this in-place)\\n sorted_list = merge(left, right)\\n # change the input items\\n items[:] = sorted_list\\n return items\",\n \"def split(self):\\n\\n # FIXME: user should be able to change the default behavior of\\n # this function (for instance user may require one filter not\\n # to split the content of the input file and the same input \\n # to be used by the next filter.\\n \\n utils.split_file(self.files['hit_ids'],\\n self.files['input'],\\n self.files['filtered_reads'],\\n self.files['survived_reads'])\",\n \"def merge(A, left, middle, right):\\n leftSubArray = A[left:middle]\\n rightSubArray = A[middle:right+1]\\n leftSubArray.append(float(\\\"inf\\\"))\\n rightSubArray.append(float(\\\"inf\\\"))\\n i = j = 0\\n for k in xrange(left, right + 1):\\n if leftSubArray[i] < rightSubArray[j]:\\n A[k] = leftSubArray[i]\\n i += 1\\n else:\\n A[k] = rightSubArray[j]\\n j += 1\\n return A\",\n \"def queued(values, qsize):\\n values = [_normalize(v) for v in values]\\n if qsize < 1:\\n raise ValueError(\\\"qsize must be 1 or larger\\\")\\n q = []\\n it = iter(values)\\n try:\\n for i in range(qsize):\\n q.append(next(it))\\n for i in cycle(range(qsize)):\\n yield q[i]\\n q[i] = next(it)\\n except StopIteration:\\n pass\",\n \"def rejoin(l0,l1=None):\\r\\n while len(l0) != 0:\\r\\n if l1 is None:\\r\\n l1 = []\\r\\n if l0[0] == '<':\\r\\n if len(l0) >= 3:\\r\\n if l0[2] == '>':\\r\\n l1 += [l0.pop(0) + l0.pop(0) + l0.pop(0)]\\r\\n else:\\r\\n l1 += [l0.pop(0)]\\r\\n return l1\",\n \"def fastq_qc(demultiplex_result, out_dir, config):\\n\\n pigz_cores = int(config['fastqTrim']['pigz_cores'])\\n cutadapt_cores = int(config['fastqTrim']['cutadapt_cores'])\\n\\n r1_adapter = config['fastqTrim']['r1_adapter']\\n r2_adapter = config['fastqTrim']['r1_adapter']\\n length_threshold = config['fastqTrim']['length_threshold']\\n quality_threshold = config['fastqTrim']['quality_threshold']\\n r1_left_cut = config['fastqTrim']['r1_left_cut']\\n r1_right_cut = config['fastqTrim']['r1_right_cut']\\n r2_left_cut = config['fastqTrim']['r2_left_cut']\\n r2_right_cut = config['fastqTrim']['r2_right_cut']\\n overlap = config['fastqTrim']['overlap']\\n total_reads_threshold = int(config['fastqTrim']['total_reads_threshold'])\\n\\n results = []\\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\\n sample_demultiplex_total = sub_df['Trimmed'].sum()\\n if sample_demultiplex_total < total_reads_threshold:\\n log.info(f'In uid {uid}: index {index_name} skipped '\\n f'due to too less reads: {sample_demultiplex_total}')\\n continue\\n # process R1\\n r1_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R1.fq.gz'\\n r1_out = f'{out_dir}/{uid}_{index_name}_R1.trimed.fq.gz'\\n r1_cmd = f'pigz -cd -p {pigz_cores} {r1_path_pattern} | ' \\\\\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\\\\n f'-q {quality_threshold} -u {r1_left_cut} ' \\\\\\n f'-u -{r1_right_cut} -m {length_threshold} ' \\\\\\n f'-a {r1_adapter} -o {r1_out} -'\\n r1_result = subprocess.run(r1_cmd, stdout=subprocess.PIPE,\\n encoding='utf8', shell=True, check=True)\\n\\n # get R1 result stat\\n lines = []\\n for line in r1_result.stdout.split('\\\\n'):\\n ll = line.split('\\\\t')\\n if len(ll) > 1:\\n lines.append(ll)\\n s = pd.Series({name: number for name, number in zip(*lines)})\\n s['uid'] = uid\\n s['index_name'] = index_name\\n s['read_type'] = 'R1'\\n results.append(s)\\n\\n # process R2\\n r2_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R2.fq.gz'\\n r2_out = f'{out_dir}/{uid}_{index_name}_R2.trimed.fq.gz'\\n r2_cmd = f'pigz -cd -p {pigz_cores} {r2_path_pattern} | ' \\\\\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\\\\n f'-q {quality_threshold} -u {r2_left_cut} ' \\\\\\n f'-u -{r2_right_cut} -m {length_threshold} ' \\\\\\n f'-a {r2_adapter} -o {r2_out} -'\\n r2_result = subprocess.run(r2_cmd, stdout=subprocess.PIPE,\\n encoding='utf8', shell=True, check=True)\\n # get R2 result stat\\n lines = []\\n for line in r2_result.stdout.split('\\\\n'):\\n ll = line.split('\\\\t')\\n if len(ll) > 1:\\n lines.append(ll)\\n s = pd.Series({name: number for name, number in zip(*lines)})\\n s['uid'] = uid\\n s['index_name'] = index_name\\n s['read_type'] = 'R2'\\n results.append(s)\\n\\n fastq_final_result = pd.DataFrame(results)\\n if len(results) == 0:\\n # all sample skipped\\n return fastq_final_result\\n fastq_final_result['out_reads_rate'] = \\\\\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\\n fastq_final_result['out_bp_rate'] = \\\\\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\\n\\n # clean up\\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\\n r_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R*.fq.gz'\\n r_rm_cmd = f'rm -f {r_path_pattern}'\\n subprocess.run(r_rm_cmd, shell=True)\\n # remove unknown reads\\n r_path_pattern = f'{out_dir}/{uid}_L*_unknown_R*.fq.gz'\\n r_rm_cmd = f'rm -f {r_path_pattern}'\\n subprocess.run(r_rm_cmd, shell=True)\\n\\n return fastq_final_result\",\n \"def array_to_pq(pq, source):\\r\\n temp = None\\r\\n \\r\\n while source != []:\\r\\n temp = source.pop(0)\\r\\n pq.insert(temp)\\r\\n\\r\\n return\",\n \"def split_by(data_set, question, entropy_before):\\r\\n yea_set = []\\r\\n nay_set = []\\r\\n abstain_set = []\\r\\n\\r\\n for data_point in data_set:\\r\\n vote = data_point.dat_votes[ord(question)-97] #the way this representative voted is the data_point's votes indexed by question\\r\\n party = data_point.dat_party\\r\\n\\r\\n if vote == \\\"+\\\":\\r\\n yea_set.append(data_point)\\r\\n if vote == \\\"-\\\":\\r\\n nay_set.append(data_point)\\r\\n if vote == \\\".\\\":\\r\\n abstain_set.append(data_point)\\r\\n\\r\\n yea_entropy = abs(calc_entropy(yea_set) * (len(yea_set))/len(data_set))\\r\\n nay_entropy = abs(calc_entropy(nay_set) * (len(nay_set))/len(data_set))\\r\\n abstain_entropy = abs(calc_entropy(abstain_set) * (len(abstain_set))/len(data_set))\\r\\n calc_gain = entropy_before - (yea_entropy + nay_entropy + abstain_entropy)\\r\\n return (calc_gain,(yea_set, nay_set, abstain_set))\",\n \"def reverse_quad(q):\\n return [q[1], q[0], q[3], q[2]]\",\n \"def __split0_global_q_dict_set(\\n q_dict_col: Dict,\\n col: Union[int, torch.Tensor],\\n r_tiles: SquareDiagTiles,\\n q_tiles: SquareDiagTiles,\\n global_merge_dict: Dict = None,\\n) -> None:\\n # q is already created, the job of this function is to create the group the merging q's together\\n # it takes the merge qs, splits them, then puts them into a new dictionary\\n proc_tile_start = torch.cumsum(\\n torch.tensor(r_tiles.tile_rows_per_process, device=r_tiles.arr.larray.device), dim=0\\n )\\n diag_proc = torch.nonzero(input=proc_tile_start > col, as_tuple=False)[0].item()\\n proc_tile_start = torch.cat(\\n (torch.tensor([0], device=r_tiles.arr.larray.device), proc_tile_start[:-1]), dim=0\\n )\\n\\n # 1: create caqr dictionary\\n # need to have empty lists for all tiles in q\\n global_merge_dict = {} if global_merge_dict is None else global_merge_dict\\n\\n # intended to be used as [row][column] -> data\\n # 2: loop over keys in the dictionary\\n merge_list = list(q_dict_col.keys())\\n merge_list.sort()\\n # todo: possible improvement -> make the keys have the process they are on as well,\\n # then can async get them if they are not on the diagonal process\\n for key in merge_list:\\n # this loops over all of the Qs for col and creates the dictionary for the pr Q merges\\n p0 = key.find(\\\"p0\\\")\\n p1 = key.find(\\\"p1\\\")\\n end = key.find(\\\"e\\\")\\n r0 = int(key[p0 + 2 : p1])\\n r1 = int(key[p1 + 2 : end])\\n lp_q = q_dict_col[key][0]\\n base_size = q_dict_col[key][1]\\n # cut the q into 4 bits (end of base array)\\n # todo: modify this so that it will get what is needed from the process,\\n # instead of gathering all the qs\\n top_left = lp_q[: base_size[0], : base_size[0]]\\n top_right = lp_q[: base_size[0], base_size[0] :]\\n bottom_left = lp_q[base_size[0] :, : base_size[0]]\\n bottom_right = lp_q[base_size[0] :, base_size[0] :]\\n # need to adjust the keys to be the global row\\n col1 = col if diag_proc == r0 else proc_tile_start[r0].item()\\n col2 = proc_tile_start[r1].item()\\n # col0 and col1 are the columns numbers\\n # r0 and r1 are the ranks\\n jdim = (col1, col1)\\n kdim = (col1, col2)\\n ldim = (col2, col1)\\n mdim = (col2, col2)\\n\\n # if there are no elements on that location than set it as the tile\\n # 1. get keys of what already has data\\n curr_keys = set(global_merge_dict.keys())\\n # 2. determine which tiles need to be touched/created\\n # these are the keys which are to be multiplied by the q in the current loop\\n # for matrix of form: | J K |\\n # | L M |\\n mult_keys_00 = [(i, col1) for i in range(q_tiles.tile_columns)] # (J)\\n # (J) -> inds: (i, col0)(col0, col0) -> set at (i, col0)\\n mult_keys_01 = [(i, col1) for i in range(q_tiles.tile_columns)] # (K)\\n # (K) -> inds: (i, col0)(col0, col1) -> set at (i, col1)\\n mult_keys_10 = [(i, col2) for i in range(q_tiles.tile_columns)] # (L)\\n # (L) -> inds: (i, col1)(col1, col0) -> set at (i, col0)\\n mult_keys_11 = [(i, col2) for i in range(q_tiles.tile_columns)] # (M)\\n # (M) -> inds: (i, col1)(col1, col1) -> set at (i, col1)\\n\\n # if there are no elements in the mult_keys then set the element to the same place\\n s00 = set(mult_keys_00) & curr_keys\\n s01 = set(mult_keys_01) & curr_keys\\n s10 = set(mult_keys_10) & curr_keys\\n s11 = set(mult_keys_11) & curr_keys\\n hold_dict = global_merge_dict.copy()\\n\\n # (J)\\n if not len(s00):\\n global_merge_dict[jdim] = top_left\\n else: # -> do the mm for all of the mult keys\\n for k in s00:\\n global_merge_dict[k[0], jdim[1]] = hold_dict[k] @ top_left\\n # (K)\\n if not len(s01):\\n # check that we are not overwriting here\\n global_merge_dict[kdim] = top_right\\n else: # -> do the mm for all of the mult keys\\n for k in s01:\\n global_merge_dict[k[0], kdim[1]] = hold_dict[k] @ top_right\\n # (L)\\n if not len(s10):\\n # check that we are not overwriting here\\n global_merge_dict[ldim] = bottom_left\\n else: # -> do the mm for all of the mult keys\\n for k in s10:\\n global_merge_dict[k[0], ldim[1]] = hold_dict[k] @ bottom_left\\n # (M)\\n if not len(s11):\\n # check that we are not overwriting here\\n global_merge_dict[mdim] = bottom_right\\n else: # -> do the mm for all of the mult keys\\n for k in s11:\\n global_merge_dict[k[0], mdim[1]] = hold_dict[k] @ bottom_right\\n return global_merge_dict\",\n \"def compute_fragments(self):\\n self.fragments = []\\n for part in self.parts:\\n for fragment in self.compute_digest(part):\\n # The part is not a fragment if it hasn't been cut at all and\\n # therefore doesn't have sticky ends. Exclude from fragments.\\n if not hasattr(fragment.seq, \\\"left_end\\\"):\\n continue\\n fragment.original_part = part\\n self.annotate_fragment_with_part(fragment)\\n self.fragments.append(fragment)\",\n \"def SplitQuery(self, request, context):\\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\",\n \"def creator(self, q, data, num_sub_proc):\\n for d in data:\\n idx = d[0]\\n q.put((idx, d[1]))\\n\\n for i in range(0, num_sub_proc):\\n q.put('DONE')\",\n \"def Split(ar, size):\\r\\n return [ar[i:i + size] for i in range(0, len(ar), size)]\",\n \"def mergeSortedArrays(nums1, m, nums2, n):\",\n \"def qf_union(self, p, q):\\n\\n if self.qf_connected(p,q):\\n return True\\n\\n pid = self.id[p]\\n for i in range(len(self.id)):\\n if self.id[i] == pid:\\n self.id[i] = self.id[q]\\n return True\",\n \"def computeShingles(q, document):\\n shingles = []\\n for i in range(len(document) - q + 1):\\n shingle = \\\"\\\"\\n for j in range(i,i+q):\\n shingle += document[j]\\n shingles.append(shingle)\\n return shingles\",\n \"def merge(self, queue2):\\n with self.mutating:\\n self.queue = list(heapq.merge(self.queue, queue2))\\n heapq.heapify(self.queue)\",\n \"def split_sort_merge(items):\\n # TODO: Running time: ??? Why and under what conditions?\\n # TODO: Memory usage: ??? Why and under what conditions?\\n # Split items list into approximately equal halves\\n pivot = int(len(items)/2)\\n first_half = items[:pivot]\\n second_half = items[pivot:]\\n # TODO: Sort each half using any other sorting algorithm\\n while not is_sorted(first_half):\\n bubble_sort(first_half)\\n\\n while not is_sorted(second_half):\\n insertion_sort(second_half)\\n # TODO: Merge sorted halves into one list in sorted order\\n # Why does this mutate when we use list[:]\\n items[:] = merge(first_half,second_half)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61172956","0.5973977","0.5877295","0.5761929","0.556019","0.52428263","0.5225745","0.51877797","0.5173802","0.513103","0.5128278","0.5124813","0.511389","0.5050456","0.50198215","0.4964687","0.4958875","0.49537897","0.49401355","0.48680025","0.48670024","0.48615062","0.48202303","0.48151115","0.48081508","0.4803736","0.47675055","0.47657797","0.4759571","0.47494403","0.47471875","0.4739822","0.47374824","0.4707976","0.47026497","0.46973827","0.4691518","0.4666971","0.46645996","0.46627438","0.46604034","0.46593317","0.46567747","0.46405292","0.4630626","0.46238065","0.4597562","0.45938686","0.45869747","0.45866016","0.45849466","0.45756269","0.45740607","0.4572906","0.45718378","0.45673946","0.45568547","0.45550004","0.45321998","0.45321998","0.45255718","0.4523108","0.45122454","0.4508749","0.45063823","0.45062622","0.4504862","0.449126","0.4485841","0.44841164","0.44820458","0.44766134","0.44732812","0.44712144","0.4467515","0.4465415","0.44585297","0.44581354","0.4457138","0.4453927","0.4452894","0.44519302","0.44471848","0.44439018","0.44307843","0.44247144","0.4419731","0.441554","0.44150707","0.4412602","0.44055477","0.4404719","0.43969768","0.43957978","0.4394546","0.43941125","0.43925223","0.4391886","0.43875548","0.43778938"],"string":"[\n \"0.61172956\",\n \"0.5973977\",\n \"0.5877295\",\n \"0.5761929\",\n \"0.556019\",\n \"0.52428263\",\n \"0.5225745\",\n \"0.51877797\",\n \"0.5173802\",\n \"0.513103\",\n \"0.5128278\",\n \"0.5124813\",\n \"0.511389\",\n \"0.5050456\",\n \"0.50198215\",\n \"0.4964687\",\n \"0.4958875\",\n \"0.49537897\",\n \"0.49401355\",\n \"0.48680025\",\n \"0.48670024\",\n \"0.48615062\",\n \"0.48202303\",\n \"0.48151115\",\n \"0.48081508\",\n \"0.4803736\",\n \"0.47675055\",\n \"0.47657797\",\n \"0.4759571\",\n \"0.47494403\",\n \"0.47471875\",\n \"0.4739822\",\n \"0.47374824\",\n \"0.4707976\",\n \"0.47026497\",\n \"0.46973827\",\n \"0.4691518\",\n \"0.4666971\",\n \"0.46645996\",\n \"0.46627438\",\n \"0.46604034\",\n \"0.46593317\",\n \"0.46567747\",\n \"0.46405292\",\n \"0.4630626\",\n \"0.46238065\",\n \"0.4597562\",\n \"0.45938686\",\n \"0.45869747\",\n \"0.45866016\",\n \"0.45849466\",\n \"0.45756269\",\n \"0.45740607\",\n \"0.4572906\",\n \"0.45718378\",\n \"0.45673946\",\n \"0.45568547\",\n \"0.45550004\",\n \"0.45321998\",\n \"0.45321998\",\n \"0.45255718\",\n \"0.4523108\",\n \"0.45122454\",\n \"0.4508749\",\n \"0.45063823\",\n \"0.45062622\",\n \"0.4504862\",\n \"0.449126\",\n \"0.4485841\",\n \"0.44841164\",\n \"0.44820458\",\n \"0.44766134\",\n \"0.44732812\",\n \"0.44712144\",\n \"0.4467515\",\n \"0.4465415\",\n \"0.44585297\",\n \"0.44581354\",\n \"0.4457138\",\n \"0.4453927\",\n \"0.4452894\",\n \"0.44519302\",\n \"0.44471848\",\n \"0.44439018\",\n \"0.44307843\",\n \"0.44247144\",\n \"0.4419731\",\n \"0.441554\",\n \"0.44150707\",\n \"0.4412602\",\n \"0.44055477\",\n \"0.4404719\",\n \"0.43969768\",\n \"0.43957978\",\n \"0.4394546\",\n \"0.43941125\",\n \"0.43925223\",\n \"0.4391886\",\n \"0.43875548\",\n \"0.43778938\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58953327"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":93491,"cells":{"query":{"kind":"string","value":"Split A at q and merge together in order."},"document":{"kind":"string","value":"def merge_in_place(A, p, q, r):\n n_1 = q - p + 1\n n_2 = r - q\n L = 0\n R = 0\n for k in range(p, r+1):\n if A[p] <= A[q + 1]:\n A.insert(r+1, A[p])\n del A[p]\n L += 1\n q -= 1\n else:\n A.insert(r+1, A[q+1])\n del A[q+1]\n R += 1\n\n if L == n_1:\n A[r+1:r+1] = A[p:p+n_2-R]\n del A[p:p+n_2-R]\n break\n\n if R == n_2:\n A[r+1:r+1] = A[p:q+1]\n del A[p:q+1]\n break"},"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 merge(A, p, q, r):\n\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\n n1 = q - p + 1 # will hold A[p..q]\n n2 = r - q # will hold A[q+1..r]\n\n L = [0] * (n1 + 1)\n R = [0] * (n2 + 1)\n \n for i in range(n1):\n L[i] = A[p+i]\n for j in range(n2):\n R[j] = A[q+j+1]\n\n # add sentinels\n L[n1] = float('inf')\n R[n2] = float('inf')\n\n # instead of sentinels, we can check if either L or R is empty,\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\n \n # indices of subarrays L and R (both already previously sorted)\n i = 0\n j = 0\n\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 1","def merge(A, p, q, r):\n n_1 = q-p+1\n n_2 = r-q\n L = []\n R = []\n for i in range(n_1):\n L.append(A[p+i])\n for j in range(n_2):\n R.append(A[q+j+1])\n L.append(math.inf)\n R.append(math.inf)\n i = 0\n j = 0\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 1","def merge(A, p, q, r):\n left, right = [], []\n for i in range(p, q + 1):\n left.append(A[i])\n\n for j in range(q + 1, r + 1):\n right.append(A[j])\n\n i, j = 0, 0\n for k in range(p, r + 1):\n if i > q - p:\n A[k] = right[j]\n j += 1\n continue\n if j > r - q - 1:\n A[k] = left[i]\n i += 1\n continue\n\n if left[i] <= right[j]:\n A[k] = left[i]\n i += 1\n else:\n A[k] = right[j]\n j += 1","def merge(arr, p, q, r):\r\n assist = np.zeros(r-p+1)\r\n s = p\r\n t = q+1\r\n k = 0\r\n while s<=q and t<=r:\r\n if arr[s] < arr[t]:\r\n assist[k] = arr[s]\r\n s = s+1\r\n else:\r\n assist[k] = arr[t]\r\n t = t+1\r\n k = k+1\r\n if s == q+1:\r\n assist[k:r-p+1] = arr[t:r+1]\r\n else:\r\n assist[k:r-p+1] = arr[s:q+1]\r\n return assist","def union(p, q):\n for i in q:\n if i not in p:\n p.append(i)","def union(p,q):\n\tfor e in q:\n\t\tif e not in p:\n\t\t\tp.append(e)","def union(self, p, q):\n p_id = self._root(p)\n q_id = self._root(q)\n if (p_id == q_id):\n return;\n if (self._sz[p_id] < self._sz[q_id]):\n self._id[p_id] = q_id\n self._sz[q_id] += self._sz[p_id]\n else:\n self._id[q_id] = p_id\n self._sz[p_id] += self._sz[q_id]","def merge(*in_qs, **kwargs):\n out_q = Queue(**kwargs)\n threads = [Thread(target=push, args=(q, out_q)) for q in in_qs]\n for t in threads:\n t.daemon = True\n t.start()\n return out_q","def union(self, p, q):\n pass","def merge_arrays_as_queues(array1, array2):\n q_a = deque(array1)\n q_b = deque(array2)\n res = [-1 for _ in xrange(len(array1)+len(array2))]\n for idx in xrange(0, len(res)):\n print q_a, q_b\n print res\n if (not q_a) or (q_b[0] < q_a[0]):\n res[idx] = q_b.popleft()\n elif (not q_b) or (q_a[0] < q_b[0]):\n res[idx] = q_a.popleft()\n else:\n res[idx] = q_b.popleft()\n\n return res","def temp_split(filename):\n filename, ext = filename.rsplit('.')\n data = np.load(filename + \".\" + ext)\n # define basic constants from parent\n A = data['a']\n A_SIZE = A.shape[0]\n A_SHAPE = A.shape\n ORIGINAL_SIZE = data['original_size']\n B = data['b']\n # basics\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\n # eval & evec\n eval, evec = linalg.eigh(B)\n # split\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\n # threshold (q)\n q1 = create_q(A_SIZE, B, g1_order, m)\n q2 = create_q(A_SIZE, B, g2_order, m)\n # B of G\n b1 = create_b_of_g(B, g1_order)\n b2 = create_b_of_g(B, g2_order)\n # a_elems\n a1_elems = []\n a2_elems = []\n original_elems = data['a_elems']\n for i in g1_order:\n a1_elems.append(original_elems[i])\n for i in g2_order:\n a2_elems.append(original_elems[i])\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))","def _concatenate_inner(self, chunks, direction):\n tmp_bucket = []\n source_chunks = chunks if direction else chunks[::-1]\n target_chunks = ChunkList()\n for chunk in source_chunks:\n if (\n # if the chunk has matched dependency, do concatenation.\n chunk.dependency == direction or\n # if the chunk is SPACE, concatenate to the previous chunk.\n (direction == False and chunk.is_space())\n ):\n tmp_bucket.append(chunk)\n continue\n tmp_bucket.append(chunk)\n if not direction: tmp_bucket = tmp_bucket[::-1]\n new_word = ''.join([tmp_chunk.word for tmp_chunk in tmp_bucket])\n chunk.update_word(new_word)\n target_chunks.append(chunk)\n tmp_bucket = []\n if tmp_bucket: target_chunks += tmp_bucket\n return target_chunks if direction else target_chunks[::-1]","def merge_plays(a, b, k=10):\n x = []\n while len(a) and len(b):\n if b[0].points > a[0].points:\n x.append(b.pop(0))\n else:\n x.append(a.pop(0))\n\n if len(x) >= k:\n return x\n while len(a):\n x.append(a.pop(0))\n while len(b):\n x.append(b.pop(0))\n return x","def split(self, X):","def solve_inplace(array1, array2):\n # append all b values to end of a and then sort\n pass","def split(self) -> GQASplit:\n return self._split","def merge(self, A, ind, p, q, r, rc_array):\n\n left = ind[p:q + 1]\n right = ind[q + 1:r + 1]\n\n i = 0\n j = 0\n ic = 0\n k = p\n\n while i < len(left) and j < len(right):\n if A[left[i]] > A[right[j]]:\n ind[k] = right[j]\n ic += 1\n k += 1\n j += 1\n else:\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n i += 1\n k += 1\n\n while i < len(left):\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n k += 1\n i += 1\n while j < len(right):\n ind[k] = right[j]\n k += 1\n j += 1","def unify(self, p, q):\n root1, root2 = self.find(p), self.find(q)\n\n # If the elements are already in the same set\n if root1 == root2:\n return\n\n # Merge the smaller component/set into the larger one.\n if self.comp_size[root1] < self.comp_size[root2]:\n self.comp_size[root2] += self.comp_size[root1]\n self.id[root1] = root2\n else:\n self.comp_size[root1] += self.comp_size[root2]\n self.id[root2] = root1\n\n # Since the roots found were different, we know that the\n # number of components/sets has decreased by one.\n self.num_components -= 1","def merge(a, b):\r\n # your code here\r\n \r\n m = []\r\n i, j = 0, 0\r\n \r\n while i < len(a) and j < len(b):\r\n if a[i] < b[j]:\r\n m.append(a[i])\r\n i += 1\r\n else:\r\n m.append(b[j])\r\n j += 1\r\n \r\n m += a[i:] + b[j:]\r\n \r\n return m","def merge_quick_sort(L):\n list1 = []\n list2 = []\n (evens, odds) = merge_sort.split(L)\n list1 += quick_sort.quick_sort(evens)\n list2 += quick_sort.quick_sort(odds)\n x = merge_sort.merge(list1,list2)\n return x","def split(filename, initial=False, optimize=False):\n # load data\n filename, ext = filename.rsplit('.')\n data = np.load(filename + \".\" + ext)\n # define constants and load A if initial\n A = data['a']\n A_SIZE = A.shape[0]\n A_SHAPE = A.shape\n if initial:\n ORIGINAL_SIZE = A_SIZE\n else:\n ORIGINAL_SIZE = data['original_size']\n # basics\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\n # create B if initial, if not, import from archive\n if initial:\n p1 = create_p1(A_SHAPE, ki, kj)\n p = create_p(p1, m)\n B = A - p\n else:\n B = data['b']\n if A_SIZE <= 1:\n raise CannotSplit\n # eval & evec\n eval, evec = linalg.eigh(B)\n # split\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\n # threshold (q)\n q1 = create_q(A_SIZE, B, g1_order, m)\n q2 = create_q(A_SIZE, B, g2_order, m)\n # B of G\n b1 = create_b_of_g(B, g1_order)\n b2 = create_b_of_g(B, g2_order)\n # a elems\n a1_elems = []\n a2_elems = []\n if initial:\n a1_elems = g1_order\n a2_elems = g2_order\n else:\n original_elems = data['a_elems']\n for i in g1_order:\n a1_elems.append(original_elems[i])\n for i in g2_order:\n a2_elems.append(original_elems[i])\n # save\n if not g1_order or not g2_order:\n raise CannotSplit(message='One group is empty, cannot split.')\n if initial:\n # save files\n np.savez('g1.npz', a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\n np.savez('g2.npz', a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\n # create File records\n files.File.create(filename='g1', ext=ext, q=q1, shape=g1.shape[0], a_elems=','.join([str(x) for x in a1_elems]))\n files.File.create(filename='g2', ext=ext, q=q2, shape=g2.shape[0], a_elems=','.join([str(x) for x in a2_elems]))\n # create Item records for burning\n files.Item.create(filename='.'.join(('g1', ext)))\n files.Item.create(filename='.'.join(('g2', ext)))\n if optimize:\n opt_table = []\n for idx, elem in enumerate(g1_order):\n # create copies of new arrays\n new_g1_order, new_g1_arrays, new_g2_order, new_g2_arrays = g1_order[:], g1_arrays[:], g2_order[:], g2_arrays[:]\n # first append new material to other array\n new_g2_order.append(elem) # TODO: check if need to be sorted\n new_g2_arrays.append(new_g1_arrays[idx]) # TODO: check if insert instead if size g2 size is >= g1 size?\n # delete material from new_g1_*\n del new_g1_order[idx]\n del new_g1_arrays[idx]\n # create new Qs\n new_q1, new_q2 = create_q(A_SIZE, B, new_g1_order, m), create_q(A_SIZE, B, new_g2_order, m)\n opt_table.append((elem, new_q1, new_q2))\n return sorted(opt_table, key=lambda x: x[0])\n else:\n # return to manager to set parents\n np.savez(filename + \",1\" + \".\" + ext, a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\n np.savez(filename + \",2\" + \".\" + ext, a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\n # save filenames for burn regardless if saved or not, why didn't I do this before in master?\n files.Item.create(filename=filename + ',2.' + ext)\n files.Item.create(filename=filename + ',1.' + ext)\n # return so we can manipulate\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))","def qu_union(self, p, q):\n pID = self.qu_findroot(p)\n qID = self.qu_findroot(q)\n\n if pID == qID: return\n\n if p > q: self.id[qID] = pID\n else: self.id[pID] = qID\n return 1","def splice(i, j, data):\n n = len(data)\n out = ()\n splice_a = []\n splice_b = []\n i = idx(i, n)\n j = idx(j, n)\n i+=1\n j+=1\n if(i < j):\n splice_a = data[i:j]\n splice_b = data[j:] + data[0:i]\n else:\n splice_a = data[i:] + data[0:j]\n splice_b = data[j:i]\n\n return (splice_a, splice_b)","def test_merge(self):\n A = [1,4,6,7,8,2,3,4,5,7]\n p = 0\n q = 5\n r = 10\n A_merged = mst.merge(A, p, q, r)\n expected = [1, 2, 3, 4, 4, 5, 6, 7, 7, 8] \n self.assertEqual(A, A_merged)","def wqu_union(self, p, q):\n pID = self.qu_findroot(p)\n qID = self.qu_findroot(q)\n\n if pID == qID: return\n if(self.sz[pID] < self.sz[qID]):\n self.id[pID] = qID\n self.sz[qID] += self.sz[pID]\n else:\n self.id[qID] = pID\n self.sz[pID] += self.sz[qID]\n return 1","def merge(a, b):\n result = []\n\n # Append smallest values to result until either list is exhausted\n i = j = 0\n while i < len(a) and j < len(b):\n if compare(a[i], b[j]) < 0:\n result.append(a[i])\n i += 1\n else:\n result.append(b[j])\n j += 1\n\n # Append all remaining values from the unexhausted list\n if i < len(a):\n result.extend(a[i:])\n else:\n result.extend(b[j:])\n\n return result","def _merge_intent_fragments(self, start_offset, upload_intents, copy_intents):\n upload_intents = deque(upload_intents)\n copy_intents = deque(copy_intents)\n while True:\n upload_intent = copy_intent = None\n if upload_intents:\n upload_intent, upload_end, _ = upload_intents[0]\n if copy_intents:\n copy_intent, copy_end, copy_protected = copy_intents[0]\n\n if upload_intent is not None and copy_intent is not None:\n if not copy_protected:\n yield_intent = upload_intent\n else:\n yield_intent = copy_intent\n start_offset = min(upload_end, copy_end)\n yield yield_intent, start_offset\n if start_offset >= upload_end:\n upload_intents.popleft()\n if start_offset >= copy_end:\n copy_intents.popleft()\n elif upload_intent is not None:\n yield upload_intent, upload_end\n upload_intents.popleft()\n elif copy_intent is not None:\n yield copy_intent, copy_end\n copy_intents.popleft()\n else:\n return","def wpqu_union(self, p, q):\n pID = self.pqu_findroot(p)\n qID = self.pqu_findroot(q)\n\n if pID == qID: return\n if (self.sz[pID] < self.sz[qID]):\n self.id[pID] = qID\n self.sz[qID] += self.sz[pID]\n else:\n self.id[qID] = pID\n self.sz[pID] += self.sz[qID]\n return 1","def spliter(temp,split1,split2):\n for x in range(len(temp)):\n if x<len(temp)/2:\n split1.append(temp[x])\n else:\n split2.append(temp[x])","def qsort(A, l, r):\n if l < r:\n q = partition(A, l, r)\n qsort(A, l, q-1)\n qsort(A, q+1, r)","def union(self, p, q):\n self._validate(p)\n self._validate(q)\n p_parent = self.find(p)\n q_parent = self.find(q)\n if p_parent == q_parent:\n return\n for i in range(len(self.parents)):\n if self.parents[i] == q_parent:\n self.parents[i] = p_parent\n self.n -= 1","def split_chunk(chunk, *a, **kw):\n return split_chunk(chunk, *a, **kw)","def pqu_union(self, p, q):\n pID = self.pqu_findroot(p)\n qID = self.pqu_findroot(q)\n\n if pID == qID: return\n\n if p > q:\n self.id[qID] = pID\n else:\n self.id[pID] = qID\n return 1","def qids_to_splits(qids):\n qidmap = {}\n i = 0\n for qid in qids:\n if not qid in qidmap:\n qidmap[qid] = i\n i+=1\n new_qids = []\n for qid in qids:\n new_qids.append(qidmap[qid])\n qidcount = np.max(new_qids)+1\n splits = [[] for i in range(qidcount)]\n for i, qid in enumerate(new_qids):\n splits[qid].append(i) \n return splits","def merge_sort(alist):\n print(\"Splitting \", alist)\n # Temporary list to store sorted list\n work = [None] * len(alist)\n rec_merge_sort(work, start=0, end=len(alist)-1)","def split(aDeck,location):\r\n newDeck=[]\r\n for x in range(location):\r\n newDeck.append(aDeck.pop())\r\n return (newDeck)","def union(self, p, q):\n p_id = self._root(p)\n q_id = self._root(q)\n self._id[p_id] = q_id","def splits_array_switcher(trajectory1, trajectory2, index_of_cut):\r\n\r\n trajectory1_a, trajectory2_b = trajectory1[:index_of_cut], trajectory1[index_of_cut:]\r\n trajectory2_a, trajectory1_b = trajectory2[:index_of_cut], trajectory2[index_of_cut:]\r\n\r\n trajectory1 = np.concatenate((trajectory1_a, trajectory1_b), axis=0)\r\n trajectory2 = np.concatenate((trajectory2_a, trajectory2_b), axis=0)\r\n\r\n return trajectory1, trajectory2","def sortbatch(q_batch, a_batch, q_lens, a_lens):\n maxlen_q = max(q_lens)\n maxlen_a = max(a_lens)\n q=q_batch[:,:maxlen_q-1]\n a=a_batch[:,:maxlen_a-1]\n sorted_idx = torch.LongTensor(a_lens.numpy().argsort()[::-1].copy())\n return q[sorted_idx], a[sorted_idx], q_lens[sorted_idx], a_lens[sorted_idx]","def _intermediates(q, results):\n # type: (np.ndarray, List[Tuple[Kernel, np.ndarray, Optional[Callable]]]) -> OrderedDict[str, Any]\n parts = OrderedDict()\n for part_num, (kernel, Iq, intermediates) in enumerate(results):\n part_id = chr(ord('A') + part_num) + \"_\" + kernel.info.name + \"(Q)\"\n parts[part_id] = (q, Iq)\n if intermediates is not None:\n parts[part_id + \" parts\"] = intermediates()\n return parts","def _group_chunks_by_entities(self, chunks, entities):\n for entity in entities:\n chunks_to_concat = chunks.get_overlaps(\n entity['beginOffset'], len(entity['content']))\n if not chunks_to_concat: continue\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\n new_chunk = Chunk(new_chunk_word)\n chunks.swap(chunks_to_concat, new_chunk)\n return chunks","def _group_chunks_by_entities(self, chunks, entities):\n for entity in entities:\n chunks_to_concat = chunks.get_overlaps(\n entity['beginOffset'], len(entity['content']))\n if not chunks_to_concat:\n continue\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\n new_chunk = Chunk(new_chunk_word)\n chunks.swap(chunks_to_concat, new_chunk)\n return chunks","def wpqu_union(self, p, q):\n if self.wpqu_connected(p,q):\n return True;\n \n p_pa,q_pa = self.id[p],self.id[q]\n \n if self.sz[p_pa] >= self.sz[q_pa]:\n self.id[q_pa] = p_pa\n self.sz[p_pa] += self.sz[q_pa] \n else:\n self.id[p_pa] = q_pa\n self.sz[q_pa] += self.sz[p_pa] \n return True","def d_j(self,q):\n dj = q.shift(y=-1) - q # works with chunks too\n return dj","def _load_data(l, q, nproc):\n for element in l:\n q.put(element)\n for _ in range(nproc):\n q.put(FINISHED)","def busca_base(A, a, q):\n \n \n nrow = np.shape(A)[0]\n zeros = np.zeros((nrow, 1))\n B0, _ = householder(power(A-a*np.identity(nrow), q), zeros)\n \n # calcula el rango de la matriz B0\n r = rango_matrix(B0)\n \n # G = [G1, G2, ..., Gn-r], donde Gi: i-esimo vector generador de N((A-aI)^{q})\n # NOTA: No esta garanizado que {G1, G2, ..., Gn-r}, sean li\n G = np.zeros((nrow, nrow-r))\n for k in range(r):\n # coeff(k, i): coeficiente de xi en la combinacion lineal de los xr+1,xr+2,...,xn, para obtener -B0[k,k]xk\n G[k,:] = - np.array([coeff(k,r+i, B0) for i in range(1, nrow-r+1)])/B0[k,k]\n G[nrow:, :] = np.identity(nrow-r)\n \n return vectores_li(G, r) # retorna solo los vectore li de {G1, G2, ..., Gn-r}, en una matriz","def wqu_union(self, p, q):\n \n if self.wqu_connected(p, q):\n return True\n \n p_pa,q_pa = p,q\n while p_pa != self.id[p_pa]:\n p_pa = self.id[p_pa]\n while q_pa != self.id[q_pa]:\n q_pa = self.id[q_pa]\n \n if self.sz[p_pa] >= self.sz[q_pa]:\n self.id[q_pa] = p_pa\n self.sz[p_pa] += self.sz[q_pa] \n else:\n self.id[p_pa] = q_pa\n self.sz[q_pa] += self.sz[p_pa] \n return True","def pqu_union(self, p, q):\n if self.pqu_connected(p,q):\n return True\n self.id[self.id[p]] = self.id[q]\n return True","def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\n A[m:] = B\n A.sort()","def mergesort(A, p, r):\n if p < r:\n q = (p+r)//2\n mergesort(A, p, q)\n mergesort(A, q + 1, r)\n merge(A, p, q, r)","def split_segments(old_seg_ends, B):\n new_segment_ends = []\n for q in range(0, B.size):\n new_ends = list(np.linspace(old_seg_ends[q], old_seg_ends[q + 1], B[q] + 1))\n new_segment_ends.extend(new_ends[:-1])\n new_segment_ends.extend([1])\n new_segment_ends = np.asarray(new_segment_ends)\n return new_segment_ends","def merge(li: Sequence, left_index: int, mid_index: int, right_index: int) -> None:\n left_li = li[left_index : mid_index]\n right_li = li[mid_index : right_index]\n i, j, k = 0, 0, left_index\n \n while i < len(left_li) and j < len(right_li):\n if left_li[i] <= right_li[j]:\n li[k] = left_li[i]\n i += 1\n else:\n li[k] = right_li[j]\n j += 1\n k += 1\n \n # Copy the remainders\n while i < len(left_li):\n li[k] = left_li[i]\n i += 1\n k += 1\n while j < len(right_li):\n li[k] = right_li[j]\n j += 1\n k += 1","def merge_recs(part_one, part_two, output):\n start_op_length = 28\n with open(part_one, 'rb') as a_handle, \\\n open(part_two, 'rb') as b_handle, \\\n open(output, 'wb') as merged:\n\n a_data = a_handle.read()\n b_data = b_handle.read()\n\n postgame_pos, _ = find_postgame(a_data, len(a_data))\n if postgame_pos:\n a_data_end = postgame_pos - LOOKAHEAD\n else:\n a_data_end = len(a_data)\n b_header_len, = struct.unpack('<I', b_data[:4])\n chapter = mgz.body.operation.build({\n 'type': 'action',\n 'op': 1,\n 'length': 2,\n 'action': {\n 'type': 'chapter',\n 'player_id': 0xff # our merge marker\n }\n })\n\n # part A with no postgame struct\n merged.write(a_data[:a_data_end])\n # chapter action\n merged.write(chapter)\n # offset to start of part B operations\n merged.write(struct.pack('<I', a_data_end + len(chapter) + b_header_len))\n # part B header (now a \"saved chapter\")\n merged.write(b_data[4:b_header_len])\n # part B operations with no start operation\n merged.write(b_data[b_header_len + start_op_length:])","def mergeSeq(left, right):\n i = j = 0\n result = []\n while i < len(left) and j < len(right):\n if left[i] <= right[j]:\n result.append(left[i])\n i += 1\n else:\n result.append(right[j])\n j += 1\n\n result += left[i:]\n result += right[j:]\n return result","def _get_pmx_crossed_sequence(sequence_a: OrderedSet, sequence_b: OrderedSet,\n part_from_a: OrderedSet, part_from_b: OrderedSet,\n start_index: int, end_index: int) -> List[int]:\n new_sequence = list(sequence_b)\n\n elements_requiring_correction = {}\n\n uniques_from_b_part = part_from_b - part_from_a\n for unique_from_b_part in uniques_from_b_part:\n index_in_part = part_from_b.index(unique_from_b_part)\n elements_requiring_correction[unique_from_b_part] = part_from_a[index_in_part]\n\n for elem_from_b, elem_from_a in elements_requiring_correction.items():\n while elem_from_a in part_from_b:\n index_of_elem_from_b = sequence_b.index(elem_from_a)\n elem_from_a = sequence_a[index_of_elem_from_b]\n\n new_index = sequence_b.index(elem_from_a)\n new_sequence[new_index] = elem_from_b\n\n new_sequence[start_index:end_index] = part_from_a\n\n return new_sequence","def push(self, x):\n # enqueue new element to q2\n self.q2.enqueue(x)\n # dequeue from q1 and enqueue in q2\n\n while self.q1.qlist:\n self.q2.enqueue(self.q1.dequeue())\n # swap q1 and q2\n temp = self.q1.qlist\n self.q1.qlist = self.q2.qlist\n self.q2.qlist = temp","def merge(a,b):\n c = []\n while len(a) != 0 and len(b) != 0:\n if a[0] < b[0]:\n c.append(a[0])\n a.remove(a[0])\n else:\n c.append(b[0])\n b.remove(b[0])\n if len(a) == 0:\n c += b\n else:\n c += a\n return c","def interval_split(a,b,split_ps):\n ps = [a] + [s for s in sorted(split_ps) if a < s < b] + [b]\n return [(p1,p2) for p1,p2 in zip(ps,ps[1:])]","def addToBq(self, p):\n self.allJobs.append(p)\n p.submitToQueue()\n if len(self.circQ) < self.maxLength - 1:\n self.circQ.append(p)","def addToBq(self, p):\n self.allJobs.append(p)\n p.submitToQueue()\n if len(self.circQ) < self.maxLength - 1:\n self.circQ.append(p)","def merge_ranges():","def qf_union(self, p, q):\n pID = self.id[p]\n\n for x in range(len(self.id)):\n if self.id[x] == pID:\n self.id[x] = self.id[q]\n return 1","def merge_reads(s1, s2, q1, q2, amplen):\n # If the amplicon is of length L and the reads are lengths l1, l2 then:\n # - read 1 from 0 to L-l2-1 inclusive doesn't overlap\n # - read 1 from L-l2 to l1-1 inclusive overlaps with read 2\n # - read 2 from 0 to l1+l2-L-1 inclusive overlaps with read 1\n # - read 2 from l1+l2-L to its end doesn't overlap\n\n # A picture for clarity:\n # s1 coords: 0 l1-1\n # | |\n # ----------------------------------------\n # ------------------------------\n # | | |\n # s1 coords: L-l2 | L-1\n # s2 coords: 0 l1+l2-L-1\n\n # Reverse complement read 2 and reverse its quality scores.\n s2 = reverse_complement(s2)\n q2 = q2[::-1]\n\n # This is where we'll put the merged sequence and quality score.\n s = np.zeros(amplen, dtype=np.int8)\n q = np.zeros(amplen, dtype=np.int8)\n\n # If the reads overlap correctly, then s1[offset+i] == s2[i], assuming s2 is\n # the reverse complement of the reverse read.\n offset = amplen - len(s2)\n\n # Fill in the parts of the merged sequence where the reads don't overlap.\n s[:offset] = s1[:offset]\n q[:offset] = q1[:offset]\n s[len(s1):] = s2[len(s1)+len(s2)-amplen:]\n q[len(s1):] = q2[len(s1)+len(s2)-amplen:]\n\n # Create a set of views into the overlapping region. We can directly compare\n # vs1[i] to vs2[i] and use that to fill in vs[i] with all indexing taken\n # care of.\n vs1 = s1[offset:]\n vq1 = q1[offset:]\n vs2 = s2[:len(vs1)]\n vq2 = q2[:len(vs1)]\n vs = s[offset:len(s1)]\n vq = q[offset:len(s1)]\n\n # Quality score of matching bases is the larger of the two quality\n # scores (this is a somewhat conservative low estimate). Quality\n # score of mismatched bases is the difference of the two quality\n # scores. If the mismatched bases have equal quality scores, the\n # base is written as an N with the minimum possible quality.\n\n # Positions where the reads agree.\n ieq = vs1 == vs2\n vs[ieq] = vs1[ieq]\n vq[ieq] = np.maximum(vq1[ieq], vq2[ieq])\n\n # Positions where the reads disagree.\n ineq = vs1 != vs2\n mismatches = ineq.sum()\n\n # Positions where the reads disagree and read 1 has the higher quality.\n ir1 = np.logical_and(ineq, vq1 > vq2)\n vs[ir1] = vs1[ir1]\n vq[ir1] = MIN_QUAL + vq1[ir1] - vq2[ir1]\n\n # Positions where the reads disagree and read 2 has the higher quality.\n ir2 = np.logical_and(ineq, vq2 > vq1)\n vs[ir2] = vs2[ir2]\n vq[ir2] = MIN_QUAL + vq2[ir2] - vq1[ir2]\n\n # Positions where the reads disagree and they have equal qualities.\n irn = np.logical_and(ineq, vq1 == vq2)\n vs[irn] = bN\n vq[irn] = MIN_QUAL\n\n return s, q, mismatches","def sort(self, A, index, p, r, rc_arr):\n\n if p < r:\n q = (p + r) // 2\n\n self.sort(A, index, p, q, rc_arr)\n self.sort(A, index, q + 1, r, rc_arr)\n self.merge(A, index, p, q, r, rc_arr)","def __init__(self):\n self.A = [] # 大顶堆，存放较小的元素\n self.B = [] # 小顶堆，存放较大的元素，使得B的最小的元素也比A中最大的元素大，保证数据流保持有序","def merge(self, parallel_seq):\n return _OSeq(sorted(self._elements + parallel_seq._elements, key=lambda x: x.get(offset_attr, 0)))","def _prepare(self, q):\n # store it in _lastr which is consulted in BasePDFGenerator.__call__\n self._lastr = q\n self._calc.qstep = q[1] - q[0]\n self._calc.qmin = q[0]\n self._calc.qmax = q[-1] + 0.5*self._calc.qstep\n return","def mconcat(a, b):\r\n if a is None:\r\n return b\r\n if b is None:\r\n return a\r\n for key in b.keyset:\r\n value=get(b,key)\r\n put(a,key,value)\r\n return a","def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\n # # solution one: sort\n # A[m:] = B\n # A.sort()\n\n # solution two: two point\n if n == 0: # B = []\n return\n i, j, k = m - 1, n - 1, m + n - 1\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\n if A[i] <= B[j]:\n A[k] = B[j]\n k -= 1\n j -= 1\n else:\n A[k] = A[i]\n k -= 1\n i -= 1\n if j > -1:\n A[:j + 1] = B[:j + 1] # A = [], B = [1]","def merge(items, start, end, subarray_size):\n mid = start + subarray_size\n assert is_sorted(items[start:mid])\n assert is_sorted(items[start+subarray_size:end])\n\n aux = []\n i = start\n j = mid\n\n while i < mid and j < end:\n if items[i] < items[j]:\n aux.append(items[i])\n i += 1\n else:\n aux.append(items[j])\n j += 1\n aux.extend(items[i:mid] or items[j:end])\n assert is_sorted(aux)\n\n ## Overwrite elements in subarrays in their correctly sorted order\n for i in range(start, end):\n items[i] = aux[i-start]","def test_merge():\n\n q1 = PriorityQueue()\n q2 = PriorityQueue()\n\n # input list (obj, priority) should be reversed\n # in the priority_queue\n input_list = [((1), 9), ((2), 8), ((3), 7),\n ((4), 6), ((5), 5), ((6), 4),\n ((7), 3), ((8), 2), ((9), 1)]\n\n # insert the items into the queues\n for idx, (obj, p) in enumerate(input_list):\n if idx < 4:\n q1.push(obj, p)\n else:\n q2.push(obj, p)\n\n # merge the queues\n q1.merge(q2)\n\n # dump the queue into a list\n output = []\n while q1._queue:\n output.append(q1.pop())\n\n # validate the expected behavior\n eq_(output, range(1, 10)[::-1])","def subsample(self, dQ):\n # Assumes self contains sorted Qo and associated T, L\n # Note: calc_Qo is already sorted\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\n idx = np.unique(np.searchsorted(self.Qo, Q))\n #print len(idx), len(self.Qo)\n\n self.T, self.dT = self.T[idx], self.dT[idx]\n self.L, self.dL = self.L[idx], self.dL[idx]\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\n if self.R is not None:\n self.R = self.R[idx]\n if self.dR is not None:\n self.dR = self.dR[idx]\n self._set_calc(self.T, self.L)","def concatenate(self):\n if not self.match_count:\n # No concatenating if there are no matches\n return []\n if self.match_count <= 1:\n # Can't combine a single match\n return self.match_list\n # Setup for iterating through\n cont = True\n first = self.match_list[self.i]\n second = self.match_list[self.j]\n while cont and self.match_count > 2:\n first, second, cont = self._process_main()\n\n # Last block is a special case\n self._process_last(first, second)\n return self.combined","def test_three_split():\n run_mergesort([3, 0, 3], [0, 3, 3])","def mergesort(input):\n\n if len(input) <= 1:\n return input\n\n cut = len(input) // 2 # floored quotient\n top = mergesort(input[:cut])\n bottom = mergesort(input[cut:])\n\n i = 0\n j = 0\n\n output = []\n for x in range(len(input)):\n if top[i] < bottom[j]:\n output.append(top[i])\n i += 1\n if i >= len(top):\n output += bottom[j:]\n break\n else:\n output.append(bottom[j])\n j += 1\n if j >= len(bottom):\n output += top[i:]\n break\n\n return output","def quick_sort_helper(a_list, first_position, last_position):\n if first_position < last_position:\n\n split_point = partition(a_list, first_position, last_position)\n\n quick_sort_helper(a_list, first_position, split_point)\n quick_sort_helper(a_list, split_point + 1, last_position)\n\n return a_list","def union(self,i,j):\n ii, jj = self.find(i), self.find(j)\n if ii != jj:\n\n if self.rank[ii] > self.rank[jj]: \n ii,jj = jj,ii\n\n if self.rank[ii] == self.rank[jj]: \n self.rank[jj]+=1\n\n self.size[jj] += self.size[ii]\n self.par[ii] = jj\n\n self.cMax = max(self.size[jj],self.cMax)\n self.nComp -=1\n\n del self.size[ii]","def merge(work, start_left, start_right, upper_bound):\n # Keep track of index in temporary list\n # whose length is the same as the original list\n i = 0\n lower_bound = start_left\n mid = start_right - 1\n # size of list after merge\n n = upper_bound - lower_bound + 1\n\n # compare two sub lists per item\n # and insert in original list\n while start_left <= mid and start_right <= upper_bound:\n work[i] = min(a_list[start_left], a_list[start_right])\n if work[i] == a_list[start_left]:\n start_left += 1\n else:\n start_right += 1\n i += 1\n\n # If all items from second list are in original list\n # insert all of the items from the first list\n # as list is already sorted\n while start_left <= mid:\n work[i] = a_list[start_left]\n i += 1\n start_left += 1\n\n # If all items from first list are in original list\n # insert all of the items from the second list\n # as list is already sorted\n while start_right <= upper_bound:\n work[i] = a_list[start_right]\n i += 1\n start_right += 1\n\n # Transfer the temporary list \"work\" back to original\n # list \"a_list\"\n for k in range(0, n):\n a_list[lower_bound+k] = work[k]","def q_append_non_leaf(node, q):\n for i in range(q-1):\n node.addkid(Node(\"*\"), before=True)\n node.addkid(Node(\"*\"))","def union(self, p, q):\n root_p = self.find(p)\n root_q = self.find(q)\n if root_p == root_q:\n return\n \n #if the sites were isolated make them un-isolated\n if self._nodes[p] == 1:\n self._nodes[p] = 0\n self._iso -= 1\n if self._nodes[q] == 1:\n self._nodes[q] = 0\n self._iso -= 1\n\n # make root of smaller rank point to root of larger rank\n if self._rank[root_p] < self._rank[root_q]:\n self._parent[root_p] = root_q\n #add the small root size to the big root size\n self._size[root_q] += self._size[root_p]\n #check if the big root size is now the biggest\n if self._size[root_q] > self._max:\n self._max = self._size[root_q]\n elif self._rank[root_p] > self._rank[root_q]:\n self._parent[root_q] = root_p\n self._size[root_p] += self._size[root_q]\n if self._size[root_p] > self._max:\n self._max = self._size[root_p]\n else:\n self._parent[root_q] = root_p\n self._size[root_p] += self._size[root_q]\n if self._size[root_p] > self._max:\n self._max = self._size[root_p]\n self._rank[root_p] += 1\n\n self._count -= 1","def split_sort_merge(items):\n # TODO: Split items list into approximately equal halves\n pivot = len(items) // 2\n # TODO: Sort each half using any other sorting algorithm\n # sort first half in-place (insertion sort)\n left = insertion_sort(items[:pivot])\n\n right = insertion_sort(items[pivot:])\n # TODO: Merge sorted halves into one list in sorted order\n # merge the two half list (merge function but this does this in-place)\n sorted_list = merge(left, right)\n # change the input items\n items[:] = sorted_list\n return items","def qu_union(self, p, q):\n\n if self.qu_connected(p, q):\n return True\n\n p_pa,q_pa = p,q\n while p_pa != self.id[p_pa]:\n p_pa = self.id[p_pa]\n while q_pa != self.id[q_pa]:\n q_pa = self.id[q_pa]\n self.id[p_pa] = q_pa\n\n return True","def split(self):\n\n # FIXME: user should be able to change the default behavior of\n # this function (for instance user may require one filter not\n # to split the content of the input file and the same input \n # to be used by the next filter.\n \n utils.split_file(self.files['hit_ids'],\n self.files['input'],\n self.files['filtered_reads'],\n self.files['survived_reads'])","def merge(A, left, middle, right):\n leftSubArray = A[left:middle]\n rightSubArray = A[middle:right+1]\n leftSubArray.append(float(\"inf\"))\n rightSubArray.append(float(\"inf\"))\n i = j = 0\n for k in xrange(left, right + 1):\n if leftSubArray[i] < rightSubArray[j]:\n A[k] = leftSubArray[i]\n i += 1\n else:\n A[k] = rightSubArray[j]\n j += 1\n return A","def queued(values, qsize):\n values = [_normalize(v) for v in values]\n if qsize < 1:\n raise ValueError(\"qsize must be 1 or larger\")\n q = []\n it = iter(values)\n try:\n for i in range(qsize):\n q.append(next(it))\n for i in cycle(range(qsize)):\n yield q[i]\n q[i] = next(it)\n except StopIteration:\n pass","def rejoin(l0,l1=None):\r\n while len(l0) != 0:\r\n if l1 is None:\r\n l1 = []\r\n if l0[0] == '<':\r\n if len(l0) >= 3:\r\n if l0[2] == '>':\r\n l1 += [l0.pop(0) + l0.pop(0) + l0.pop(0)]\r\n else:\r\n l1 += [l0.pop(0)]\r\n return l1","def fastq_qc(demultiplex_result, out_dir, config):\n\n pigz_cores = int(config['fastqTrim']['pigz_cores'])\n cutadapt_cores = int(config['fastqTrim']['cutadapt_cores'])\n\n r1_adapter = config['fastqTrim']['r1_adapter']\n r2_adapter = config['fastqTrim']['r1_adapter']\n length_threshold = config['fastqTrim']['length_threshold']\n quality_threshold = config['fastqTrim']['quality_threshold']\n r1_left_cut = config['fastqTrim']['r1_left_cut']\n r1_right_cut = config['fastqTrim']['r1_right_cut']\n r2_left_cut = config['fastqTrim']['r2_left_cut']\n r2_right_cut = config['fastqTrim']['r2_right_cut']\n overlap = config['fastqTrim']['overlap']\n total_reads_threshold = int(config['fastqTrim']['total_reads_threshold'])\n\n results = []\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\n sample_demultiplex_total = sub_df['Trimmed'].sum()\n if sample_demultiplex_total < total_reads_threshold:\n log.info(f'In uid {uid}: index {index_name} skipped '\n f'due to too less reads: {sample_demultiplex_total}')\n continue\n # process R1\n r1_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R1.fq.gz'\n r1_out = f'{out_dir}/{uid}_{index_name}_R1.trimed.fq.gz'\n r1_cmd = f'pigz -cd -p {pigz_cores} {r1_path_pattern} | ' \\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\n f'-q {quality_threshold} -u {r1_left_cut} ' \\\n f'-u -{r1_right_cut} -m {length_threshold} ' \\\n f'-a {r1_adapter} -o {r1_out} -'\n r1_result = subprocess.run(r1_cmd, stdout=subprocess.PIPE,\n encoding='utf8', shell=True, check=True)\n\n # get R1 result stat\n lines = []\n for line in r1_result.stdout.split('\\n'):\n ll = line.split('\\t')\n if len(ll) > 1:\n lines.append(ll)\n s = pd.Series({name: number for name, number in zip(*lines)})\n s['uid'] = uid\n s['index_name'] = index_name\n s['read_type'] = 'R1'\n results.append(s)\n\n # process R2\n r2_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R2.fq.gz'\n r2_out = f'{out_dir}/{uid}_{index_name}_R2.trimed.fq.gz'\n r2_cmd = f'pigz -cd -p {pigz_cores} {r2_path_pattern} | ' \\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\n f'-q {quality_threshold} -u {r2_left_cut} ' \\\n f'-u -{r2_right_cut} -m {length_threshold} ' \\\n f'-a {r2_adapter} -o {r2_out} -'\n r2_result = subprocess.run(r2_cmd, stdout=subprocess.PIPE,\n encoding='utf8', shell=True, check=True)\n # get R2 result stat\n lines = []\n for line in r2_result.stdout.split('\\n'):\n ll = line.split('\\t')\n if len(ll) > 1:\n lines.append(ll)\n s = pd.Series({name: number for name, number in zip(*lines)})\n s['uid'] = uid\n s['index_name'] = index_name\n s['read_type'] = 'R2'\n results.append(s)\n\n fastq_final_result = pd.DataFrame(results)\n if len(results) == 0:\n # all sample skipped\n return fastq_final_result\n fastq_final_result['out_reads_rate'] = \\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\n fastq_final_result['out_bp_rate'] = \\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\n\n # clean up\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\n r_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R*.fq.gz'\n r_rm_cmd = f'rm -f {r_path_pattern}'\n subprocess.run(r_rm_cmd, shell=True)\n # remove unknown reads\n r_path_pattern = f'{out_dir}/{uid}_L*_unknown_R*.fq.gz'\n r_rm_cmd = f'rm -f {r_path_pattern}'\n subprocess.run(r_rm_cmd, shell=True)\n\n return fastq_final_result","def split_by(data_set, question, entropy_before):\r\n yea_set = []\r\n nay_set = []\r\n abstain_set = []\r\n\r\n for data_point in data_set:\r\n vote = data_point.dat_votes[ord(question)-97] #the way this representative voted is the data_point's votes indexed by question\r\n party = data_point.dat_party\r\n\r\n if vote == \"+\":\r\n yea_set.append(data_point)\r\n if vote == \"-\":\r\n nay_set.append(data_point)\r\n if vote == \".\":\r\n abstain_set.append(data_point)\r\n\r\n yea_entropy = abs(calc_entropy(yea_set) * (len(yea_set))/len(data_set))\r\n nay_entropy = abs(calc_entropy(nay_set) * (len(nay_set))/len(data_set))\r\n abstain_entropy = abs(calc_entropy(abstain_set) * (len(abstain_set))/len(data_set))\r\n calc_gain = entropy_before - (yea_entropy + nay_entropy + abstain_entropy)\r\n return (calc_gain,(yea_set, nay_set, abstain_set))","def array_to_pq(pq, source):\r\n temp = None\r\n \r\n while source != []:\r\n temp = source.pop(0)\r\n pq.insert(temp)\r\n\r\n return","def reverse_quad(q):\n return [q[1], q[0], q[3], q[2]]","def compute_fragments(self):\n self.fragments = []\n for part in self.parts:\n for fragment in self.compute_digest(part):\n # The part is not a fragment if it hasn't been cut at all and\n # therefore doesn't have sticky ends. Exclude from fragments.\n if not hasattr(fragment.seq, \"left_end\"):\n continue\n fragment.original_part = part\n self.annotate_fragment_with_part(fragment)\n self.fragments.append(fragment)","def __split0_global_q_dict_set(\n q_dict_col: Dict,\n col: Union[int, torch.Tensor],\n r_tiles: SquareDiagTiles,\n q_tiles: SquareDiagTiles,\n global_merge_dict: Dict = None,\n) -> None:\n # q is already created, the job of this function is to create the group the merging q's together\n # it takes the merge qs, splits them, then puts them into a new dictionary\n proc_tile_start = torch.cumsum(\n torch.tensor(r_tiles.tile_rows_per_process, device=r_tiles.arr.larray.device), dim=0\n )\n diag_proc = torch.nonzero(input=proc_tile_start > col, as_tuple=False)[0].item()\n proc_tile_start = torch.cat(\n (torch.tensor([0], device=r_tiles.arr.larray.device), proc_tile_start[:-1]), dim=0\n )\n\n # 1: create caqr dictionary\n # need to have empty lists for all tiles in q\n global_merge_dict = {} if global_merge_dict is None else global_merge_dict\n\n # intended to be used as [row][column] -> data\n # 2: loop over keys in the dictionary\n merge_list = list(q_dict_col.keys())\n merge_list.sort()\n # todo: possible improvement -> make the keys have the process they are on as well,\n # then can async get them if they are not on the diagonal process\n for key in merge_list:\n # this loops over all of the Qs for col and creates the dictionary for the pr Q merges\n p0 = key.find(\"p0\")\n p1 = key.find(\"p1\")\n end = key.find(\"e\")\n r0 = int(key[p0 + 2 : p1])\n r1 = int(key[p1 + 2 : end])\n lp_q = q_dict_col[key][0]\n base_size = q_dict_col[key][1]\n # cut the q into 4 bits (end of base array)\n # todo: modify this so that it will get what is needed from the process,\n # instead of gathering all the qs\n top_left = lp_q[: base_size[0], : base_size[0]]\n top_right = lp_q[: base_size[0], base_size[0] :]\n bottom_left = lp_q[base_size[0] :, : base_size[0]]\n bottom_right = lp_q[base_size[0] :, base_size[0] :]\n # need to adjust the keys to be the global row\n col1 = col if diag_proc == r0 else proc_tile_start[r0].item()\n col2 = proc_tile_start[r1].item()\n # col0 and col1 are the columns numbers\n # r0 and r1 are the ranks\n jdim = (col1, col1)\n kdim = (col1, col2)\n ldim = (col2, col1)\n mdim = (col2, col2)\n\n # if there are no elements on that location than set it as the tile\n # 1. get keys of what already has data\n curr_keys = set(global_merge_dict.keys())\n # 2. determine which tiles need to be touched/created\n # these are the keys which are to be multiplied by the q in the current loop\n # for matrix of form: | J K |\n # | L M |\n mult_keys_00 = [(i, col1) for i in range(q_tiles.tile_columns)] # (J)\n # (J) -> inds: (i, col0)(col0, col0) -> set at (i, col0)\n mult_keys_01 = [(i, col1) for i in range(q_tiles.tile_columns)] # (K)\n # (K) -> inds: (i, col0)(col0, col1) -> set at (i, col1)\n mult_keys_10 = [(i, col2) for i in range(q_tiles.tile_columns)] # (L)\n # (L) -> inds: (i, col1)(col1, col0) -> set at (i, col0)\n mult_keys_11 = [(i, col2) for i in range(q_tiles.tile_columns)] # (M)\n # (M) -> inds: (i, col1)(col1, col1) -> set at (i, col1)\n\n # if there are no elements in the mult_keys then set the element to the same place\n s00 = set(mult_keys_00) & curr_keys\n s01 = set(mult_keys_01) & curr_keys\n s10 = set(mult_keys_10) & curr_keys\n s11 = set(mult_keys_11) & curr_keys\n hold_dict = global_merge_dict.copy()\n\n # (J)\n if not len(s00):\n global_merge_dict[jdim] = top_left\n else: # -> do the mm for all of the mult keys\n for k in s00:\n global_merge_dict[k[0], jdim[1]] = hold_dict[k] @ top_left\n # (K)\n if not len(s01):\n # check that we are not overwriting here\n global_merge_dict[kdim] = top_right\n else: # -> do the mm for all of the mult keys\n for k in s01:\n global_merge_dict[k[0], kdim[1]] = hold_dict[k] @ top_right\n # (L)\n if not len(s10):\n # check that we are not overwriting here\n global_merge_dict[ldim] = bottom_left\n else: # -> do the mm for all of the mult keys\n for k in s10:\n global_merge_dict[k[0], ldim[1]] = hold_dict[k] @ bottom_left\n # (M)\n if not len(s11):\n # check that we are not overwriting here\n global_merge_dict[mdim] = bottom_right\n else: # -> do the mm for all of the mult keys\n for k in s11:\n global_merge_dict[k[0], mdim[1]] = hold_dict[k] @ bottom_right\n return global_merge_dict","def mergeSortedArrays(nums1, m, nums2, n):","def Split(ar, size):\r\n return [ar[i:i + size] for i in range(0, len(ar), size)]","def creator(self, q, data, num_sub_proc):\n for d in data:\n idx = d[0]\n q.put((idx, d[1]))\n\n for i in range(0, num_sub_proc):\n q.put('DONE')","def SplitQuery(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)","def qf_union(self, p, q):\n\n if self.qf_connected(p,q):\n return True\n\n pid = self.id[p]\n for i in range(len(self.id)):\n if self.id[i] == pid:\n self.id[i] = self.id[q]\n return True","def computeShingles(q, document):\n shingles = []\n for i in range(len(document) - q + 1):\n shingle = \"\"\n for j in range(i,i+q):\n shingle += document[j]\n shingles.append(shingle)\n return shingles","def merge(self, queue2):\n with self.mutating:\n self.queue = list(heapq.merge(self.queue, queue2))\n heapq.heapify(self.queue)","def split_sort_merge(items):\n # TODO: Running time: ??? Why and under what conditions?\n # TODO: Memory usage: ??? Why and under what conditions?\n # Split items list into approximately equal halves\n pivot = int(len(items)/2)\n first_half = items[:pivot]\n second_half = items[pivot:]\n # TODO: Sort each half using any other sorting algorithm\n while not is_sorted(first_half):\n bubble_sort(first_half)\n\n while not is_sorted(second_half):\n insertion_sort(second_half)\n # TODO: Merge sorted halves into one list in sorted order\n # Why does this mutate when we use list[:]\n items[:] = merge(first_half,second_half)"],"string":"[\n \"def merge(A, p, q, r):\\n\\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\\n n1 = q - p + 1 # will hold A[p..q]\\n n2 = r - q # will hold A[q+1..r]\\n\\n L = [0] * (n1 + 1)\\n R = [0] * (n2 + 1)\\n \\n for i in range(n1):\\n L[i] = A[p+i]\\n for j in range(n2):\\n R[j] = A[q+j+1]\\n\\n # add sentinels\\n L[n1] = float('inf')\\n R[n2] = float('inf')\\n\\n # instead of sentinels, we can check if either L or R is empty,\\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\\n \\n # indices of subarrays L and R (both already previously sorted)\\n i = 0\\n j = 0\\n\\n for k in range(p, r+1):\\n if L[i] <= R[j]:\\n A[k] = L[i]\\n i += 1\\n else:\\n A[k] = R[j]\\n j += 1\",\n \"def merge(A, p, q, r):\\n n_1 = q-p+1\\n n_2 = r-q\\n L = []\\n R = []\\n for i in range(n_1):\\n L.append(A[p+i])\\n for j in range(n_2):\\n R.append(A[q+j+1])\\n L.append(math.inf)\\n R.append(math.inf)\\n i = 0\\n j = 0\\n for k in range(p, r+1):\\n if L[i] <= R[j]:\\n A[k] = L[i]\\n i += 1\\n else:\\n A[k] = R[j]\\n j += 1\",\n \"def merge(A, p, q, r):\\n left, right = [], []\\n for i in range(p, q + 1):\\n left.append(A[i])\\n\\n for j in range(q + 1, r + 1):\\n right.append(A[j])\\n\\n i, j = 0, 0\\n for k in range(p, r + 1):\\n if i > q - p:\\n A[k] = right[j]\\n j += 1\\n continue\\n if j > r - q - 1:\\n A[k] = left[i]\\n i += 1\\n continue\\n\\n if left[i] <= right[j]:\\n A[k] = left[i]\\n i += 1\\n else:\\n A[k] = right[j]\\n j += 1\",\n \"def merge(arr, p, q, r):\\r\\n assist = np.zeros(r-p+1)\\r\\n s = p\\r\\n t = q+1\\r\\n k = 0\\r\\n while s<=q and t<=r:\\r\\n if arr[s] < arr[t]:\\r\\n assist[k] = arr[s]\\r\\n s = s+1\\r\\n else:\\r\\n assist[k] = arr[t]\\r\\n t = t+1\\r\\n k = k+1\\r\\n if s == q+1:\\r\\n assist[k:r-p+1] = arr[t:r+1]\\r\\n else:\\r\\n assist[k:r-p+1] = arr[s:q+1]\\r\\n return assist\",\n \"def union(p, q):\\n for i in q:\\n if i not in p:\\n p.append(i)\",\n \"def union(p,q):\\n\\tfor e in q:\\n\\t\\tif e not in p:\\n\\t\\t\\tp.append(e)\",\n \"def union(self, p, q):\\n p_id = self._root(p)\\n q_id = self._root(q)\\n if (p_id == q_id):\\n return;\\n if (self._sz[p_id] < self._sz[q_id]):\\n self._id[p_id] = q_id\\n self._sz[q_id] += self._sz[p_id]\\n else:\\n self._id[q_id] = p_id\\n self._sz[p_id] += self._sz[q_id]\",\n \"def merge(*in_qs, **kwargs):\\n out_q = Queue(**kwargs)\\n threads = [Thread(target=push, args=(q, out_q)) for q in in_qs]\\n for t in threads:\\n t.daemon = True\\n t.start()\\n return out_q\",\n \"def union(self, p, q):\\n pass\",\n \"def merge_arrays_as_queues(array1, array2):\\n q_a = deque(array1)\\n q_b = deque(array2)\\n res = [-1 for _ in xrange(len(array1)+len(array2))]\\n for idx in xrange(0, len(res)):\\n print q_a, q_b\\n print res\\n if (not q_a) or (q_b[0] < q_a[0]):\\n res[idx] = q_b.popleft()\\n elif (not q_b) or (q_a[0] < q_b[0]):\\n res[idx] = q_a.popleft()\\n else:\\n res[idx] = q_b.popleft()\\n\\n return res\",\n \"def temp_split(filename):\\n filename, ext = filename.rsplit('.')\\n data = np.load(filename + \\\".\\\" + ext)\\n # define basic constants from parent\\n A = data['a']\\n A_SIZE = A.shape[0]\\n A_SHAPE = A.shape\\n ORIGINAL_SIZE = data['original_size']\\n B = data['b']\\n # basics\\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\\n # eval & evec\\n eval, evec = linalg.eigh(B)\\n # split\\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\\n # threshold (q)\\n q1 = create_q(A_SIZE, B, g1_order, m)\\n q2 = create_q(A_SIZE, B, g2_order, m)\\n # B of G\\n b1 = create_b_of_g(B, g1_order)\\n b2 = create_b_of_g(B, g2_order)\\n # a_elems\\n a1_elems = []\\n a2_elems = []\\n original_elems = data['a_elems']\\n for i in g1_order:\\n a1_elems.append(original_elems[i])\\n for i in g2_order:\\n a2_elems.append(original_elems[i])\\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\\\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))\",\n \"def _concatenate_inner(self, chunks, direction):\\n tmp_bucket = []\\n source_chunks = chunks if direction else chunks[::-1]\\n target_chunks = ChunkList()\\n for chunk in source_chunks:\\n if (\\n # if the chunk has matched dependency, do concatenation.\\n chunk.dependency == direction or\\n # if the chunk is SPACE, concatenate to the previous chunk.\\n (direction == False and chunk.is_space())\\n ):\\n tmp_bucket.append(chunk)\\n continue\\n tmp_bucket.append(chunk)\\n if not direction: tmp_bucket = tmp_bucket[::-1]\\n new_word = ''.join([tmp_chunk.word for tmp_chunk in tmp_bucket])\\n chunk.update_word(new_word)\\n target_chunks.append(chunk)\\n tmp_bucket = []\\n if tmp_bucket: target_chunks += tmp_bucket\\n return target_chunks if direction else target_chunks[::-1]\",\n \"def merge_plays(a, b, k=10):\\n x = []\\n while len(a) and len(b):\\n if b[0].points > a[0].points:\\n x.append(b.pop(0))\\n else:\\n x.append(a.pop(0))\\n\\n if len(x) >= k:\\n return x\\n while len(a):\\n x.append(a.pop(0))\\n while len(b):\\n x.append(b.pop(0))\\n return x\",\n \"def split(self, X):\",\n \"def solve_inplace(array1, array2):\\n # append all b values to end of a and then sort\\n pass\",\n \"def split(self) -> GQASplit:\\n return self._split\",\n \"def merge(self, A, ind, p, q, r, rc_array):\\n\\n left = ind[p:q + 1]\\n right = ind[q + 1:r + 1]\\n\\n i = 0\\n j = 0\\n ic = 0\\n k = p\\n\\n while i < len(left) and j < len(right):\\n if A[left[i]] > A[right[j]]:\\n ind[k] = right[j]\\n ic += 1\\n k += 1\\n j += 1\\n else:\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n i += 1\\n k += 1\\n\\n while i < len(left):\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n k += 1\\n i += 1\\n while j < len(right):\\n ind[k] = right[j]\\n k += 1\\n j += 1\",\n \"def unify(self, p, q):\\n root1, root2 = self.find(p), self.find(q)\\n\\n # If the elements are already in the same set\\n if root1 == root2:\\n return\\n\\n # Merge the smaller component/set into the larger one.\\n if self.comp_size[root1] < self.comp_size[root2]:\\n self.comp_size[root2] += self.comp_size[root1]\\n self.id[root1] = root2\\n else:\\n self.comp_size[root1] += self.comp_size[root2]\\n self.id[root2] = root1\\n\\n # Since the roots found were different, we know that the\\n # number of components/sets has decreased by one.\\n self.num_components -= 1\",\n \"def merge(a, b):\\r\\n # your code here\\r\\n \\r\\n m = []\\r\\n i, j = 0, 0\\r\\n \\r\\n while i < len(a) and j < len(b):\\r\\n if a[i] < b[j]:\\r\\n m.append(a[i])\\r\\n i += 1\\r\\n else:\\r\\n m.append(b[j])\\r\\n j += 1\\r\\n \\r\\n m += a[i:] + b[j:]\\r\\n \\r\\n return m\",\n \"def merge_quick_sort(L):\\n list1 = []\\n list2 = []\\n (evens, odds) = merge_sort.split(L)\\n list1 += quick_sort.quick_sort(evens)\\n list2 += quick_sort.quick_sort(odds)\\n x = merge_sort.merge(list1,list2)\\n return x\",\n \"def split(filename, initial=False, optimize=False):\\n # load data\\n filename, ext = filename.rsplit('.')\\n data = np.load(filename + \\\".\\\" + ext)\\n # define constants and load A if initial\\n A = data['a']\\n A_SIZE = A.shape[0]\\n A_SHAPE = A.shape\\n if initial:\\n ORIGINAL_SIZE = A_SIZE\\n else:\\n ORIGINAL_SIZE = data['original_size']\\n # basics\\n ki, kj, m = np.sum(A, 1), np.sum(A, 0), np.sum(np.sum(A, 1))\\n # create B if initial, if not, import from archive\\n if initial:\\n p1 = create_p1(A_SHAPE, ki, kj)\\n p = create_p(p1, m)\\n B = A - p\\n else:\\n B = data['b']\\n if A_SIZE <= 1:\\n raise CannotSplit\\n # eval & evec\\n eval, evec = linalg.eigh(B)\\n # split\\n g1_order, g1_arrays, g2_order, g2_arrays = create_g(A, evec)\\n g1, g2 = create_g_matrix(g1_order, g1_arrays), create_g_matrix(g2_order, g2_arrays)\\n # threshold (q)\\n q1 = create_q(A_SIZE, B, g1_order, m)\\n q2 = create_q(A_SIZE, B, g2_order, m)\\n # B of G\\n b1 = create_b_of_g(B, g1_order)\\n b2 = create_b_of_g(B, g2_order)\\n # a elems\\n a1_elems = []\\n a2_elems = []\\n if initial:\\n a1_elems = g1_order\\n a2_elems = g2_order\\n else:\\n original_elems = data['a_elems']\\n for i in g1_order:\\n a1_elems.append(original_elems[i])\\n for i in g2_order:\\n a2_elems.append(original_elems[i])\\n # save\\n if not g1_order or not g2_order:\\n raise CannotSplit(message='One group is empty, cannot split.')\\n if initial:\\n # save files\\n np.savez('g1.npz', a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\\n np.savez('g2.npz', a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\\n # create File records\\n files.File.create(filename='g1', ext=ext, q=q1, shape=g1.shape[0], a_elems=','.join([str(x) for x in a1_elems]))\\n files.File.create(filename='g2', ext=ext, q=q2, shape=g2.shape[0], a_elems=','.join([str(x) for x in a2_elems]))\\n # create Item records for burning\\n files.Item.create(filename='.'.join(('g1', ext)))\\n files.Item.create(filename='.'.join(('g2', ext)))\\n if optimize:\\n opt_table = []\\n for idx, elem in enumerate(g1_order):\\n # create copies of new arrays\\n new_g1_order, new_g1_arrays, new_g2_order, new_g2_arrays = g1_order[:], g1_arrays[:], g2_order[:], g2_arrays[:]\\n # first append new material to other array\\n new_g2_order.append(elem) # TODO: check if need to be sorted\\n new_g2_arrays.append(new_g1_arrays[idx]) # TODO: check if insert instead if size g2 size is >= g1 size?\\n # delete material from new_g1_*\\n del new_g1_order[idx]\\n del new_g1_arrays[idx]\\n # create new Qs\\n new_q1, new_q2 = create_q(A_SIZE, B, new_g1_order, m), create_q(A_SIZE, B, new_g2_order, m)\\n opt_table.append((elem, new_q1, new_q2))\\n return sorted(opt_table, key=lambda x: x[0])\\n else:\\n # return to manager to set parents\\n np.savez(filename + \\\",1\\\" + \\\".\\\" + ext, a=g1, b=b1, q=q1, a_elems=a1_elems, original_size=ORIGINAL_SIZE)\\n np.savez(filename + \\\",2\\\" + \\\".\\\" + ext, a=g2, b=b2, q=q2, a_elems=a2_elems, original_size=ORIGINAL_SIZE)\\n # save filenames for burn regardless if saved or not, why didn't I do this before in master?\\n files.Item.create(filename=filename + ',2.' + ext)\\n files.Item.create(filename=filename + ',1.' + ext)\\n # return so we can manipulate\\n return Part(filename + ',1', ext, q1, g1.shape[0], ','.join([str(x) for x in a1_elems])), \\\\\\n Part(filename + ',2', ext, q2, g2.shape[0], ','.join([str(x) for x in a2_elems]))\",\n \"def qu_union(self, p, q):\\n pID = self.qu_findroot(p)\\n qID = self.qu_findroot(q)\\n\\n if pID == qID: return\\n\\n if p > q: self.id[qID] = pID\\n else: self.id[pID] = qID\\n return 1\",\n \"def splice(i, j, data):\\n n = len(data)\\n out = ()\\n splice_a = []\\n splice_b = []\\n i = idx(i, n)\\n j = idx(j, n)\\n i+=1\\n j+=1\\n if(i < j):\\n splice_a = data[i:j]\\n splice_b = data[j:] + data[0:i]\\n else:\\n splice_a = data[i:] + data[0:j]\\n splice_b = data[j:i]\\n\\n return (splice_a, splice_b)\",\n \"def test_merge(self):\\n A = [1,4,6,7,8,2,3,4,5,7]\\n p = 0\\n q = 5\\n r = 10\\n A_merged = mst.merge(A, p, q, r)\\n expected = [1, 2, 3, 4, 4, 5, 6, 7, 7, 8] \\n self.assertEqual(A, A_merged)\",\n \"def wqu_union(self, p, q):\\n pID = self.qu_findroot(p)\\n qID = self.qu_findroot(q)\\n\\n if pID == qID: return\\n if(self.sz[pID] < self.sz[qID]):\\n self.id[pID] = qID\\n self.sz[qID] += self.sz[pID]\\n else:\\n self.id[qID] = pID\\n self.sz[pID] += self.sz[qID]\\n return 1\",\n \"def merge(a, b):\\n result = []\\n\\n # Append smallest values to result until either list is exhausted\\n i = j = 0\\n while i < len(a) and j < len(b):\\n if compare(a[i], b[j]) < 0:\\n result.append(a[i])\\n i += 1\\n else:\\n result.append(b[j])\\n j += 1\\n\\n # Append all remaining values from the unexhausted list\\n if i < len(a):\\n result.extend(a[i:])\\n else:\\n result.extend(b[j:])\\n\\n return result\",\n \"def _merge_intent_fragments(self, start_offset, upload_intents, copy_intents):\\n upload_intents = deque(upload_intents)\\n copy_intents = deque(copy_intents)\\n while True:\\n upload_intent = copy_intent = None\\n if upload_intents:\\n upload_intent, upload_end, _ = upload_intents[0]\\n if copy_intents:\\n copy_intent, copy_end, copy_protected = copy_intents[0]\\n\\n if upload_intent is not None and copy_intent is not None:\\n if not copy_protected:\\n yield_intent = upload_intent\\n else:\\n yield_intent = copy_intent\\n start_offset = min(upload_end, copy_end)\\n yield yield_intent, start_offset\\n if start_offset >= upload_end:\\n upload_intents.popleft()\\n if start_offset >= copy_end:\\n copy_intents.popleft()\\n elif upload_intent is not None:\\n yield upload_intent, upload_end\\n upload_intents.popleft()\\n elif copy_intent is not None:\\n yield copy_intent, copy_end\\n copy_intents.popleft()\\n else:\\n return\",\n \"def wpqu_union(self, p, q):\\n pID = self.pqu_findroot(p)\\n qID = self.pqu_findroot(q)\\n\\n if pID == qID: return\\n if (self.sz[pID] < self.sz[qID]):\\n self.id[pID] = qID\\n self.sz[qID] += self.sz[pID]\\n else:\\n self.id[qID] = pID\\n self.sz[pID] += self.sz[qID]\\n return 1\",\n \"def spliter(temp,split1,split2):\\n for x in range(len(temp)):\\n if x<len(temp)/2:\\n split1.append(temp[x])\\n else:\\n split2.append(temp[x])\",\n \"def qsort(A, l, r):\\n if l < r:\\n q = partition(A, l, r)\\n qsort(A, l, q-1)\\n qsort(A, q+1, r)\",\n \"def union(self, p, q):\\n self._validate(p)\\n self._validate(q)\\n p_parent = self.find(p)\\n q_parent = self.find(q)\\n if p_parent == q_parent:\\n return\\n for i in range(len(self.parents)):\\n if self.parents[i] == q_parent:\\n self.parents[i] = p_parent\\n self.n -= 1\",\n \"def split_chunk(chunk, *a, **kw):\\n return split_chunk(chunk, *a, **kw)\",\n \"def pqu_union(self, p, q):\\n pID = self.pqu_findroot(p)\\n qID = self.pqu_findroot(q)\\n\\n if pID == qID: return\\n\\n if p > q:\\n self.id[qID] = pID\\n else:\\n self.id[pID] = qID\\n return 1\",\n \"def qids_to_splits(qids):\\n qidmap = {}\\n i = 0\\n for qid in qids:\\n if not qid in qidmap:\\n qidmap[qid] = i\\n i+=1\\n new_qids = []\\n for qid in qids:\\n new_qids.append(qidmap[qid])\\n qidcount = np.max(new_qids)+1\\n splits = [[] for i in range(qidcount)]\\n for i, qid in enumerate(new_qids):\\n splits[qid].append(i) \\n return splits\",\n \"def merge_sort(alist):\\n print(\\\"Splitting \\\", alist)\\n # Temporary list to store sorted list\\n work = [None] * len(alist)\\n rec_merge_sort(work, start=0, end=len(alist)-1)\",\n \"def split(aDeck,location):\\r\\n newDeck=[]\\r\\n for x in range(location):\\r\\n newDeck.append(aDeck.pop())\\r\\n return (newDeck)\",\n \"def union(self, p, q):\\n p_id = self._root(p)\\n q_id = self._root(q)\\n self._id[p_id] = q_id\",\n \"def splits_array_switcher(trajectory1, trajectory2, index_of_cut):\\r\\n\\r\\n trajectory1_a, trajectory2_b = trajectory1[:index_of_cut], trajectory1[index_of_cut:]\\r\\n trajectory2_a, trajectory1_b = trajectory2[:index_of_cut], trajectory2[index_of_cut:]\\r\\n\\r\\n trajectory1 = np.concatenate((trajectory1_a, trajectory1_b), axis=0)\\r\\n trajectory2 = np.concatenate((trajectory2_a, trajectory2_b), axis=0)\\r\\n\\r\\n return trajectory1, trajectory2\",\n \"def sortbatch(q_batch, a_batch, q_lens, a_lens):\\n maxlen_q = max(q_lens)\\n maxlen_a = max(a_lens)\\n q=q_batch[:,:maxlen_q-1]\\n a=a_batch[:,:maxlen_a-1]\\n sorted_idx = torch.LongTensor(a_lens.numpy().argsort()[::-1].copy())\\n return q[sorted_idx], a[sorted_idx], q_lens[sorted_idx], a_lens[sorted_idx]\",\n \"def _intermediates(q, results):\\n # type: (np.ndarray, List[Tuple[Kernel, np.ndarray, Optional[Callable]]]) -> OrderedDict[str, Any]\\n parts = OrderedDict()\\n for part_num, (kernel, Iq, intermediates) in enumerate(results):\\n part_id = chr(ord('A') + part_num) + \\\"_\\\" + kernel.info.name + \\\"(Q)\\\"\\n parts[part_id] = (q, Iq)\\n if intermediates is not None:\\n parts[part_id + \\\" parts\\\"] = intermediates()\\n return parts\",\n \"def _group_chunks_by_entities(self, chunks, entities):\\n for entity in entities:\\n chunks_to_concat = chunks.get_overlaps(\\n entity['beginOffset'], len(entity['content']))\\n if not chunks_to_concat: continue\\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\\n new_chunk = Chunk(new_chunk_word)\\n chunks.swap(chunks_to_concat, new_chunk)\\n return chunks\",\n \"def _group_chunks_by_entities(self, chunks, entities):\\n for entity in entities:\\n chunks_to_concat = chunks.get_overlaps(\\n entity['beginOffset'], len(entity['content']))\\n if not chunks_to_concat:\\n continue\\n new_chunk_word = u''.join([chunk.word for chunk in chunks_to_concat])\\n new_chunk = Chunk(new_chunk_word)\\n chunks.swap(chunks_to_concat, new_chunk)\\n return chunks\",\n \"def wpqu_union(self, p, q):\\n if self.wpqu_connected(p,q):\\n return True;\\n \\n p_pa,q_pa = self.id[p],self.id[q]\\n \\n if self.sz[p_pa] >= self.sz[q_pa]:\\n self.id[q_pa] = p_pa\\n self.sz[p_pa] += self.sz[q_pa] \\n else:\\n self.id[p_pa] = q_pa\\n self.sz[q_pa] += self.sz[p_pa] \\n return True\",\n \"def d_j(self,q):\\n dj = q.shift(y=-1) - q # works with chunks too\\n return dj\",\n \"def _load_data(l, q, nproc):\\n for element in l:\\n q.put(element)\\n for _ in range(nproc):\\n q.put(FINISHED)\",\n \"def busca_base(A, a, q):\\n \\n \\n nrow = np.shape(A)[0]\\n zeros = np.zeros((nrow, 1))\\n B0, _ = householder(power(A-a*np.identity(nrow), q), zeros)\\n \\n # calcula el rango de la matriz B0\\n r = rango_matrix(B0)\\n \\n # G = [G1, G2, ..., Gn-r], donde Gi: i-esimo vector generador de N((A-aI)^{q})\\n # NOTA: No esta garanizado que {G1, G2, ..., Gn-r}, sean li\\n G = np.zeros((nrow, nrow-r))\\n for k in range(r):\\n # coeff(k, i): coeficiente de xi en la combinacion lineal de los xr+1,xr+2,...,xn, para obtener -B0[k,k]xk\\n G[k,:] = - np.array([coeff(k,r+i, B0) for i in range(1, nrow-r+1)])/B0[k,k]\\n G[nrow:, :] = np.identity(nrow-r)\\n \\n return vectores_li(G, r) # retorna solo los vectore li de {G1, G2, ..., Gn-r}, en una matriz\",\n \"def wqu_union(self, p, q):\\n \\n if self.wqu_connected(p, q):\\n return True\\n \\n p_pa,q_pa = p,q\\n while p_pa != self.id[p_pa]:\\n p_pa = self.id[p_pa]\\n while q_pa != self.id[q_pa]:\\n q_pa = self.id[q_pa]\\n \\n if self.sz[p_pa] >= self.sz[q_pa]:\\n self.id[q_pa] = p_pa\\n self.sz[p_pa] += self.sz[q_pa] \\n else:\\n self.id[p_pa] = q_pa\\n self.sz[q_pa] += self.sz[p_pa] \\n return True\",\n \"def pqu_union(self, p, q):\\n if self.pqu_connected(p,q):\\n return True\\n self.id[self.id[p]] = self.id[q]\\n return True\",\n \"def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\\n A[m:] = B\\n A.sort()\",\n \"def mergesort(A, p, r):\\n if p < r:\\n q = (p+r)//2\\n mergesort(A, p, q)\\n mergesort(A, q + 1, r)\\n merge(A, p, q, r)\",\n \"def split_segments(old_seg_ends, B):\\n new_segment_ends = []\\n for q in range(0, B.size):\\n new_ends = list(np.linspace(old_seg_ends[q], old_seg_ends[q + 1], B[q] + 1))\\n new_segment_ends.extend(new_ends[:-1])\\n new_segment_ends.extend([1])\\n new_segment_ends = np.asarray(new_segment_ends)\\n return new_segment_ends\",\n \"def merge(li: Sequence, left_index: int, mid_index: int, right_index: int) -> None:\\n left_li = li[left_index : mid_index]\\n right_li = li[mid_index : right_index]\\n i, j, k = 0, 0, left_index\\n \\n while i < len(left_li) and j < len(right_li):\\n if left_li[i] <= right_li[j]:\\n li[k] = left_li[i]\\n i += 1\\n else:\\n li[k] = right_li[j]\\n j += 1\\n k += 1\\n \\n # Copy the remainders\\n while i < len(left_li):\\n li[k] = left_li[i]\\n i += 1\\n k += 1\\n while j < len(right_li):\\n li[k] = right_li[j]\\n j += 1\\n k += 1\",\n \"def merge_recs(part_one, part_two, output):\\n start_op_length = 28\\n with open(part_one, 'rb') as a_handle, \\\\\\n open(part_two, 'rb') as b_handle, \\\\\\n open(output, 'wb') as merged:\\n\\n a_data = a_handle.read()\\n b_data = b_handle.read()\\n\\n postgame_pos, _ = find_postgame(a_data, len(a_data))\\n if postgame_pos:\\n a_data_end = postgame_pos - LOOKAHEAD\\n else:\\n a_data_end = len(a_data)\\n b_header_len, = struct.unpack('<I', b_data[:4])\\n chapter = mgz.body.operation.build({\\n 'type': 'action',\\n 'op': 1,\\n 'length': 2,\\n 'action': {\\n 'type': 'chapter',\\n 'player_id': 0xff # our merge marker\\n }\\n })\\n\\n # part A with no postgame struct\\n merged.write(a_data[:a_data_end])\\n # chapter action\\n merged.write(chapter)\\n # offset to start of part B operations\\n merged.write(struct.pack('<I', a_data_end + len(chapter) + b_header_len))\\n # part B header (now a \\\"saved chapter\\\")\\n merged.write(b_data[4:b_header_len])\\n # part B operations with no start operation\\n merged.write(b_data[b_header_len + start_op_length:])\",\n \"def mergeSeq(left, right):\\n i = j = 0\\n result = []\\n while i < len(left) and j < len(right):\\n if left[i] <= right[j]:\\n result.append(left[i])\\n i += 1\\n else:\\n result.append(right[j])\\n j += 1\\n\\n result += left[i:]\\n result += right[j:]\\n return result\",\n \"def _get_pmx_crossed_sequence(sequence_a: OrderedSet, sequence_b: OrderedSet,\\n part_from_a: OrderedSet, part_from_b: OrderedSet,\\n start_index: int, end_index: int) -> List[int]:\\n new_sequence = list(sequence_b)\\n\\n elements_requiring_correction = {}\\n\\n uniques_from_b_part = part_from_b - part_from_a\\n for unique_from_b_part in uniques_from_b_part:\\n index_in_part = part_from_b.index(unique_from_b_part)\\n elements_requiring_correction[unique_from_b_part] = part_from_a[index_in_part]\\n\\n for elem_from_b, elem_from_a in elements_requiring_correction.items():\\n while elem_from_a in part_from_b:\\n index_of_elem_from_b = sequence_b.index(elem_from_a)\\n elem_from_a = sequence_a[index_of_elem_from_b]\\n\\n new_index = sequence_b.index(elem_from_a)\\n new_sequence[new_index] = elem_from_b\\n\\n new_sequence[start_index:end_index] = part_from_a\\n\\n return new_sequence\",\n \"def push(self, x):\\n # enqueue new element to q2\\n self.q2.enqueue(x)\\n # dequeue from q1 and enqueue in q2\\n\\n while self.q1.qlist:\\n self.q2.enqueue(self.q1.dequeue())\\n # swap q1 and q2\\n temp = self.q1.qlist\\n self.q1.qlist = self.q2.qlist\\n self.q2.qlist = temp\",\n \"def merge(a,b):\\n c = []\\n while len(a) != 0 and len(b) != 0:\\n if a[0] < b[0]:\\n c.append(a[0])\\n a.remove(a[0])\\n else:\\n c.append(b[0])\\n b.remove(b[0])\\n if len(a) == 0:\\n c += b\\n else:\\n c += a\\n return c\",\n \"def interval_split(a,b,split_ps):\\n ps = [a] + [s for s in sorted(split_ps) if a < s < b] + [b]\\n return [(p1,p2) for p1,p2 in zip(ps,ps[1:])]\",\n \"def addToBq(self, p):\\n self.allJobs.append(p)\\n p.submitToQueue()\\n if len(self.circQ) < self.maxLength - 1:\\n self.circQ.append(p)\",\n \"def addToBq(self, p):\\n self.allJobs.append(p)\\n p.submitToQueue()\\n if len(self.circQ) < self.maxLength - 1:\\n self.circQ.append(p)\",\n \"def merge_ranges():\",\n \"def qf_union(self, p, q):\\n pID = self.id[p]\\n\\n for x in range(len(self.id)):\\n if self.id[x] == pID:\\n self.id[x] = self.id[q]\\n return 1\",\n \"def merge_reads(s1, s2, q1, q2, amplen):\\n # If the amplicon is of length L and the reads are lengths l1, l2 then:\\n # - read 1 from 0 to L-l2-1 inclusive doesn't overlap\\n # - read 1 from L-l2 to l1-1 inclusive overlaps with read 2\\n # - read 2 from 0 to l1+l2-L-1 inclusive overlaps with read 1\\n # - read 2 from l1+l2-L to its end doesn't overlap\\n\\n # A picture for clarity:\\n # s1 coords: 0 l1-1\\n # | |\\n # ----------------------------------------\\n # ------------------------------\\n # | | |\\n # s1 coords: L-l2 | L-1\\n # s2 coords: 0 l1+l2-L-1\\n\\n # Reverse complement read 2 and reverse its quality scores.\\n s2 = reverse_complement(s2)\\n q2 = q2[::-1]\\n\\n # This is where we'll put the merged sequence and quality score.\\n s = np.zeros(amplen, dtype=np.int8)\\n q = np.zeros(amplen, dtype=np.int8)\\n\\n # If the reads overlap correctly, then s1[offset+i] == s2[i], assuming s2 is\\n # the reverse complement of the reverse read.\\n offset = amplen - len(s2)\\n\\n # Fill in the parts of the merged sequence where the reads don't overlap.\\n s[:offset] = s1[:offset]\\n q[:offset] = q1[:offset]\\n s[len(s1):] = s2[len(s1)+len(s2)-amplen:]\\n q[len(s1):] = q2[len(s1)+len(s2)-amplen:]\\n\\n # Create a set of views into the overlapping region. We can directly compare\\n # vs1[i] to vs2[i] and use that to fill in vs[i] with all indexing taken\\n # care of.\\n vs1 = s1[offset:]\\n vq1 = q1[offset:]\\n vs2 = s2[:len(vs1)]\\n vq2 = q2[:len(vs1)]\\n vs = s[offset:len(s1)]\\n vq = q[offset:len(s1)]\\n\\n # Quality score of matching bases is the larger of the two quality\\n # scores (this is a somewhat conservative low estimate). Quality\\n # score of mismatched bases is the difference of the two quality\\n # scores. If the mismatched bases have equal quality scores, the\\n # base is written as an N with the minimum possible quality.\\n\\n # Positions where the reads agree.\\n ieq = vs1 == vs2\\n vs[ieq] = vs1[ieq]\\n vq[ieq] = np.maximum(vq1[ieq], vq2[ieq])\\n\\n # Positions where the reads disagree.\\n ineq = vs1 != vs2\\n mismatches = ineq.sum()\\n\\n # Positions where the reads disagree and read 1 has the higher quality.\\n ir1 = np.logical_and(ineq, vq1 > vq2)\\n vs[ir1] = vs1[ir1]\\n vq[ir1] = MIN_QUAL + vq1[ir1] - vq2[ir1]\\n\\n # Positions where the reads disagree and read 2 has the higher quality.\\n ir2 = np.logical_and(ineq, vq2 > vq1)\\n vs[ir2] = vs2[ir2]\\n vq[ir2] = MIN_QUAL + vq2[ir2] - vq1[ir2]\\n\\n # Positions where the reads disagree and they have equal qualities.\\n irn = np.logical_and(ineq, vq1 == vq2)\\n vs[irn] = bN\\n vq[irn] = MIN_QUAL\\n\\n return s, q, mismatches\",\n \"def sort(self, A, index, p, r, rc_arr):\\n\\n if p < r:\\n q = (p + r) // 2\\n\\n self.sort(A, index, p, q, rc_arr)\\n self.sort(A, index, q + 1, r, rc_arr)\\n self.merge(A, index, p, q, r, rc_arr)\",\n \"def __init__(self):\\n self.A = [] # 大顶堆，存放较小的元素\\n self.B = [] # 小顶堆，存放较大的元素，使得B的最小的元素也比A中最大的元素大，保证数据流保持有序\",\n \"def merge(self, parallel_seq):\\n return _OSeq(sorted(self._elements + parallel_seq._elements, key=lambda x: x.get(offset_attr, 0)))\",\n \"def _prepare(self, q):\\n # store it in _lastr which is consulted in BasePDFGenerator.__call__\\n self._lastr = q\\n self._calc.qstep = q[1] - q[0]\\n self._calc.qmin = q[0]\\n self._calc.qmax = q[-1] + 0.5*self._calc.qstep\\n return\",\n \"def mconcat(a, b):\\r\\n if a is None:\\r\\n return b\\r\\n if b is None:\\r\\n return a\\r\\n for key in b.keyset:\\r\\n value=get(b,key)\\r\\n put(a,key,value)\\r\\n return a\",\n \"def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\\n # # solution one: sort\\n # A[m:] = B\\n # A.sort()\\n\\n # solution two: two point\\n if n == 0: # B = []\\n return\\n i, j, k = m - 1, n - 1, m + n - 1\\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\\n if A[i] <= B[j]:\\n A[k] = B[j]\\n k -= 1\\n j -= 1\\n else:\\n A[k] = A[i]\\n k -= 1\\n i -= 1\\n if j > -1:\\n A[:j + 1] = B[:j + 1] # A = [], B = [1]\",\n \"def merge(items, start, end, subarray_size):\\n mid = start + subarray_size\\n assert is_sorted(items[start:mid])\\n assert is_sorted(items[start+subarray_size:end])\\n\\n aux = []\\n i = start\\n j = mid\\n\\n while i < mid and j < end:\\n if items[i] < items[j]:\\n aux.append(items[i])\\n i += 1\\n else:\\n aux.append(items[j])\\n j += 1\\n aux.extend(items[i:mid] or items[j:end])\\n assert is_sorted(aux)\\n\\n ## Overwrite elements in subarrays in their correctly sorted order\\n for i in range(start, end):\\n items[i] = aux[i-start]\",\n \"def test_merge():\\n\\n q1 = PriorityQueue()\\n q2 = PriorityQueue()\\n\\n # input list (obj, priority) should be reversed\\n # in the priority_queue\\n input_list = [((1), 9), ((2), 8), ((3), 7),\\n ((4), 6), ((5), 5), ((6), 4),\\n ((7), 3), ((8), 2), ((9), 1)]\\n\\n # insert the items into the queues\\n for idx, (obj, p) in enumerate(input_list):\\n if idx < 4:\\n q1.push(obj, p)\\n else:\\n q2.push(obj, p)\\n\\n # merge the queues\\n q1.merge(q2)\\n\\n # dump the queue into a list\\n output = []\\n while q1._queue:\\n output.append(q1.pop())\\n\\n # validate the expected behavior\\n eq_(output, range(1, 10)[::-1])\",\n \"def subsample(self, dQ):\\n # Assumes self contains sorted Qo and associated T, L\\n # Note: calc_Qo is already sorted\\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\\n idx = np.unique(np.searchsorted(self.Qo, Q))\\n #print len(idx), len(self.Qo)\\n\\n self.T, self.dT = self.T[idx], self.dT[idx]\\n self.L, self.dL = self.L[idx], self.dL[idx]\\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\\n if self.R is not None:\\n self.R = self.R[idx]\\n if self.dR is not None:\\n self.dR = self.dR[idx]\\n self._set_calc(self.T, self.L)\",\n \"def concatenate(self):\\n if not self.match_count:\\n # No concatenating if there are no matches\\n return []\\n if self.match_count <= 1:\\n # Can't combine a single match\\n return self.match_list\\n # Setup for iterating through\\n cont = True\\n first = self.match_list[self.i]\\n second = self.match_list[self.j]\\n while cont and self.match_count > 2:\\n first, second, cont = self._process_main()\\n\\n # Last block is a special case\\n self._process_last(first, second)\\n return self.combined\",\n \"def test_three_split():\\n run_mergesort([3, 0, 3], [0, 3, 3])\",\n \"def mergesort(input):\\n\\n if len(input) <= 1:\\n return input\\n\\n cut = len(input) // 2 # floored quotient\\n top = mergesort(input[:cut])\\n bottom = mergesort(input[cut:])\\n\\n i = 0\\n j = 0\\n\\n output = []\\n for x in range(len(input)):\\n if top[i] < bottom[j]:\\n output.append(top[i])\\n i += 1\\n if i >= len(top):\\n output += bottom[j:]\\n break\\n else:\\n output.append(bottom[j])\\n j += 1\\n if j >= len(bottom):\\n output += top[i:]\\n break\\n\\n return output\",\n \"def quick_sort_helper(a_list, first_position, last_position):\\n if first_position < last_position:\\n\\n split_point = partition(a_list, first_position, last_position)\\n\\n quick_sort_helper(a_list, first_position, split_point)\\n quick_sort_helper(a_list, split_point + 1, last_position)\\n\\n return a_list\",\n \"def union(self,i,j):\\n ii, jj = self.find(i), self.find(j)\\n if ii != jj:\\n\\n if self.rank[ii] > self.rank[jj]: \\n ii,jj = jj,ii\\n\\n if self.rank[ii] == self.rank[jj]: \\n self.rank[jj]+=1\\n\\n self.size[jj] += self.size[ii]\\n self.par[ii] = jj\\n\\n self.cMax = max(self.size[jj],self.cMax)\\n self.nComp -=1\\n\\n del self.size[ii]\",\n \"def merge(work, start_left, start_right, upper_bound):\\n # Keep track of index in temporary list\\n # whose length is the same as the original list\\n i = 0\\n lower_bound = start_left\\n mid = start_right - 1\\n # size of list after merge\\n n = upper_bound - lower_bound + 1\\n\\n # compare two sub lists per item\\n # and insert in original list\\n while start_left <= mid and start_right <= upper_bound:\\n work[i] = min(a_list[start_left], a_list[start_right])\\n if work[i] == a_list[start_left]:\\n start_left += 1\\n else:\\n start_right += 1\\n i += 1\\n\\n # If all items from second list are in original list\\n # insert all of the items from the first list\\n # as list is already sorted\\n while start_left <= mid:\\n work[i] = a_list[start_left]\\n i += 1\\n start_left += 1\\n\\n # If all items from first list are in original list\\n # insert all of the items from the second list\\n # as list is already sorted\\n while start_right <= upper_bound:\\n work[i] = a_list[start_right]\\n i += 1\\n start_right += 1\\n\\n # Transfer the temporary list \\\"work\\\" back to original\\n # list \\\"a_list\\\"\\n for k in range(0, n):\\n a_list[lower_bound+k] = work[k]\",\n \"def q_append_non_leaf(node, q):\\n for i in range(q-1):\\n node.addkid(Node(\\\"*\\\"), before=True)\\n node.addkid(Node(\\\"*\\\"))\",\n \"def union(self, p, q):\\n root_p = self.find(p)\\n root_q = self.find(q)\\n if root_p == root_q:\\n return\\n \\n #if the sites were isolated make them un-isolated\\n if self._nodes[p] == 1:\\n self._nodes[p] = 0\\n self._iso -= 1\\n if self._nodes[q] == 1:\\n self._nodes[q] = 0\\n self._iso -= 1\\n\\n # make root of smaller rank point to root of larger rank\\n if self._rank[root_p] < self._rank[root_q]:\\n self._parent[root_p] = root_q\\n #add the small root size to the big root size\\n self._size[root_q] += self._size[root_p]\\n #check if the big root size is now the biggest\\n if self._size[root_q] > self._max:\\n self._max = self._size[root_q]\\n elif self._rank[root_p] > self._rank[root_q]:\\n self._parent[root_q] = root_p\\n self._size[root_p] += self._size[root_q]\\n if self._size[root_p] > self._max:\\n self._max = self._size[root_p]\\n else:\\n self._parent[root_q] = root_p\\n self._size[root_p] += self._size[root_q]\\n if self._size[root_p] > self._max:\\n self._max = self._size[root_p]\\n self._rank[root_p] += 1\\n\\n self._count -= 1\",\n \"def split_sort_merge(items):\\n # TODO: Split items list into approximately equal halves\\n pivot = len(items) // 2\\n # TODO: Sort each half using any other sorting algorithm\\n # sort first half in-place (insertion sort)\\n left = insertion_sort(items[:pivot])\\n\\n right = insertion_sort(items[pivot:])\\n # TODO: Merge sorted halves into one list in sorted order\\n # merge the two half list (merge function but this does this in-place)\\n sorted_list = merge(left, right)\\n # change the input items\\n items[:] = sorted_list\\n return items\",\n \"def qu_union(self, p, q):\\n\\n if self.qu_connected(p, q):\\n return True\\n\\n p_pa,q_pa = p,q\\n while p_pa != self.id[p_pa]:\\n p_pa = self.id[p_pa]\\n while q_pa != self.id[q_pa]:\\n q_pa = self.id[q_pa]\\n self.id[p_pa] = q_pa\\n\\n return True\",\n \"def split(self):\\n\\n # FIXME: user should be able to change the default behavior of\\n # this function (for instance user may require one filter not\\n # to split the content of the input file and the same input \\n # to be used by the next filter.\\n \\n utils.split_file(self.files['hit_ids'],\\n self.files['input'],\\n self.files['filtered_reads'],\\n self.files['survived_reads'])\",\n \"def merge(A, left, middle, right):\\n leftSubArray = A[left:middle]\\n rightSubArray = A[middle:right+1]\\n leftSubArray.append(float(\\\"inf\\\"))\\n rightSubArray.append(float(\\\"inf\\\"))\\n i = j = 0\\n for k in xrange(left, right + 1):\\n if leftSubArray[i] < rightSubArray[j]:\\n A[k] = leftSubArray[i]\\n i += 1\\n else:\\n A[k] = rightSubArray[j]\\n j += 1\\n return A\",\n \"def queued(values, qsize):\\n values = [_normalize(v) for v in values]\\n if qsize < 1:\\n raise ValueError(\\\"qsize must be 1 or larger\\\")\\n q = []\\n it = iter(values)\\n try:\\n for i in range(qsize):\\n q.append(next(it))\\n for i in cycle(range(qsize)):\\n yield q[i]\\n q[i] = next(it)\\n except StopIteration:\\n pass\",\n \"def rejoin(l0,l1=None):\\r\\n while len(l0) != 0:\\r\\n if l1 is None:\\r\\n l1 = []\\r\\n if l0[0] == '<':\\r\\n if len(l0) >= 3:\\r\\n if l0[2] == '>':\\r\\n l1 += [l0.pop(0) + l0.pop(0) + l0.pop(0)]\\r\\n else:\\r\\n l1 += [l0.pop(0)]\\r\\n return l1\",\n \"def fastq_qc(demultiplex_result, out_dir, config):\\n\\n pigz_cores = int(config['fastqTrim']['pigz_cores'])\\n cutadapt_cores = int(config['fastqTrim']['cutadapt_cores'])\\n\\n r1_adapter = config['fastqTrim']['r1_adapter']\\n r2_adapter = config['fastqTrim']['r1_adapter']\\n length_threshold = config['fastqTrim']['length_threshold']\\n quality_threshold = config['fastqTrim']['quality_threshold']\\n r1_left_cut = config['fastqTrim']['r1_left_cut']\\n r1_right_cut = config['fastqTrim']['r1_right_cut']\\n r2_left_cut = config['fastqTrim']['r2_left_cut']\\n r2_right_cut = config['fastqTrim']['r2_right_cut']\\n overlap = config['fastqTrim']['overlap']\\n total_reads_threshold = int(config['fastqTrim']['total_reads_threshold'])\\n\\n results = []\\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\\n sample_demultiplex_total = sub_df['Trimmed'].sum()\\n if sample_demultiplex_total < total_reads_threshold:\\n log.info(f'In uid {uid}: index {index_name} skipped '\\n f'due to too less reads: {sample_demultiplex_total}')\\n continue\\n # process R1\\n r1_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R1.fq.gz'\\n r1_out = f'{out_dir}/{uid}_{index_name}_R1.trimed.fq.gz'\\n r1_cmd = f'pigz -cd -p {pigz_cores} {r1_path_pattern} | ' \\\\\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\\\\n f'-q {quality_threshold} -u {r1_left_cut} ' \\\\\\n f'-u -{r1_right_cut} -m {length_threshold} ' \\\\\\n f'-a {r1_adapter} -o {r1_out} -'\\n r1_result = subprocess.run(r1_cmd, stdout=subprocess.PIPE,\\n encoding='utf8', shell=True, check=True)\\n\\n # get R1 result stat\\n lines = []\\n for line in r1_result.stdout.split('\\\\n'):\\n ll = line.split('\\\\t')\\n if len(ll) > 1:\\n lines.append(ll)\\n s = pd.Series({name: number for name, number in zip(*lines)})\\n s['uid'] = uid\\n s['index_name'] = index_name\\n s['read_type'] = 'R1'\\n results.append(s)\\n\\n # process R2\\n r2_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R2.fq.gz'\\n r2_out = f'{out_dir}/{uid}_{index_name}_R2.trimed.fq.gz'\\n r2_cmd = f'pigz -cd -p {pigz_cores} {r2_path_pattern} | ' \\\\\\n f'cutadapt -j {cutadapt_cores} --report=minimal -O {overlap} ' \\\\\\n f'-q {quality_threshold} -u {r2_left_cut} ' \\\\\\n f'-u -{r2_right_cut} -m {length_threshold} ' \\\\\\n f'-a {r2_adapter} -o {r2_out} -'\\n r2_result = subprocess.run(r2_cmd, stdout=subprocess.PIPE,\\n encoding='utf8', shell=True, check=True)\\n # get R2 result stat\\n lines = []\\n for line in r2_result.stdout.split('\\\\n'):\\n ll = line.split('\\\\t')\\n if len(ll) > 1:\\n lines.append(ll)\\n s = pd.Series({name: number for name, number in zip(*lines)})\\n s['uid'] = uid\\n s['index_name'] = index_name\\n s['read_type'] = 'R2'\\n results.append(s)\\n\\n fastq_final_result = pd.DataFrame(results)\\n if len(results) == 0:\\n # all sample skipped\\n return fastq_final_result\\n fastq_final_result['out_reads_rate'] = \\\\\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\\n fastq_final_result['out_bp_rate'] = \\\\\\n fastq_final_result['out_reads'].astype(int) / fastq_final_result['in_reads'].astype(int)\\n\\n # clean up\\n for (uid, index_name), sub_df in demultiplex_result.groupby(['uid', 'index_name']):\\n r_path_pattern = f'{out_dir}/{uid}_L*_{index_name}_R*.fq.gz'\\n r_rm_cmd = f'rm -f {r_path_pattern}'\\n subprocess.run(r_rm_cmd, shell=True)\\n # remove unknown reads\\n r_path_pattern = f'{out_dir}/{uid}_L*_unknown_R*.fq.gz'\\n r_rm_cmd = f'rm -f {r_path_pattern}'\\n subprocess.run(r_rm_cmd, shell=True)\\n\\n return fastq_final_result\",\n \"def split_by(data_set, question, entropy_before):\\r\\n yea_set = []\\r\\n nay_set = []\\r\\n abstain_set = []\\r\\n\\r\\n for data_point in data_set:\\r\\n vote = data_point.dat_votes[ord(question)-97] #the way this representative voted is the data_point's votes indexed by question\\r\\n party = data_point.dat_party\\r\\n\\r\\n if vote == \\\"+\\\":\\r\\n yea_set.append(data_point)\\r\\n if vote == \\\"-\\\":\\r\\n nay_set.append(data_point)\\r\\n if vote == \\\".\\\":\\r\\n abstain_set.append(data_point)\\r\\n\\r\\n yea_entropy = abs(calc_entropy(yea_set) * (len(yea_set))/len(data_set))\\r\\n nay_entropy = abs(calc_entropy(nay_set) * (len(nay_set))/len(data_set))\\r\\n abstain_entropy = abs(calc_entropy(abstain_set) * (len(abstain_set))/len(data_set))\\r\\n calc_gain = entropy_before - (yea_entropy + nay_entropy + abstain_entropy)\\r\\n return (calc_gain,(yea_set, nay_set, abstain_set))\",\n \"def array_to_pq(pq, source):\\r\\n temp = None\\r\\n \\r\\n while source != []:\\r\\n temp = source.pop(0)\\r\\n pq.insert(temp)\\r\\n\\r\\n return\",\n \"def reverse_quad(q):\\n return [q[1], q[0], q[3], q[2]]\",\n \"def compute_fragments(self):\\n self.fragments = []\\n for part in self.parts:\\n for fragment in self.compute_digest(part):\\n # The part is not a fragment if it hasn't been cut at all and\\n # therefore doesn't have sticky ends. Exclude from fragments.\\n if not hasattr(fragment.seq, \\\"left_end\\\"):\\n continue\\n fragment.original_part = part\\n self.annotate_fragment_with_part(fragment)\\n self.fragments.append(fragment)\",\n \"def __split0_global_q_dict_set(\\n q_dict_col: Dict,\\n col: Union[int, torch.Tensor],\\n r_tiles: SquareDiagTiles,\\n q_tiles: SquareDiagTiles,\\n global_merge_dict: Dict = None,\\n) -> None:\\n # q is already created, the job of this function is to create the group the merging q's together\\n # it takes the merge qs, splits them, then puts them into a new dictionary\\n proc_tile_start = torch.cumsum(\\n torch.tensor(r_tiles.tile_rows_per_process, device=r_tiles.arr.larray.device), dim=0\\n )\\n diag_proc = torch.nonzero(input=proc_tile_start > col, as_tuple=False)[0].item()\\n proc_tile_start = torch.cat(\\n (torch.tensor([0], device=r_tiles.arr.larray.device), proc_tile_start[:-1]), dim=0\\n )\\n\\n # 1: create caqr dictionary\\n # need to have empty lists for all tiles in q\\n global_merge_dict = {} if global_merge_dict is None else global_merge_dict\\n\\n # intended to be used as [row][column] -> data\\n # 2: loop over keys in the dictionary\\n merge_list = list(q_dict_col.keys())\\n merge_list.sort()\\n # todo: possible improvement -> make the keys have the process they are on as well,\\n # then can async get them if they are not on the diagonal process\\n for key in merge_list:\\n # this loops over all of the Qs for col and creates the dictionary for the pr Q merges\\n p0 = key.find(\\\"p0\\\")\\n p1 = key.find(\\\"p1\\\")\\n end = key.find(\\\"e\\\")\\n r0 = int(key[p0 + 2 : p1])\\n r1 = int(key[p1 + 2 : end])\\n lp_q = q_dict_col[key][0]\\n base_size = q_dict_col[key][1]\\n # cut the q into 4 bits (end of base array)\\n # todo: modify this so that it will get what is needed from the process,\\n # instead of gathering all the qs\\n top_left = lp_q[: base_size[0], : base_size[0]]\\n top_right = lp_q[: base_size[0], base_size[0] :]\\n bottom_left = lp_q[base_size[0] :, : base_size[0]]\\n bottom_right = lp_q[base_size[0] :, base_size[0] :]\\n # need to adjust the keys to be the global row\\n col1 = col if diag_proc == r0 else proc_tile_start[r0].item()\\n col2 = proc_tile_start[r1].item()\\n # col0 and col1 are the columns numbers\\n # r0 and r1 are the ranks\\n jdim = (col1, col1)\\n kdim = (col1, col2)\\n ldim = (col2, col1)\\n mdim = (col2, col2)\\n\\n # if there are no elements on that location than set it as the tile\\n # 1. get keys of what already has data\\n curr_keys = set(global_merge_dict.keys())\\n # 2. determine which tiles need to be touched/created\\n # these are the keys which are to be multiplied by the q in the current loop\\n # for matrix of form: | J K |\\n # | L M |\\n mult_keys_00 = [(i, col1) for i in range(q_tiles.tile_columns)] # (J)\\n # (J) -> inds: (i, col0)(col0, col0) -> set at (i, col0)\\n mult_keys_01 = [(i, col1) for i in range(q_tiles.tile_columns)] # (K)\\n # (K) -> inds: (i, col0)(col0, col1) -> set at (i, col1)\\n mult_keys_10 = [(i, col2) for i in range(q_tiles.tile_columns)] # (L)\\n # (L) -> inds: (i, col1)(col1, col0) -> set at (i, col0)\\n mult_keys_11 = [(i, col2) for i in range(q_tiles.tile_columns)] # (M)\\n # (M) -> inds: (i, col1)(col1, col1) -> set at (i, col1)\\n\\n # if there are no elements in the mult_keys then set the element to the same place\\n s00 = set(mult_keys_00) & curr_keys\\n s01 = set(mult_keys_01) & curr_keys\\n s10 = set(mult_keys_10) & curr_keys\\n s11 = set(mult_keys_11) & curr_keys\\n hold_dict = global_merge_dict.copy()\\n\\n # (J)\\n if not len(s00):\\n global_merge_dict[jdim] = top_left\\n else: # -> do the mm for all of the mult keys\\n for k in s00:\\n global_merge_dict[k[0], jdim[1]] = hold_dict[k] @ top_left\\n # (K)\\n if not len(s01):\\n # check that we are not overwriting here\\n global_merge_dict[kdim] = top_right\\n else: # -> do the mm for all of the mult keys\\n for k in s01:\\n global_merge_dict[k[0], kdim[1]] = hold_dict[k] @ top_right\\n # (L)\\n if not len(s10):\\n # check that we are not overwriting here\\n global_merge_dict[ldim] = bottom_left\\n else: # -> do the mm for all of the mult keys\\n for k in s10:\\n global_merge_dict[k[0], ldim[1]] = hold_dict[k] @ bottom_left\\n # (M)\\n if not len(s11):\\n # check that we are not overwriting here\\n global_merge_dict[mdim] = bottom_right\\n else: # -> do the mm for all of the mult keys\\n for k in s11:\\n global_merge_dict[k[0], mdim[1]] = hold_dict[k] @ bottom_right\\n return global_merge_dict\",\n \"def mergeSortedArrays(nums1, m, nums2, n):\",\n \"def Split(ar, size):\\r\\n return [ar[i:i + size] for i in range(0, len(ar), size)]\",\n \"def creator(self, q, data, num_sub_proc):\\n for d in data:\\n idx = d[0]\\n q.put((idx, d[1]))\\n\\n for i in range(0, num_sub_proc):\\n q.put('DONE')\",\n \"def SplitQuery(self, request, context):\\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\",\n \"def qf_union(self, p, q):\\n\\n if self.qf_connected(p,q):\\n return True\\n\\n pid = self.id[p]\\n for i in range(len(self.id)):\\n if self.id[i] == pid:\\n self.id[i] = self.id[q]\\n return True\",\n \"def computeShingles(q, document):\\n shingles = []\\n for i in range(len(document) - q + 1):\\n shingle = \\\"\\\"\\n for j in range(i,i+q):\\n shingle += document[j]\\n shingles.append(shingle)\\n return shingles\",\n \"def merge(self, queue2):\\n with self.mutating:\\n self.queue = list(heapq.merge(self.queue, queue2))\\n heapq.heapify(self.queue)\",\n \"def split_sort_merge(items):\\n # TODO: Running time: ??? Why and under what conditions?\\n # TODO: Memory usage: ??? Why and under what conditions?\\n # Split items list into approximately equal halves\\n pivot = int(len(items)/2)\\n first_half = items[:pivot]\\n second_half = items[pivot:]\\n # TODO: Sort each half using any other sorting algorithm\\n while not is_sorted(first_half):\\n bubble_sort(first_half)\\n\\n while not is_sorted(second_half):\\n insertion_sort(second_half)\\n # TODO: Merge sorted halves into one list in sorted order\\n # Why does this mutate when we use list[:]\\n items[:] = merge(first_half,second_half)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6118815","0.58961606","0.5878436","0.57619405","0.5558039","0.5241369","0.5224264","0.5186988","0.5172165","0.51325655","0.5128098","0.51249146","0.51147157","0.5049574","0.5020555","0.49630874","0.49623552","0.49531335","0.49419618","0.48679426","0.4866867","0.48587304","0.48194954","0.48171285","0.48056814","0.48047736","0.4767098","0.47632438","0.4757625","0.474896","0.47456813","0.47388968","0.473482","0.470466","0.47029915","0.4696765","0.4689865","0.46675065","0.46637115","0.4663595","0.4659815","0.46587497","0.4654745","0.46377966","0.4629719","0.46271533","0.45955265","0.4591358","0.45903024","0.45883867","0.45847175","0.4575494","0.4575357","0.45736417","0.45728284","0.45656416","0.45582548","0.45532554","0.45298886","0.45298886","0.4526363","0.45203665","0.45133716","0.45120332","0.45087475","0.45070753","0.4503055","0.4492652","0.44876155","0.4487012","0.4482035","0.44750723","0.44730458","0.44725835","0.44672212","0.44646645","0.4457709","0.4457285","0.44550592","0.44522563","0.44512352","0.44505683","0.4446104","0.44458467","0.442816","0.44236472","0.44174814","0.44152138","0.44124228","0.44096884","0.44045216","0.44034466","0.43957055","0.43943036","0.4393423","0.43920016","0.4389707","0.43881887","0.43871635","0.4377353"],"string":"[\n \"0.6118815\",\n \"0.58961606\",\n \"0.5878436\",\n \"0.57619405\",\n \"0.5558039\",\n \"0.5241369\",\n \"0.5224264\",\n \"0.5186988\",\n \"0.5172165\",\n \"0.51325655\",\n \"0.5128098\",\n \"0.51249146\",\n \"0.51147157\",\n \"0.5049574\",\n \"0.5020555\",\n \"0.49630874\",\n \"0.49623552\",\n \"0.49531335\",\n \"0.49419618\",\n \"0.48679426\",\n \"0.4866867\",\n \"0.48587304\",\n \"0.48194954\",\n \"0.48171285\",\n \"0.48056814\",\n \"0.48047736\",\n \"0.4767098\",\n \"0.47632438\",\n \"0.4757625\",\n \"0.474896\",\n \"0.47456813\",\n \"0.47388968\",\n \"0.473482\",\n \"0.470466\",\n \"0.47029915\",\n \"0.4696765\",\n \"0.4689865\",\n \"0.46675065\",\n \"0.46637115\",\n \"0.4663595\",\n \"0.4659815\",\n \"0.46587497\",\n \"0.4654745\",\n \"0.46377966\",\n \"0.4629719\",\n \"0.46271533\",\n \"0.45955265\",\n \"0.4591358\",\n \"0.45903024\",\n \"0.45883867\",\n \"0.45847175\",\n \"0.4575494\",\n \"0.4575357\",\n \"0.45736417\",\n \"0.45728284\",\n \"0.45656416\",\n \"0.45582548\",\n \"0.45532554\",\n \"0.45298886\",\n \"0.45298886\",\n \"0.4526363\",\n \"0.45203665\",\n \"0.45133716\",\n \"0.45120332\",\n \"0.45087475\",\n \"0.45070753\",\n \"0.4503055\",\n \"0.4492652\",\n \"0.44876155\",\n \"0.4487012\",\n \"0.4482035\",\n \"0.44750723\",\n \"0.44730458\",\n \"0.44725835\",\n \"0.44672212\",\n \"0.44646645\",\n \"0.4457709\",\n \"0.4457285\",\n \"0.44550592\",\n \"0.44522563\",\n \"0.44512352\",\n \"0.44505683\",\n \"0.4446104\",\n \"0.44458467\",\n \"0.442816\",\n \"0.44236472\",\n \"0.44174814\",\n \"0.44152138\",\n \"0.44124228\",\n \"0.44096884\",\n \"0.44045216\",\n \"0.44034466\",\n \"0.43957055\",\n \"0.43943036\",\n \"0.4393423\",\n \"0.43920016\",\n \"0.4389707\",\n \"0.43881887\",\n \"0.43871635\",\n \"0.4377353\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5974006"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93492,"cells":{"query":{"kind":"string","value":"Sort array elements in A between p and r using mergesort."},"document":{"kind":"string","value":"def mergesort(A, p, r):\n if p < r:\n q = (p+r)//2\n mergesort(A, p, q)\n mergesort(A, q + 1, r)\n merge(A, p, q, r)"},"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 sort(self, A, index, p, r, rc_arr):\n\n if p < r:\n q = (p + r) // 2\n\n self.sort(A, index, p, q, rc_arr)\n self.sort(A, index, q + 1, r, rc_arr)\n self.merge(A, index, p, q, r, rc_arr)","def mergesort_ip(A, p, r):\n if p < r:\n q = (p+r)//2\n mergesort(A, p, q)\n mergesort(A, q + 1, r)\n merge_in_place(A, p, q, r)","def merge(A, p, q, r):\n\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\n n1 = q - p + 1 # will hold A[p..q]\n n2 = r - q # will hold A[q+1..r]\n\n L = [0] * (n1 + 1)\n R = [0] * (n2 + 1)\n \n for i in range(n1):\n L[i] = A[p+i]\n for j in range(n2):\n R[j] = A[q+j+1]\n\n # add sentinels\n L[n1] = float('inf')\n R[n2] = float('inf')\n\n # instead of sentinels, we can check if either L or R is empty,\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\n \n # indices of subarrays L and R (both already previously sorted)\n i = 0\n j = 0\n\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 1","def merge(arr, p, q, r):\r\n assist = np.zeros(r-p+1)\r\n s = p\r\n t = q+1\r\n k = 0\r\n while s<=q and t<=r:\r\n if arr[s] < arr[t]:\r\n assist[k] = arr[s]\r\n s = s+1\r\n else:\r\n assist[k] = arr[t]\r\n t = t+1\r\n k = k+1\r\n if s == q+1:\r\n assist[k:r-p+1] = arr[t:r+1]\r\n else:\r\n assist[k:r-p+1] = arr[s:q+1]\r\n return assist","def merge(A, p, q, r):\n left, right = [], []\n for i in range(p, q + 1):\n left.append(A[i])\n\n for j in range(q + 1, r + 1):\n right.append(A[j])\n\n i, j = 0, 0\n for k in range(p, r + 1):\n if i > q - p:\n A[k] = right[j]\n j += 1\n continue\n if j > r - q - 1:\n A[k] = left[i]\n i += 1\n continue\n\n if left[i] <= right[j]:\n A[k] = left[i]\n i += 1\n else:\n A[k] = right[j]\n j += 1","def merge(A, p, q, r):\n n_1 = q-p+1\n n_2 = r-q\n L = []\n R = []\n for i in range(n_1):\n L.append(A[p+i])\n for j in range(n_2):\n R.append(A[q+j+1])\n L.append(math.inf)\n R.append(math.inf)\n i = 0\n j = 0\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 1","def quick_sort(array, p, r):\n if p < r:\n # Partition array[p..r]\n q = partition(array, p, r)\n # Recursively call quick-sort on lower partition\n quick_sort(array, p, q - 1)\n # Recursively call quick-sort on upper partition\n quick_sort(array, q + 1, r)\n return array","def quicksort(A, p, r):\n if p < r:\n q = partition(A, p, r)\n quicksort(A, p, q-1)\n quicksort(A, q + 1, r)","def quickSort(array, p, r):\n if p < r:\n q = partition(array, p, r)\n quickSort(array,p, q-1)\n quickSort(array,q+1,r)","def merge(self, A, ind, p, q, r, rc_array):\n\n left = ind[p:q + 1]\n right = ind[q + 1:r + 1]\n\n i = 0\n j = 0\n ic = 0\n k = p\n\n while i < len(left) and j < len(right):\n if A[left[i]] > A[right[j]]:\n ind[k] = right[j]\n ic += 1\n k += 1\n j += 1\n else:\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n i += 1\n k += 1\n\n while i < len(left):\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n k += 1\n i += 1\n while j < len(right):\n ind[k] = right[j]\n k += 1\n j += 1","def insertionsortIndex(A:list, p:int, r:int) -> \"void\":\n\tfor i in range(p + 1, r + 1):\n\t\t\n\t\tkey = A[i]\n\t\tj = i - 1\n\n\t\twhile j >= p and key < A[j]:\n\t\t\tA[j+1] = A[j]\n\t\t\tj = j - 1\n\t\tA[j+1] = key","def merge_sort(array):\n length = len(array)\n if length < 2:\n return array\n middle = length//2\n left = Merge.merge_sort(array[:middle])\n right = Merge.merge_sort(array[middle:])\n return Merge.merge(left, right)","def merge_sort(data: List[Any]):\n if len(data) > 1:\n mid = len(data) // 2\n left = data[:mid]\n right = data[mid:]\n\n merge_sort(left)\n merge_sort(right)\n\n i = j = k = 0\n\n # Copy data to temp arrays L[] and R[]\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n data[k] = left[i]\n i += 1\n else:\n data[k] = right[j]\n j += 1\n k += 1\n\n # Checking if any element was left\n while i < len(left):\n data[k] = left[i]\n i += 1\n k += 1\n\n while j < len(right):\n data[k] = right[j]\n j += 1\n k += 1","def merge_sort (arr):\n n = len(arr)\n if n is 1: # Base case.\n return arr\n else:\n left = merge_sort(arr[0:int(floor(n/2))])\n right = merge_sort(arr[int(ceil(n/2)):])\n res = merge(left, right)\n return res","def quicksort_random(A, p, r):\n if p < r:\n q = partition_random(A, p, r)\n quicksort_random(A, p, q-1)\n quicksort_random(A, q + 1, r)","def mergesort(self, input_array):\n if len(input_array) > 1:\n mid = len(input_array)//2\n left = self.mergesort(input_array[:mid])\n right = self.mergesort(input_array[mid:])\n val = self.sort(left,right)\n return val\n return input_array","def quicksort(input_, p, r):\n if p < r:\n j = partition(input_, p, r)\n quicksort(input_, p, j - 1)\n quicksort(input_, j + 1, r )","def partition(array, p, r):\n # Choose pivot at end\n x = array[r]\n # Setup lower partition counter\n i = p - 1\n # For each element in array[p..r-1]\n for j in range(p, r):\n # If current item is leq than pivot\n if array[j] <= x:\n # Increment i anticipating a swap\n i += 1\n # Swap values at indices i and j in array\n array[i], array[j] = array[j], array[i]\n # Swap pivot with first element of upper sub-array, such that array[p..i] <= pivot <= array[i+2..r]\n array[i + 1], array[r] = array[r], array[i + 1]\n # Return index of pivot for further sorting\n return i + 1","def mergesort(array):\n if len(array) == 1:\n return array\n mid = len(array) // 2 # find the middle point of the array\n left = mergesort(array[:mid])\n right = mergesort(array[mid:])\n return merge(left, right)","def mergesort_iterative(array):\n n = len(array)\n result = array.copy()\n\n # Merge runs of length 1, 2, 4, 8, ...\n length = 1\n while length < n:\n # Merge each pair of runs\n for i in range(0, n, 2 * length):\n mid = i + length\n upper = i + 2 * length\n result[i:upper] = merge(result[i:mid], result[mid:upper])\n length *= 2\n\n return result","def merge_sort(arr):\n if len(arr) == 0 or len(arr) == 1:\n return arr\n start = 0\n end = len(arr)\n mid = start + (end - start) // 2\n left = merge_sort(arr[start:mid])\n right = merge_sort(arr[mid:end])\n return merge(left, right)","def mergesort(a):\n\n\n\n def merge(left,right):\n ll = len(left)\n lr = len(right)\n result = []\n i,j = 0,0\n while i < ll and j< lr:\n if left[i] <= right[j]:\n result.append(left[i])\n i+=1\n else:\n result.append(right[j])\n j+=1\n\n result += left[i:]\n result += right[j:]\n return result \n\n\n \n \n if len(a)<= 1:\n return a\n\n mid = len(a)//2\n left = mergesort(a[:mid])\n right = mergesort(a[mid:])\n return merge(left,right)","def merge_in_place(A, p, q, r):\n n_1 = q - p + 1\n n_2 = r - q\n L = 0\n R = 0\n for k in range(p, r+1):\n if A[p] <= A[q + 1]:\n A.insert(r+1, A[p])\n del A[p]\n L += 1\n q -= 1\n else:\n A.insert(r+1, A[q+1])\n del A[q+1]\n R += 1\n\n if L == n_1:\n A[r+1:r+1] = A[p:p+n_2-R]\n del A[p:p+n_2-R]\n break\n\n if R == n_2:\n A[r+1:r+1] = A[p:q+1]\n del A[p:q+1]\n break","def merge_sort(arr):\n if len(arr) <= 1:\n return arr\n mid = len(arr) // 2\n left = merge_sort(arr[:mid])\n right = merge_sort(arr[mid:])\n return merge(left,right)","def qsort(A, l, r):\n if l < r:\n q = partition(A, l, r)\n qsort(A, l, q-1)\n qsort(A, q+1, r)","def merge_sort(arr):\n n = len(arr)\n # Base case\n if n == 1:\n return arr\n # Recursive step: sort each half of the elements\n return merge(merge_sort(arr[:n//2]), merge_sort(arr[n//2:]))","def mergesort(array):\n if len(array) == 1:\n return array\n else:\n mid = len(array) // 2\n return _subsort(mergesort(array[mid:]), mergesort(array[:mid]))","def merge_sort(arr):\n if len(arr) <= 1:\n # nothing to sort\n return arr\n\n # split into left and right half\n left = arr[:len(arr) // 2]\n right = arr[len(arr) // 2:]\n\n # recursively sort each half\n left = merge_sort(left)\n right = merge_sort(right)\n\n # merge both sorted halves into a new array\n return merge(left, right)","def merge_sort(array):\n\n if len(array) <= 1: # base case\n return array\n\n # divide array in half and merge sort recursively\n half = len(array) // 2\n left = merge_sort(array[:half])\n right = merge_sort(array[half:])\n\n return merge(left, right)","def test_merge_sort(self):\n A = [5, 2, 4, 7, 1, 3, 2, 6]\n A_sorted = mst.merge_sort(A, 0, 8)\n self.assertEqual(A_sorted, [1, 2, 2, 3, 4, 5, 6, 7])","def merge_sort(arr):\n\n # Base Case: Array has more than one element.\n if len(arr) > 1:\n\n # Middle must not be float number .\n mid = len(arr) // 2\n\n # Dividing array into 2 halves. On Prime numbers right half will always\n # has greater number of elements by one element.\n left_half = arr[:mid]\n right_half = arr[mid:]\n\n print(f\"Current array is: {arr}\")\n print(f\" Left of the array: {left_half}\")\n print(f\" Right of the array: {right_half} \\n\")\n\n # Each function will keep recurse until array has one element left.\n merge_sort(left_half)\n merge_sort(right_half)\n\n i = j = k = 0\n\n # Copy data to two temporarily arrays left_half[] and right_half[]\n while i < len(left_half) and j < len(right_half):\n if left_half[i] < right_half[j]:\n arr[k] = left_half[i]\n i += 1\n else:\n arr[k] = right_half[j]\n j += 1\n k += 1\n\n # Eventually the above loop will break due the imbalance\n # e.g. False and True, and biggest number from either left or right half\n # will be remained without being added to the temporarily array.\n while i < len(left_half):\n arr[k] = left_half[i]\n i += 1\n k += 1\n\n while j < len(right_half):\n arr[k] = right_half[j]\n j += 1\n k += 1","def __merge_sort(ar,temp,low,high):\n if low == high:\n return\n\n # divide and conqure\n middle = (low+high)//2\n __merge_sort(ar,temp,low,middle)\n __merge_sort(ar,temp,middle+1,high)\n\n # combine\n index = leftindex = low\n rightindex = middle+1\n\n while leftindex <= middle and rightindex <= high:\n if ar[leftindex] < ar[rightindex]:\n temp[index] = ar[leftindex]\n leftindex += 1\n index += 1\n else:\n temp[index] = ar[rightindex]\n rightindex += 1\n index += 1\n\n while leftindex <= middle:\n temp[index] = ar[leftindex]\n index += 1\n leftindex +=1\n\n while rightindex <= high:\n temp[index] =ar[rightindex]\n index += 1\n rightindex +=1\n\n assert index == high+1\n\n # copy back\n for i in xrange(low,high+1):\n ar[i] = temp[i]","def partition(A:list, p:int, r:int) -> int:\n\n\tx = A[r]\n\ti = p - 1\n\tfor j in range(p, r):\n\t\tif A[j] <= x:\n\t\t\ti = i + 1\n\t\t\tA[i], A[j] = A[j], A[i]\n\tA[i+1], A[r] = A[r], A[i+1]\n\treturn i + 1","def merge_sort_algorithm(self, low, high):\n if low < high:\n mid = (low + high) / 2\n self.merge_sort_algorithm(low, mid)\n self.merge_sort_algorithm(mid+1, high)\n self.merge(low, high, mid)","def merge_sort(arr, start, end):\n if len(arr) <= 1:\n return\n if start >= end:\n return\n\n mid = int((start + end) / 2)\n merge_sort(arr, start, mid)\n merge_sort(arr, mid+1, end)\n merging(arr, start, mid, mid+1, end)","def partition(A, p, r):\n x = A[r]\n i = p\n for j in range(p, r):\n if A[j] <= x:\n A[i], A[j] = A[j], A[i]\n i += 1\n A[i], A[r] = A[r], A[i]\n return i","def merge_sort(self, data):\n print \"Splitting\", data\n if len(data) > 1:\n mid = len(data)// 2\n left_half = data[:mid]\n right_half = data[mid:]\n self.merge_sort(left_half)\n self.merge_sort(right_half)\n i,j,k = (0,0,0)\n while i< len(left_half) and j<len(right_half):\n if left_half[i] < right_half[j]:\n data[k] = left_half[i]\n i += 1\n else:\n data[k] = right_half[j]\n j += 1\n k += 1\n #take care of the unbalance\n while i < len(left_half):\n data[k] = left_half[i]\n i += 1\n k += 1\n while j < len(right_half):\n data[k] = right_half[j]\n j += 1\n k += 1\n print \"merging\", data","def sort(self, nums: List[int]) -> None:\n if len(nums) <= 1: return\n\n # Find the middle of the array\n mid = len(nums) // 2\n\n # Split the array elements into two halves\n left = nums[:mid]\n right = nums[mid:]\n\n # Sort the left half\n self.sort(left)\n\n # Sort the right half\n self.sort(right)\n\n # Merge the left and right arrays into the original array\n i = j = k = 0\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n nums[k] = left[i]\n i += 1\n else:\n nums[k] = right[j]\n j += 1\n k += 1\n\n # Add the remaining elements of the left array if any\n while i < len(left):\n nums[k] = left[i]\n i += 1\n k += 1\n\n # Add the remaining elements of the right array if any\n while j < len(right):\n nums[k] = right[j]\n j += 1\n k += 1","def test_20el_sorted_array(self):\n res = merge_sort([1, 2, 3, 4, 5, 6, 7, 8, 9,\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])","def sort(self, left_arr, right_arr):\n sorted_array = []\n left_ind, right_ind = 0,0\n while left_ind < len(left_arr) and right_ind < len(right_arr):\n if left_arr[left_ind] < right_arr[right_ind]:\n sorted_array.append(left_arr[left_ind])\n left_ind += 1\n else: \n sorted_array.append(right_arr[right_ind])\n right_ind += 1\n if left_ind == len(left_arr):\n sorted_array.extend(right_arr[right_ind:])\n else:\n sorted_array.extend(left_arr[left_ind:])\n return sorted_array","def partition_random(A, p, r):\n n = random.randint(p, r)\n A[n], A[r] = A[r], A[n]\n x = A[r]\n i = p-1\n for j in range(p, r):\n if A[j] <= x:\n i += 1\n A[i], A[j] = A[j], A[i]\n A[i+1], A[r] = A[r], A[i+1]\n return i+1","def mergesort(arr):\n if type(arr) is not list:\n raise TypeError('argument must be list of integers')\n\n if len(arr) <= 1:\n return arr \n\n def recurse(arr):\n half = len(arr)//2\n left = []\n right = []\n\n for i in range(half):\n left = left + [arr[i]]\n right = right + [arr[len(arr) - 1 - i]]\n # print('split', left, right)\n if len(left) > 1:\n left = recurse(left)\n if len(right) > 1:\n right = recurse(right)\n \n return merge(left, right) \n \n def merge(left, right):\n output = []\n i = 0\n j = 0\n while i < len(left) and j < len(right):\n if left[i] <= right[j]:\n output.append(left[i])\n i = i + 1\n elif left[i] >= right[j]:\n output.append(right[j])\n j = j + 1\n # print('merging', left, right, '=>', output)\n output.extend(left[i:])\n output.extend(right[j:])\n\n # print('merged', output, '\\n')\n return output\n\n return recurse(arr)","def mergesort_iterative_hybrid(array, threshold=37):\n n = len(array)\n result = array.copy()\n\n # Initial insertion sort pass\n for i in range(0, n, threshold):\n result[i:i+threshold] = insertion_sort(result[i:i+threshold])\n\n # Merge runs of length threshold, 2*threshold, ...\n length = threshold\n while length < n:\n # Merge each pair of runs\n for i in range(0, n, 2 * length):\n mid = i + length\n upper = i + 2 * length\n result[i:upper] = merge(result[i:mid], result[mid:upper])\n length *= 2\n\n return result","def custom_sort(arr):\n pass","def mergesort_recursive_hybrid(array, threshold=37):\n # Base case delegates to insertion sort\n n = len(array)\n if n <= threshold:\n return insertion_sort(array)\n\n # Recur on two halves of array and merge results\n mid = n // 2\n return merge(\n mergesort_recursive(array[:mid]),\n mergesort_recursive(array[mid:]))","def merge(l, r):\n print(\"merge [l={}, r={}]\".format(l, r))\n t = [None] * (len(l) + len(r))\n ti = 0\n \n i, j = 0, 0\n\n while i < len(l) and j < len(r):\n if l[i] <= r[j]:\n t[ti] = l[i]\n i += 1\n else:\n t[ti] = r[j]\n j += 1\n ti += 1\n\n # copy remaining items from one of either l or r...\n if i < len(l):\n while i < len(l):\n t[ti] = l[i]\n i += 1\n ti += 1\n else:\n while j < len(r):\n t[ti] = r[j]\n j+= 1\n ti += 1\n\n return t","def merge_sort(arr):\r\n if len(arr) == 1:\r\n return arr\r\n middle = len(arr) // 2\r\n first_half = merge_sort(arr[:middle])\r\n second_half = merge_sort(arr[middle:])\r\n return merge(first_half, second_half)","def random_qsort(A, l, r):\n if l < r:\n q = random_partition(A, l, r)\n random_qsort(A, l, q-1)\n random_qsort(A, q+1, r)","def mergesort(arr):\n len_arr = len(arr)\n if len_arr <= 1:\n return arr\n\n middle = len_arr / 2\n front = mergesort(arr[:middle])\n back = mergesort(arr[middle:])\n\n return merge(front, back)","def sort(self, nums: List[int]) -> None:\n\n # Start at the 2nd element in the array\n for i in range(1, len(nums)):\n\n # Set the key to the beginning of the unsorted subarray\n key = nums[i]\n\n # Set a pointer to the end of the sorted subarray\n j = i-1\n\n # Shift elements in the sorted array to the right as needed\n # until the correct position for the key is found\n while j >= 0 and key < nums[j]:\n nums[j+1] = nums[j]\n j -= 1\n\n # Set the key to the found position\n nums[j+1] = key","def merge_sort (t,cmp):\n n = len(t)\n if n <= 1:\n # cas de base\n return copy.deepcopy(t)\n else:\n # cas general\n t1 = merge_sort((t[0:((n-1)//2+1)]),cmp)\n t2 = merge_sort((t[((n-1)//2+1):n]),cmp)\n return merge(t1,t2,cmp)","def mergeSortedArrays(nums1, m, nums2, n):","def qsort(array, left, right):\n if left < right:\n p_ind_new = partition(array, left, right)\n qsort(array, left, p_ind_new-1)\n qsort(array, p_ind_new+1, right)","def mergesort(arr1, option):\n length = len(arr1)\n if length < 2:\n return arr1\n # make a copy, since mergesort needs O(n) space\n arr2 = arr1[:]\n step = 1\n while step < length:\n i, curr = 0, 0 # beginning of each pair, current write point\n while i + step < length:\n left, right = i, i + step\n while curr < length and curr < i + 2 * step:\n if right == length or right == i + 2 * step:\n arr2[curr] = arr1[left]\n left += 1\n elif left == i + step:\n arr2[curr] = arr1[right]\n right += 1\n elif arr1[left] <= arr1[right]:\n arr2[curr] = arr1[left]\n left += 1\n elif arr1[left] > arr1[right]:\n arr2[curr] = arr1[right]\n right += 1\n curr += 1\n i += 2 * step\n # important: copy the untouched end to the new array. It's not applied yet\n while curr < length:\n arr2[curr] = arr1[curr]\n curr += 1\n step *= 2\n # swap two arrays for cost efficiency\n arr1, arr2 = arr2, arr1\n return arr1","def merge_sort(L):\n n = len(L)\n if n < 2:\n return L\n mid = n // 2\n left = L[:mid]\n right = L[mid:]\n merge_sort(left)\n merge_sort(right)\n merge(L, left, right)","def quicksortSimple(A:list, p:int, r:int) -> \"void\":\n\n\ttamanoSecuencia = r - p + 1\n\n\tif tamanoSecuencia <= 32 and p < r:\t\n\t\tinsertionsortIndex(A, p, r)\n\n\n\telif tamanoSecuencia > 32 and p < r:\n\t\tq = partition(A, p, r)\t\n\t\tquicksortSimple(A, p, q-1)\n\t\tquicksortSimple(A, q+1, r)\n\n\t# Para usarse se llama: quickSort(arreglo, 0, len(arreglo) - 1)","def merge_sort(array: list):\n\n # check if the list is not empty and is greater than one element\n if len(array) > 1:\n # get the middle of the list, do an integer division, we don't need decimals\n # assign a left part and a right part\n middle = len(array) // 2\n left_half = array[:middle]\n right_half = array[middle:]\n\n # call merge_sort recursively to keep dividing the list\n merge_sort(left_half)\n merge_sort(right_half)\n\n i = 0 # used to track left half of the list\n j = 0 # used to track right side of the list\n k = 0 # used to track the array itself\n\n # merge both left and right part of the list\n while i < len(left_half) and j < len(right_half):\n if left_half[i] <= right_half[j]:\n array[k] = left_half[i]\n i += 1\n else:\n array[k] = right_half[j]\n j += 1\n k += 1\n\n # merge the left half in an ordered fashion\n while i < len(left_half):\n array[k] = left_half[i]\n i += 1\n k += 1\n\n # merge the right half in an ordered fashion\n while j < len(right_half):\n array[k] = right_half[j]\n j += 1\n k += 1\n\n return array","def merge_sort(nums):\n\n if len(nums) == 1:\n return nums\n\n mid = len(nums)/2 \n left_part = merge_sort(nums[:mid]) \n right_part = merge_sort(nums[mid:]) \n merged = merge(left_part,right_part) \n return merged","def merge_sort(a_list):\n\n if len(a_list) > 1:\n mid = len(a_list) // 2\n left_half = a_list[:mid]\n right_half = a_list[mid:]\n\n merge_sort(left_half)\n merge_sort(right_half)\n\n i = 0\n j = 0\n k = 0\n while i < len(left_half) and j < len(right_half):\n if left_half[i] < right_half[j]:\n a_list[k] = left_half[i]\n i += 1\n else:\n a_list[k] = right_half[j]\n j += 1\n k += 1\n\n while i < len(left_half):\n a_list[k] = left_half[i]\n i += 1\n k += 1\n\n while j < len(right_half):\n a_list[k] = right_half[j]\n j += 1\n k += 1\n return a_list","def merge_sort(arr: list, start: int, end: int):\n if end == start:\n return [arr[start]]\n else:\n mid = start + (end - start)//2\n left = merge_sort(arr, start, mid)\n right = merge_sort(arr, mid+1, end)\n sorted_arr = merge(left, right)\n return sorted_arr","def merge_sort(aList):\n\n n = len(aList)\n\n # Check for base case\n if n <= 1:\n return aList\n\n # Split the list into two halves and call recursively\n first = merge_sort(aList[0:int(n/2)])\n\n second = merge_sort(aList[int(n/2):n])\n\n #pdb.set_trace()\n\n # Perform Merge of two sorted lists\n # Initialize counters, lengths and the newly sorted array\n i, j = 0, 0\n firstLen = len(first)\n secondLen = len(second)\n\n sortedList = []\n\n # Populate the sorted list with the lesser of each half-list\n for k in range(n):\n\n # Make sure we won't try to access past the end of a list\n # If we've reached the end of the first array, then\n # add the element from the second array.\n if i == firstLen:\n sortedList.append(second[j])\n j += 1\n\n # If we've reached the end of the second array, add\n # the element from the first array\n elif j == secondLen:\n sortedList.append(first[i])\n i += 1\n\n # The normal case (before we've reached the end of either array)\n elif first[i] < second[j]:\n sortedList.append(first[i])\n i += 1\n\n else:\n sortedList.append(second[j])\n j += 1\n\n\n return sortedList","def merge(A, left, middle, right):\n leftSubArray = A[left:middle]\n rightSubArray = A[middle:right+1]\n leftSubArray.append(float(\"inf\"))\n rightSubArray.append(float(\"inf\"))\n i = j = 0\n for k in xrange(left, right + 1):\n if leftSubArray[i] < rightSubArray[j]:\n A[k] = leftSubArray[i]\n i += 1\n else:\n A[k] = rightSubArray[j]\n j += 1\n return A","def test_20el_shuffled_array(self):\n res = merge_sort([2, 11, 17, 16, 14, 19, 15, 9, 12,\n 5, 1, 18, 4, 20, 7, 3, 8, 10, 13, 6])\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])","def _quicksort(self, l, r):\n\t\tif l < r:\n\t\t\tsplitpoint = self._partition(l, r)\n\t\t\tself._quicksort(l, splitpoint-1)\n\t\t\tself._quicksort(splitpoint+1, r)","def merge_sort(data):\r\n\r\n if not data or len(data) == 1:\r\n # return if list size is 0 or 1\r\n return data\r\n else:\r\n # split data list in half\r\n middle = int(len(data) / 2)\r\n a = merge_sort(data[:middle])\r\n b = merge_sort(data[middle:])\r\n # user merge function to merge the two halves\r\n # back together while also sorting them\r\n return merge(a, b)","def sort(arr, filename):\n if len(arr) > 1:\n mid = len(arr) // 2 # Finding the mid of the array\n L = arr[:mid] # Dividing the array elements\n R = arr[mid:] # into 2 halves\n sort(L, filename) # Sorting the first half\n sort(R, filename) # Sorting the second half\n\n i = j = k = 0\n\n # Copy data to temp arrays L[] and R[]\n while i < len(L) and j < len(R):\n if L[i] < R[j]:\n arr[k] = L[i]\n i += 1\n else:\n arr[k] = R[j]\n j += 1\n k += 1\n\n # Checking if any element was left\n while i < len(L):\n arr[k] = L[i]\n i += 1\n k += 1\n\n while j < len(R):\n arr[k] = R[j]\n j += 1\n k += 1\n with open(\"output/temp/\" + filename, \"w\") as file:\n for item in arr:\n file.write('%s\\n' % item)","def merge_sort(items, key):\n # Check endcase\n if (len(items) / 2) > 1:\n global COMPARE\n # Pivot point/middle\n pivot = int(len(items) / 2)\n # Recursive call\n left = merge_sort(items[0:pivot], key)\n right = merge_sort(items[pivot:len(items)], key)\n # Init the variables\n l_index = r_index = 0\n merged = []\n # Merging\n while (l_index < len(left)) and (r_index < len(right)):\n # If right index is larger, append left[index]; increase l. index\n if COMPARE(right[r_index], left[l_index]):\n merged.append(left[l_index])\n l_index += 1\n # If left index is larger, append right[index]; increase r. index\n elif COMPARE(left[l_index], right[r_index]):\n merged.append(right[r_index])\n r_index += 1\n # Add remaining merge\n if(l_index == len(left)):\n merged.extend(right[r_index:])\n elif(r_index == len(left)):\n merged.extend(left[l_index:])\n # Return list\n return merged\n else:\n # End of the line!\n return bubble_sort(items, key)","def mergesort_recursive(array):\n # Base case for empty or singular list\n n = len(array)\n if n < 2:\n return array\n\n # Recur on two halves of array and merge results\n mid = n // 2\n return merge(\n mergesort_recursive(array[:mid]),\n mergesort_recursive(array[mid:]))","def merge_sort(a, b):\n l = []\n while a and b:\n if a[0] < b[0]:\n l.append(a.pop(0))\n else:\n l.append(b.pop(0))\n return l + a + b","def sort(self, nums: List[int]) -> None:\n n = len(nums)\n for i in range(n):\n\n # Set the lowest to the beginning of the unsorted subarray\n low = i\n for j in range(i+1,n):\n\n # Find the lowest in the unsorted array\n if nums[j] < nums[low]:\n low = j\n \n # Swap the beginning of the unsorted subarray and the lowest.\n # The beginning of the unsorted subarray now becomes the end of the sorted subarray\n nums[i], nums[low] = nums[low], nums[i]","def dualPivotQuicksort(A:list, left:int, right:int) -> \"void\":\n\n\tif right - left <= 32:\t\t\n\t\tinsertionsortIndex(A, left, right)\n\telse:\n\t\tif A[left] > A[right]:\n\t\t\tp, q = A[right], A[left]\n\t\telse:\n\t\t\tp, q = A[left], A[right]\n\t\tl, g = left + 1, right - 1\n\t\tk = l\n\n\t\twhile k <= g:\n\t\t\tif A[k] < p:\n\t\t\t\tA[k], A[l] = A[l], A[k]\n\t\t\t\tl = l + 1\n\t\t\telse:\n\t\t\t\tif A[k] >= q:\n\n\t\t\t\t\twhile A[g] > q and k < g:\n\t\t\t\t\t\tg = g - 1\n\n\t\t\t\t\tif A[g] >= p:\n\t\t\t\t\t\tA[k], A[g] = A[g], A[k]\n\t\t\t\t\telse:\n\t\t\t\t\t\tA[k], A[g] = A[g], A[k]\n\t\t\t\t\t\tA[k], A[l] = A[l], A[k]\n\t\t\t\t\t\tl = l + 1\n\n\t\t\t\t\tg = g - 1\t\t\t\t\t\n\t\t\tk = k + 1\n\n\t\tl = l - 1\n\t\tg = g + 1\n\t\tA[left] = A[l]\n\t\tA[l] = p\n\t\tA[right] = A[g]\n\t\tA[g] = q\n\t\tdualPivotQuicksort(A, left, l-1)\n\t\tdualPivotQuicksort(A, l+1, g-1)\n\t\tdualPivotQuicksort(A, g+1, right)\n\n\t\t# Debe llamarse con: dualPivotQuicksort(A, 0, len(A)-1)","def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\n # # solution one: sort\n # A[m:] = B\n # A.sort()\n\n # solution two: two point\n if n == 0: # B = []\n return\n i, j, k = m - 1, n - 1, m + n - 1\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\n if A[i] <= B[j]:\n A[k] = B[j]\n k -= 1\n j -= 1\n else:\n A[k] = A[i]\n k -= 1\n i -= 1\n if j > -1:\n A[:j + 1] = B[:j + 1] # A = [], B = [1]","def mergesort(sequence):\n\tif len(sequence) <= 1:\n\t\treturn sequence\n\n\tmiddle_index = len(sequence) // 2\n\tleft_half = mergesort(sequence[:middle_index])\n\tright_half = mergesort(sequence[middle_index:])\n\n\treturn merge(left_half, right_half)","def merge_sort(S):\n n = len(S)\n if n < 2:\n return\n\n # devide\n mid = n//2\n S1 = S[0:mid]\n S2 = S[mid:n]\n\n # conquer\n merge_sort(S1)\n merge_sort(S2)\n\n # merge results\n i = j = 0\n while i + j < len(S):\n if j == len(S2) or (i < len(S1) and S1[i] < S2[j]):\n S[i + j] = S1[i]\n i += 1\n else:\n S[i + j] = S2[j]\n j += 1","def merge_sort(S):\n n = len(S)\n if n < 2:\n return\n mid = n // 2\n S1 = S[0:mid]\n S2 = S[mid:n]\n merge_sort(S1)\n merge_sort(S2)\n merge(S1, S2, S)","def merge_sort(alist):\n print(\"Splitting \", alist)\n # Temporary list to store sorted list\n work = [None] * len(alist)\n rec_merge_sort(work, start=0, end=len(alist)-1)","def merge(array, left, middle, right):\n\n len1 = middle - left + 1\n len2 = right - middle\n\n left_side = array[left: left + len1]\n right_side = array[middle + 1: middle + len2 + 1]\n\n i = j = 0\n k = left\n\n while i < len1 and j < len2:\n if left_side[i] <= right_side[j]:\n array[k] = left_side[i]\n i += 1\n else:\n array[k] = right_side[j]\n j += 1\n\n k += 1\n\n while i < len1:\n array[k] = left_side[i]\n i += 1\n k += 1\n\n while j < len2:\n array[k] = right_side[j]\n j += 1\n k += 1","def mergesort(T:list) -> \"void\":\n\n\tif len(T) <= 32:\n\t\tinsertionsort(T)\n\n\telse:\n\t\tU = T[0:len(T)//2]\n\t\tV = T[len(T)//2:len(T)]\n\t\tmergesort(U)\n\t\tmergesort(V)\n\t\tmerge(U, V, T)","def merge_sort(aList):\n #If the aList is size 0 or 1, it's already sorted.\n if len(aList) <= 1:\n return aList\n\n else:\n mid = len(aList) // 2\n\n # Recursively sort the left and right halves\n left = merge_sort(aList[:mid])\n right = merge_sort(aList[mid:])\n \n # Merge the two (each sorted) parts back together\n return merge(left, right)","def mergeunsort(arr, inv_seq):\n\tif len(arr) <= 1:\n\t\treturn list(arr)\n\tcut_idx = (len(arr) + 1) / 2\n\tleft = arr[:cut_idx]\n\tright = arr[cut_idx:]\n\tleft = mergeinvert(left, inv_seq)\n\tright = mergeinvert(right, inv_seq)\n\treturn invert_merge(left, right, inv_seq)","def _merge(arr, temp, left, mid, right):\n i = left\n j = mid\n k = left\n inv_count = 0\n while i < mid and j <= right:\n if arr[i] < arr[j]:\n temp[k] = arr[i]\n k += 1\n i += 1\n else:\n temp[k] = arr[j]\n k += 1\n j += 1\n inv_count += (mid -i)\n while i < mid:\n temp[k] = arr[i]\n k += 1\n i += 1\n if j <= right:\n k += right - j + 1\n j += right - j + 1\n arr[left:k + 1] = temp[left:k + 1]\n else:\n arr[left:right + 1] = temp[left:right + 1]\n return inv_count","def merge_two(l, r):\n new = []\n i1, i2 = 0, 0\n while i1 != len(l) and i2 != len(r):\n if l[i1] < r[i2]:\n new.append(l[i1])\n i1 += 1\n else:\n new.append(r[i2])\n i2 += 1\n\n new.extend(l[i1:])\n new.extend(r[i2:])\n return new","def merge_sort(items):\r\n # TODO: Check if list is so small it's already sorted (base case)\r\n # TODO: Split items list into approximately equal halves\r\n # TODO: Sort each half by recursively calling merge sort\r\n # TODO: Merge sorted halves into one list in sorted order\r","def merge_sort(input_list,start,end):\n if start < end:\n mid=(start+end)//2\n merge_sort(input_list,start,mid)\n merge_sort(input_list,mid+1,end)\n return merge(input_list,start,mid,end)","def merging(arr, s1, e1, s2, e2):\n p1 = s1\n p2 = s2\n tmp = [0 for _ in range(len(arr))]\n idx = s1\n\n while p1 <= e1 and p2 <= e2:\n if arr[p1] < arr[p2]:\n tmp[idx] = arr[p1]\n idx += 1\n p1 += 1\n else:\n tmp[idx] = arr[p2]\n idx += 1\n p2 += 1\n\n if p1 <= e1:\n for i in range(p1, e1+1):\n tmp[idx] = arr[p1]\n idx += 1\n p1 += 1\n else:\n for i in range(p2, e2+1):\n tmp[idx] = arr[p2]\n idx += 1\n p2 += 1\n\n for i in range(s1, e2+1):\n arr[i] = tmp[i]\n\n # done","def merge (left, right):\n i = 0\n j = 0\n n = len(left)\n m = len(right)\n out = []\n\n while i < n and j < m:\n if left[i] < right[j]:\n out.append(left[i])\n i += 1\n else:\n out.append(right[j])\n j += 1\n\n if i is n:\n for l in xrange(j, m):\n out.append(right[l])\n elif j is m:\n for l in xrange(i, n):\n out.append(left[l])\n\n return out","def mergesort(x):\n\n if len(x) == 0 or len(x) == 1:\n return x\n else:\n middle = int(len(x)/2)\n a = mergesort(x[:middle])\n b = mergesort(x[middle:])\n return merge(a,b)","def merge(nums1, m, nums2, n):\r\n if not nums2:\r\n return\r\n\r\n while m > 0 and n > 0:\r\n # the current element of the final sorted array is the smaller of nums2[n -1] and nums1[m - 1]\r\n if nums2[n - 1] < nums1[m - 1]:\r\n nums1[m + n - 1] = nums1[m - 1]\r\n m -= 1\r\n else:\r\n nums1[m + n - 1] = nums2[n - 1]\r\n n -= 1\r\n nums1[:n] = nums2[:n]","def RInsertionSort(array):\n\n if not isinstance(array, np.ndarray):\n raise TypeError('_container is not ndarray') \n\n # Get array\n n = len(array)\n fhelper(array, 1, n)","def sort_by_polar_angle_v2(pts):\n\n\t### make a copy of points array to avoid corruption\n\t### of original points array\n\tcopy_pts = []\n\tfor each in pts:\n\t\tif each not in copy_pts:\n\t\t\tcopy_pts.append(each)\n\n\tP0_idx = copy_pts.index(P0)\n\tdel copy_pts[P0_idx]\n\n\n\t# Call polar_angle function to calculate polar angle\n\t# of points with respect to P0\n\tp =polar_angle(copy_pts)\n\t\n\n\t#########For sorting polar angle array ######\n\t# Once we get the polar angle array, we use numpy.argsort\n\t# to get the indices of sorted polar angle array\n\t# using the indices serves two purpose\n\t# 1. Sort polar angle array\n\t# 2. Sort list of points array \n\t# 3. Develop logic to take farthest point in case of\n\t# collinear\n\n\tnp_p = np.asarray(p)\t\n\tsorted_idx = np.argsort(np_p,kind='mergesort')\n\n\n\t# Do steps 1. and 2. of above commented logic\n\tsorted_p = []\n\tsorted_pts = []\n\tfor each in sorted_idx:\n\t\tsorted_p.append(p[each])\n\t\tsorted_pts.append(copy_pts[each])\n\n\t# Code for step 3.\n\tcheck_dict = {}\n\tfor i in range(len(sorted_p)-1):\n\t\tfor j in range(i+1,len(sorted_p)):\n\t\t\tif sorted_p[j] == sorted_p[i]:\n\t\t\t\tif sorted_p[i] not in check_dict:\n\t\t\t\t\ttemp_list=[]\n\t\t\t\t\ttemp_list.append(sorted_pts[i])\n\t\t\t\t\tcheck_dict[sorted_p[i]]=temp_list\n\t\t\t\ttemp_list2 = []\n\t\t\t\ttemp_list2 = check_dict[sorted_p[i]]\n\t\t\t\tif sorted_pts[j] not in temp_list2:\n\t\t\t\t\ttemp_list2.append(sorted_pts[j])\n\t\t\t\t\tcheck_dict[sorted_p[i]]=temp_list2\n\t\t\t\tif sorted_pts[j] in temp_list2:\n\t\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tbreak\n\n\n\tfor dict_val in check_dict.values():\n\n\t\tfarthest_pt = dict_val[0]\n\t\tmax_dist = euclidean_distance_v2(farthest_pt,P0)\n\n\t\tfor each in dict_val[1:]:\n\n\t\t\tif euclidean_distance_v2(each,P0) > max_dist:\n\t\t\t\tsorted_pts = [x for x in sorted_pts if x!=farthest_pt]\n\t\t\t\tmax_dist = euclidean_distance_v2(each,P0)\n\t\t\t\tfarthest_pt = each\n\t\t\tif euclidean_distance_v2(each,P0) < max_dist:\n\t\t\t\tsorted_pts = [x for x in sorted_pts if x!=each]\n\n\n\treturn sorted_pts","def bottom_up_merge_sort(items):\n subarray_size = 1\n\n while subarray_size < len(items)//2:\n ## Continue making passes through items until the subarray size is\n ## the size of items, since this means items is finally sorted.\n for i in range(0, len(items), subarray_size):\n merge(items, i, i+subarray_size*2, subarray_size)\n subarray_size *= 2","def merge(arr1,arr2,n,m) :\n gap = n + m\n\n while gap > 1 :\n\n gap = (gap // 2) + (gap % 2)\n \n i = 0\n while (i + gap) <= (n+m-1) :\n if i < n and (i+gap) < n :\n if arr1[i] > arr1[i+gap] :\n arr1[i], arr1[i+gap] = arr1[i+gap], arr1[i]\n elif i < n and (i + gap) >= n :\n if arr1[i] > arr2[i+gap-n] :\n arr1[i], arr2[i+gap-n] = arr2[i+gap-n], arr1[i]\n elif i >= n :\n if arr2[i-n] > arr2[i+gap-n] :\n arr2[i-n], arr2[i+gap-n] = arr2[i+gap-n], arr2[i-n]\n i += 1","def heap_sort(self, A):\n pass","def heap_sort(self, A):\n pass","def merge_sort(list):\n\n\tif len(list) <= 1:\n\t\treturn list\n\n\tleft_half, right_half = split(list)\n\tleft = merge_sort(left_half)\n\tright = merge_sort(right_half)\n\n\treturn merge(left, right)","def merge_sort(list):\n # Base Condition\n if len(list) <= 1:\n return list\n\n left_half, right_half = split(list)\n left = merge_sort(left_half)\n right = merge_sort(right_half)\n\n return merge(left,right)","def merge_sort(list):\r\n \r\n if len(list) <= 1:\r\n return list\r\n \r\n left_half, right_half = split(list)\r\n left = merge_sort(left_half)\r\n right = merge_sort(right_half)\r\n \r\n return merge(left, right)","def mergeSort(sequence):\n if len(sequence) <= 1:\n return sequence\n\n mid = len(sequence) // 2\n left = mergeSort(sequence[:mid])\n right = mergeSort(sequence[mid:])\n result = mergeSeq(left, right)\n return result","def test_three_split():\n run_mergesort([3, 0, 3], [0, 3, 3])","def merge_sort(items):\n if len(items) >1:\n mid = len(items)//2\n left = items[:mid]\n right = items[mid:]\n\n merge_sort(left)\n merge_sort(right)\n\n i = j = k = 0\n\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n items[k] = left[i]\n i+=1\n else:\n items[k] = right[j]\n j+=1\n k+=1\n\n while i < len(left):\n items[k] = left[i]\n i+=1\n k+=1\n\n while j < len(right):\n items[k] = right[j]\n j+=1\n k+=1\n\n return items"],"string":"[\n \"def sort(self, A, index, p, r, rc_arr):\\n\\n if p < r:\\n q = (p + r) // 2\\n\\n self.sort(A, index, p, q, rc_arr)\\n self.sort(A, index, q + 1, r, rc_arr)\\n self.merge(A, index, p, q, r, rc_arr)\",\n \"def mergesort_ip(A, p, r):\\n if p < r:\\n q = (p+r)//2\\n mergesort(A, p, q)\\n mergesort(A, q + 1, r)\\n merge_in_place(A, p, q, r)\",\n \"def merge(A, p, q, r):\\n\\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\\n n1 = q - p + 1 # will hold A[p..q]\\n n2 = r - q # will hold A[q+1..r]\\n\\n L = [0] * (n1 + 1)\\n R = [0] * (n2 + 1)\\n \\n for i in range(n1):\\n L[i] = A[p+i]\\n for j in range(n2):\\n R[j] = A[q+j+1]\\n\\n # add sentinels\\n L[n1] = float('inf')\\n R[n2] = float('inf')\\n\\n # instead of sentinels, we can check if either L or R is empty,\\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\\n \\n # indices of subarrays L and R (both already previously sorted)\\n i = 0\\n j = 0\\n\\n for k in range(p, r+1):\\n if L[i] <= R[j]:\\n A[k] = L[i]\\n i += 1\\n else:\\n A[k] = R[j]\\n j += 1\",\n \"def merge(arr, p, q, r):\\r\\n assist = np.zeros(r-p+1)\\r\\n s = p\\r\\n t = q+1\\r\\n k = 0\\r\\n while s<=q and t<=r:\\r\\n if arr[s] < arr[t]:\\r\\n assist[k] = arr[s]\\r\\n s = s+1\\r\\n else:\\r\\n assist[k] = arr[t]\\r\\n t = t+1\\r\\n k = k+1\\r\\n if s == q+1:\\r\\n assist[k:r-p+1] = arr[t:r+1]\\r\\n else:\\r\\n assist[k:r-p+1] = arr[s:q+1]\\r\\n return assist\",\n \"def merge(A, p, q, r):\\n left, right = [], []\\n for i in range(p, q + 1):\\n left.append(A[i])\\n\\n for j in range(q + 1, r + 1):\\n right.append(A[j])\\n\\n i, j = 0, 0\\n for k in range(p, r + 1):\\n if i > q - p:\\n A[k] = right[j]\\n j += 1\\n continue\\n if j > r - q - 1:\\n A[k] = left[i]\\n i += 1\\n continue\\n\\n if left[i] <= right[j]:\\n A[k] = left[i]\\n i += 1\\n else:\\n A[k] = right[j]\\n j += 1\",\n \"def merge(A, p, q, r):\\n n_1 = q-p+1\\n n_2 = r-q\\n L = []\\n R = []\\n for i in range(n_1):\\n L.append(A[p+i])\\n for j in range(n_2):\\n R.append(A[q+j+1])\\n L.append(math.inf)\\n R.append(math.inf)\\n i = 0\\n j = 0\\n for k in range(p, r+1):\\n if L[i] <= R[j]:\\n A[k] = L[i]\\n i += 1\\n else:\\n A[k] = R[j]\\n j += 1\",\n \"def quick_sort(array, p, r):\\n if p < r:\\n # Partition array[p..r]\\n q = partition(array, p, r)\\n # Recursively call quick-sort on lower partition\\n quick_sort(array, p, q - 1)\\n # Recursively call quick-sort on upper partition\\n quick_sort(array, q + 1, r)\\n return array\",\n \"def quicksort(A, p, r):\\n if p < r:\\n q = partition(A, p, r)\\n quicksort(A, p, q-1)\\n quicksort(A, q + 1, r)\",\n \"def quickSort(array, p, r):\\n if p < r:\\n q = partition(array, p, r)\\n quickSort(array,p, q-1)\\n quickSort(array,q+1,r)\",\n \"def merge(self, A, ind, p, q, r, rc_array):\\n\\n left = ind[p:q + 1]\\n right = ind[q + 1:r + 1]\\n\\n i = 0\\n j = 0\\n ic = 0\\n k = p\\n\\n while i < len(left) and j < len(right):\\n if A[left[i]] > A[right[j]]:\\n ind[k] = right[j]\\n ic += 1\\n k += 1\\n j += 1\\n else:\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n i += 1\\n k += 1\\n\\n while i < len(left):\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n k += 1\\n i += 1\\n while j < len(right):\\n ind[k] = right[j]\\n k += 1\\n j += 1\",\n \"def insertionsortIndex(A:list, p:int, r:int) -> \\\"void\\\":\\n\\tfor i in range(p + 1, r + 1):\\n\\t\\t\\n\\t\\tkey = A[i]\\n\\t\\tj = i - 1\\n\\n\\t\\twhile j >= p and key < A[j]:\\n\\t\\t\\tA[j+1] = A[j]\\n\\t\\t\\tj = j - 1\\n\\t\\tA[j+1] = key\",\n \"def merge_sort(array):\\n length = len(array)\\n if length < 2:\\n return array\\n middle = length//2\\n left = Merge.merge_sort(array[:middle])\\n right = Merge.merge_sort(array[middle:])\\n return Merge.merge(left, right)\",\n \"def merge_sort(data: List[Any]):\\n if len(data) > 1:\\n mid = len(data) // 2\\n left = data[:mid]\\n right = data[mid:]\\n\\n merge_sort(left)\\n merge_sort(right)\\n\\n i = j = k = 0\\n\\n # Copy data to temp arrays L[] and R[]\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n data[k] = left[i]\\n i += 1\\n else:\\n data[k] = right[j]\\n j += 1\\n k += 1\\n\\n # Checking if any element was left\\n while i < len(left):\\n data[k] = left[i]\\n i += 1\\n k += 1\\n\\n while j < len(right):\\n data[k] = right[j]\\n j += 1\\n k += 1\",\n \"def merge_sort (arr):\\n n = len(arr)\\n if n is 1: # Base case.\\n return arr\\n else:\\n left = merge_sort(arr[0:int(floor(n/2))])\\n right = merge_sort(arr[int(ceil(n/2)):])\\n res = merge(left, right)\\n return res\",\n \"def quicksort_random(A, p, r):\\n if p < r:\\n q = partition_random(A, p, r)\\n quicksort_random(A, p, q-1)\\n quicksort_random(A, q + 1, r)\",\n \"def mergesort(self, input_array):\\n if len(input_array) > 1:\\n mid = len(input_array)//2\\n left = self.mergesort(input_array[:mid])\\n right = self.mergesort(input_array[mid:])\\n val = self.sort(left,right)\\n return val\\n return input_array\",\n \"def quicksort(input_, p, r):\\n if p < r:\\n j = partition(input_, p, r)\\n quicksort(input_, p, j - 1)\\n quicksort(input_, j + 1, r )\",\n \"def partition(array, p, r):\\n # Choose pivot at end\\n x = array[r]\\n # Setup lower partition counter\\n i = p - 1\\n # For each element in array[p..r-1]\\n for j in range(p, r):\\n # If current item is leq than pivot\\n if array[j] <= x:\\n # Increment i anticipating a swap\\n i += 1\\n # Swap values at indices i and j in array\\n array[i], array[j] = array[j], array[i]\\n # Swap pivot with first element of upper sub-array, such that array[p..i] <= pivot <= array[i+2..r]\\n array[i + 1], array[r] = array[r], array[i + 1]\\n # Return index of pivot for further sorting\\n return i + 1\",\n \"def mergesort(array):\\n if len(array) == 1:\\n return array\\n mid = len(array) // 2 # find the middle point of the array\\n left = mergesort(array[:mid])\\n right = mergesort(array[mid:])\\n return merge(left, right)\",\n \"def mergesort_iterative(array):\\n n = len(array)\\n result = array.copy()\\n\\n # Merge runs of length 1, 2, 4, 8, ...\\n length = 1\\n while length < n:\\n # Merge each pair of runs\\n for i in range(0, n, 2 * length):\\n mid = i + length\\n upper = i + 2 * length\\n result[i:upper] = merge(result[i:mid], result[mid:upper])\\n length *= 2\\n\\n return result\",\n \"def merge_sort(arr):\\n if len(arr) == 0 or len(arr) == 1:\\n return arr\\n start = 0\\n end = len(arr)\\n mid = start + (end - start) // 2\\n left = merge_sort(arr[start:mid])\\n right = merge_sort(arr[mid:end])\\n return merge(left, right)\",\n \"def mergesort(a):\\n\\n\\n\\n def merge(left,right):\\n ll = len(left)\\n lr = len(right)\\n result = []\\n i,j = 0,0\\n while i < ll and j< lr:\\n if left[i] <= right[j]:\\n result.append(left[i])\\n i+=1\\n else:\\n result.append(right[j])\\n j+=1\\n\\n result += left[i:]\\n result += right[j:]\\n return result \\n\\n\\n \\n \\n if len(a)<= 1:\\n return a\\n\\n mid = len(a)//2\\n left = mergesort(a[:mid])\\n right = mergesort(a[mid:])\\n return merge(left,right)\",\n \"def merge_in_place(A, p, q, r):\\n n_1 = q - p + 1\\n n_2 = r - q\\n L = 0\\n R = 0\\n for k in range(p, r+1):\\n if A[p] <= A[q + 1]:\\n A.insert(r+1, A[p])\\n del A[p]\\n L += 1\\n q -= 1\\n else:\\n A.insert(r+1, A[q+1])\\n del A[q+1]\\n R += 1\\n\\n if L == n_1:\\n A[r+1:r+1] = A[p:p+n_2-R]\\n del A[p:p+n_2-R]\\n break\\n\\n if R == n_2:\\n A[r+1:r+1] = A[p:q+1]\\n del A[p:q+1]\\n break\",\n \"def merge_sort(arr):\\n if len(arr) <= 1:\\n return arr\\n mid = len(arr) // 2\\n left = merge_sort(arr[:mid])\\n right = merge_sort(arr[mid:])\\n return merge(left,right)\",\n \"def qsort(A, l, r):\\n if l < r:\\n q = partition(A, l, r)\\n qsort(A, l, q-1)\\n qsort(A, q+1, r)\",\n \"def merge_sort(arr):\\n n = len(arr)\\n # Base case\\n if n == 1:\\n return arr\\n # Recursive step: sort each half of the elements\\n return merge(merge_sort(arr[:n//2]), merge_sort(arr[n//2:]))\",\n \"def mergesort(array):\\n if len(array) == 1:\\n return array\\n else:\\n mid = len(array) // 2\\n return _subsort(mergesort(array[mid:]), mergesort(array[:mid]))\",\n \"def merge_sort(arr):\\n if len(arr) <= 1:\\n # nothing to sort\\n return arr\\n\\n # split into left and right half\\n left = arr[:len(arr) // 2]\\n right = arr[len(arr) // 2:]\\n\\n # recursively sort each half\\n left = merge_sort(left)\\n right = merge_sort(right)\\n\\n # merge both sorted halves into a new array\\n return merge(left, right)\",\n \"def merge_sort(array):\\n\\n if len(array) <= 1: # base case\\n return array\\n\\n # divide array in half and merge sort recursively\\n half = len(array) // 2\\n left = merge_sort(array[:half])\\n right = merge_sort(array[half:])\\n\\n return merge(left, right)\",\n \"def test_merge_sort(self):\\n A = [5, 2, 4, 7, 1, 3, 2, 6]\\n A_sorted = mst.merge_sort(A, 0, 8)\\n self.assertEqual(A_sorted, [1, 2, 2, 3, 4, 5, 6, 7])\",\n \"def merge_sort(arr):\\n\\n # Base Case: Array has more than one element.\\n if len(arr) > 1:\\n\\n # Middle must not be float number .\\n mid = len(arr) // 2\\n\\n # Dividing array into 2 halves. On Prime numbers right half will always\\n # has greater number of elements by one element.\\n left_half = arr[:mid]\\n right_half = arr[mid:]\\n\\n print(f\\\"Current array is: {arr}\\\")\\n print(f\\\" Left of the array: {left_half}\\\")\\n print(f\\\" Right of the array: {right_half} \\\\n\\\")\\n\\n # Each function will keep recurse until array has one element left.\\n merge_sort(left_half)\\n merge_sort(right_half)\\n\\n i = j = k = 0\\n\\n # Copy data to two temporarily arrays left_half[] and right_half[]\\n while i < len(left_half) and j < len(right_half):\\n if left_half[i] < right_half[j]:\\n arr[k] = left_half[i]\\n i += 1\\n else:\\n arr[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n # Eventually the above loop will break due the imbalance\\n # e.g. False and True, and biggest number from either left or right half\\n # will be remained without being added to the temporarily array.\\n while i < len(left_half):\\n arr[k] = left_half[i]\\n i += 1\\n k += 1\\n\\n while j < len(right_half):\\n arr[k] = right_half[j]\\n j += 1\\n k += 1\",\n \"def __merge_sort(ar,temp,low,high):\\n if low == high:\\n return\\n\\n # divide and conqure\\n middle = (low+high)//2\\n __merge_sort(ar,temp,low,middle)\\n __merge_sort(ar,temp,middle+1,high)\\n\\n # combine\\n index = leftindex = low\\n rightindex = middle+1\\n\\n while leftindex <= middle and rightindex <= high:\\n if ar[leftindex] < ar[rightindex]:\\n temp[index] = ar[leftindex]\\n leftindex += 1\\n index += 1\\n else:\\n temp[index] = ar[rightindex]\\n rightindex += 1\\n index += 1\\n\\n while leftindex <= middle:\\n temp[index] = ar[leftindex]\\n index += 1\\n leftindex +=1\\n\\n while rightindex <= high:\\n temp[index] =ar[rightindex]\\n index += 1\\n rightindex +=1\\n\\n assert index == high+1\\n\\n # copy back\\n for i in xrange(low,high+1):\\n ar[i] = temp[i]\",\n \"def partition(A:list, p:int, r:int) -> int:\\n\\n\\tx = A[r]\\n\\ti = p - 1\\n\\tfor j in range(p, r):\\n\\t\\tif A[j] <= x:\\n\\t\\t\\ti = i + 1\\n\\t\\t\\tA[i], A[j] = A[j], A[i]\\n\\tA[i+1], A[r] = A[r], A[i+1]\\n\\treturn i + 1\",\n \"def merge_sort_algorithm(self, low, high):\\n if low < high:\\n mid = (low + high) / 2\\n self.merge_sort_algorithm(low, mid)\\n self.merge_sort_algorithm(mid+1, high)\\n self.merge(low, high, mid)\",\n \"def merge_sort(arr, start, end):\\n if len(arr) <= 1:\\n return\\n if start >= end:\\n return\\n\\n mid = int((start + end) / 2)\\n merge_sort(arr, start, mid)\\n merge_sort(arr, mid+1, end)\\n merging(arr, start, mid, mid+1, end)\",\n \"def partition(A, p, r):\\n x = A[r]\\n i = p\\n for j in range(p, r):\\n if A[j] <= x:\\n A[i], A[j] = A[j], A[i]\\n i += 1\\n A[i], A[r] = A[r], A[i]\\n return i\",\n \"def merge_sort(self, data):\\n print \\\"Splitting\\\", data\\n if len(data) > 1:\\n mid = len(data)// 2\\n left_half = data[:mid]\\n right_half = data[mid:]\\n self.merge_sort(left_half)\\n self.merge_sort(right_half)\\n i,j,k = (0,0,0)\\n while i< len(left_half) and j<len(right_half):\\n if left_half[i] < right_half[j]:\\n data[k] = left_half[i]\\n i += 1\\n else:\\n data[k] = right_half[j]\\n j += 1\\n k += 1\\n #take care of the unbalance\\n while i < len(left_half):\\n data[k] = left_half[i]\\n i += 1\\n k += 1\\n while j < len(right_half):\\n data[k] = right_half[j]\\n j += 1\\n k += 1\\n print \\\"merging\\\", data\",\n \"def sort(self, nums: List[int]) -> None:\\n if len(nums) <= 1: return\\n\\n # Find the middle of the array\\n mid = len(nums) // 2\\n\\n # Split the array elements into two halves\\n left = nums[:mid]\\n right = nums[mid:]\\n\\n # Sort the left half\\n self.sort(left)\\n\\n # Sort the right half\\n self.sort(right)\\n\\n # Merge the left and right arrays into the original array\\n i = j = k = 0\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n nums[k] = left[i]\\n i += 1\\n else:\\n nums[k] = right[j]\\n j += 1\\n k += 1\\n\\n # Add the remaining elements of the left array if any\\n while i < len(left):\\n nums[k] = left[i]\\n i += 1\\n k += 1\\n\\n # Add the remaining elements of the right array if any\\n while j < len(right):\\n nums[k] = right[j]\\n j += 1\\n k += 1\",\n \"def test_20el_sorted_array(self):\\n res = merge_sort([1, 2, 3, 4, 5, 6, 7, 8, 9,\\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\",\n \"def sort(self, left_arr, right_arr):\\n sorted_array = []\\n left_ind, right_ind = 0,0\\n while left_ind < len(left_arr) and right_ind < len(right_arr):\\n if left_arr[left_ind] < right_arr[right_ind]:\\n sorted_array.append(left_arr[left_ind])\\n left_ind += 1\\n else: \\n sorted_array.append(right_arr[right_ind])\\n right_ind += 1\\n if left_ind == len(left_arr):\\n sorted_array.extend(right_arr[right_ind:])\\n else:\\n sorted_array.extend(left_arr[left_ind:])\\n return sorted_array\",\n \"def partition_random(A, p, r):\\n n = random.randint(p, r)\\n A[n], A[r] = A[r], A[n]\\n x = A[r]\\n i = p-1\\n for j in range(p, r):\\n if A[j] <= x:\\n i += 1\\n A[i], A[j] = A[j], A[i]\\n A[i+1], A[r] = A[r], A[i+1]\\n return i+1\",\n \"def mergesort(arr):\\n if type(arr) is not list:\\n raise TypeError('argument must be list of integers')\\n\\n if len(arr) <= 1:\\n return arr \\n\\n def recurse(arr):\\n half = len(arr)//2\\n left = []\\n right = []\\n\\n for i in range(half):\\n left = left + [arr[i]]\\n right = right + [arr[len(arr) - 1 - i]]\\n # print('split', left, right)\\n if len(left) > 1:\\n left = recurse(left)\\n if len(right) > 1:\\n right = recurse(right)\\n \\n return merge(left, right) \\n \\n def merge(left, right):\\n output = []\\n i = 0\\n j = 0\\n while i < len(left) and j < len(right):\\n if left[i] <= right[j]:\\n output.append(left[i])\\n i = i + 1\\n elif left[i] >= right[j]:\\n output.append(right[j])\\n j = j + 1\\n # print('merging', left, right, '=>', output)\\n output.extend(left[i:])\\n output.extend(right[j:])\\n\\n # print('merged', output, '\\\\n')\\n return output\\n\\n return recurse(arr)\",\n \"def mergesort_iterative_hybrid(array, threshold=37):\\n n = len(array)\\n result = array.copy()\\n\\n # Initial insertion sort pass\\n for i in range(0, n, threshold):\\n result[i:i+threshold] = insertion_sort(result[i:i+threshold])\\n\\n # Merge runs of length threshold, 2*threshold, ...\\n length = threshold\\n while length < n:\\n # Merge each pair of runs\\n for i in range(0, n, 2 * length):\\n mid = i + length\\n upper = i + 2 * length\\n result[i:upper] = merge(result[i:mid], result[mid:upper])\\n length *= 2\\n\\n return result\",\n \"def custom_sort(arr):\\n pass\",\n \"def mergesort_recursive_hybrid(array, threshold=37):\\n # Base case delegates to insertion sort\\n n = len(array)\\n if n <= threshold:\\n return insertion_sort(array)\\n\\n # Recur on two halves of array and merge results\\n mid = n // 2\\n return merge(\\n mergesort_recursive(array[:mid]),\\n mergesort_recursive(array[mid:]))\",\n \"def merge(l, r):\\n print(\\\"merge [l={}, r={}]\\\".format(l, r))\\n t = [None] * (len(l) + len(r))\\n ti = 0\\n \\n i, j = 0, 0\\n\\n while i < len(l) and j < len(r):\\n if l[i] <= r[j]:\\n t[ti] = l[i]\\n i += 1\\n else:\\n t[ti] = r[j]\\n j += 1\\n ti += 1\\n\\n # copy remaining items from one of either l or r...\\n if i < len(l):\\n while i < len(l):\\n t[ti] = l[i]\\n i += 1\\n ti += 1\\n else:\\n while j < len(r):\\n t[ti] = r[j]\\n j+= 1\\n ti += 1\\n\\n return t\",\n \"def merge_sort(arr):\\r\\n if len(arr) == 1:\\r\\n return arr\\r\\n middle = len(arr) // 2\\r\\n first_half = merge_sort(arr[:middle])\\r\\n second_half = merge_sort(arr[middle:])\\r\\n return merge(first_half, second_half)\",\n \"def random_qsort(A, l, r):\\n if l < r:\\n q = random_partition(A, l, r)\\n random_qsort(A, l, q-1)\\n random_qsort(A, q+1, r)\",\n \"def mergesort(arr):\\n len_arr = len(arr)\\n if len_arr <= 1:\\n return arr\\n\\n middle = len_arr / 2\\n front = mergesort(arr[:middle])\\n back = mergesort(arr[middle:])\\n\\n return merge(front, back)\",\n \"def sort(self, nums: List[int]) -> None:\\n\\n # Start at the 2nd element in the array\\n for i in range(1, len(nums)):\\n\\n # Set the key to the beginning of the unsorted subarray\\n key = nums[i]\\n\\n # Set a pointer to the end of the sorted subarray\\n j = i-1\\n\\n # Shift elements in the sorted array to the right as needed\\n # until the correct position for the key is found\\n while j >= 0 and key < nums[j]:\\n nums[j+1] = nums[j]\\n j -= 1\\n\\n # Set the key to the found position\\n nums[j+1] = key\",\n \"def merge_sort (t,cmp):\\n n = len(t)\\n if n <= 1:\\n # cas de base\\n return copy.deepcopy(t)\\n else:\\n # cas general\\n t1 = merge_sort((t[0:((n-1)//2+1)]),cmp)\\n t2 = merge_sort((t[((n-1)//2+1):n]),cmp)\\n return merge(t1,t2,cmp)\",\n \"def mergeSortedArrays(nums1, m, nums2, n):\",\n \"def qsort(array, left, right):\\n if left < right:\\n p_ind_new = partition(array, left, right)\\n qsort(array, left, p_ind_new-1)\\n qsort(array, p_ind_new+1, right)\",\n \"def mergesort(arr1, option):\\n length = len(arr1)\\n if length < 2:\\n return arr1\\n # make a copy, since mergesort needs O(n) space\\n arr2 = arr1[:]\\n step = 1\\n while step < length:\\n i, curr = 0, 0 # beginning of each pair, current write point\\n while i + step < length:\\n left, right = i, i + step\\n while curr < length and curr < i + 2 * step:\\n if right == length or right == i + 2 * step:\\n arr2[curr] = arr1[left]\\n left += 1\\n elif left == i + step:\\n arr2[curr] = arr1[right]\\n right += 1\\n elif arr1[left] <= arr1[right]:\\n arr2[curr] = arr1[left]\\n left += 1\\n elif arr1[left] > arr1[right]:\\n arr2[curr] = arr1[right]\\n right += 1\\n curr += 1\\n i += 2 * step\\n # important: copy the untouched end to the new array. It's not applied yet\\n while curr < length:\\n arr2[curr] = arr1[curr]\\n curr += 1\\n step *= 2\\n # swap two arrays for cost efficiency\\n arr1, arr2 = arr2, arr1\\n return arr1\",\n \"def merge_sort(L):\\n n = len(L)\\n if n < 2:\\n return L\\n mid = n // 2\\n left = L[:mid]\\n right = L[mid:]\\n merge_sort(left)\\n merge_sort(right)\\n merge(L, left, right)\",\n \"def quicksortSimple(A:list, p:int, r:int) -> \\\"void\\\":\\n\\n\\ttamanoSecuencia = r - p + 1\\n\\n\\tif tamanoSecuencia <= 32 and p < r:\\t\\n\\t\\tinsertionsortIndex(A, p, r)\\n\\n\\n\\telif tamanoSecuencia > 32 and p < r:\\n\\t\\tq = partition(A, p, r)\\t\\n\\t\\tquicksortSimple(A, p, q-1)\\n\\t\\tquicksortSimple(A, q+1, r)\\n\\n\\t# Para usarse se llama: quickSort(arreglo, 0, len(arreglo) - 1)\",\n \"def merge_sort(array: list):\\n\\n # check if the list is not empty and is greater than one element\\n if len(array) > 1:\\n # get the middle of the list, do an integer division, we don't need decimals\\n # assign a left part and a right part\\n middle = len(array) // 2\\n left_half = array[:middle]\\n right_half = array[middle:]\\n\\n # call merge_sort recursively to keep dividing the list\\n merge_sort(left_half)\\n merge_sort(right_half)\\n\\n i = 0 # used to track left half of the list\\n j = 0 # used to track right side of the list\\n k = 0 # used to track the array itself\\n\\n # merge both left and right part of the list\\n while i < len(left_half) and j < len(right_half):\\n if left_half[i] <= right_half[j]:\\n array[k] = left_half[i]\\n i += 1\\n else:\\n array[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n # merge the left half in an ordered fashion\\n while i < len(left_half):\\n array[k] = left_half[i]\\n i += 1\\n k += 1\\n\\n # merge the right half in an ordered fashion\\n while j < len(right_half):\\n array[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n return array\",\n \"def merge_sort(nums):\\n\\n if len(nums) == 1:\\n return nums\\n\\n mid = len(nums)/2 \\n left_part = merge_sort(nums[:mid]) \\n right_part = merge_sort(nums[mid:]) \\n merged = merge(left_part,right_part) \\n return merged\",\n \"def merge_sort(a_list):\\n\\n if len(a_list) > 1:\\n mid = len(a_list) // 2\\n left_half = a_list[:mid]\\n right_half = a_list[mid:]\\n\\n merge_sort(left_half)\\n merge_sort(right_half)\\n\\n i = 0\\n j = 0\\n k = 0\\n while i < len(left_half) and j < len(right_half):\\n if left_half[i] < right_half[j]:\\n a_list[k] = left_half[i]\\n i += 1\\n else:\\n a_list[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n while i < len(left_half):\\n a_list[k] = left_half[i]\\n i += 1\\n k += 1\\n\\n while j < len(right_half):\\n a_list[k] = right_half[j]\\n j += 1\\n k += 1\\n return a_list\",\n \"def merge_sort(arr: list, start: int, end: int):\\n if end == start:\\n return [arr[start]]\\n else:\\n mid = start + (end - start)//2\\n left = merge_sort(arr, start, mid)\\n right = merge_sort(arr, mid+1, end)\\n sorted_arr = merge(left, right)\\n return sorted_arr\",\n \"def merge_sort(aList):\\n\\n n = len(aList)\\n\\n # Check for base case\\n if n <= 1:\\n return aList\\n\\n # Split the list into two halves and call recursively\\n first = merge_sort(aList[0:int(n/2)])\\n\\n second = merge_sort(aList[int(n/2):n])\\n\\n #pdb.set_trace()\\n\\n # Perform Merge of two sorted lists\\n # Initialize counters, lengths and the newly sorted array\\n i, j = 0, 0\\n firstLen = len(first)\\n secondLen = len(second)\\n\\n sortedList = []\\n\\n # Populate the sorted list with the lesser of each half-list\\n for k in range(n):\\n\\n # Make sure we won't try to access past the end of a list\\n # If we've reached the end of the first array, then\\n # add the element from the second array.\\n if i == firstLen:\\n sortedList.append(second[j])\\n j += 1\\n\\n # If we've reached the end of the second array, add\\n # the element from the first array\\n elif j == secondLen:\\n sortedList.append(first[i])\\n i += 1\\n\\n # The normal case (before we've reached the end of either array)\\n elif first[i] < second[j]:\\n sortedList.append(first[i])\\n i += 1\\n\\n else:\\n sortedList.append(second[j])\\n j += 1\\n\\n\\n return sortedList\",\n \"def merge(A, left, middle, right):\\n leftSubArray = A[left:middle]\\n rightSubArray = A[middle:right+1]\\n leftSubArray.append(float(\\\"inf\\\"))\\n rightSubArray.append(float(\\\"inf\\\"))\\n i = j = 0\\n for k in xrange(left, right + 1):\\n if leftSubArray[i] < rightSubArray[j]:\\n A[k] = leftSubArray[i]\\n i += 1\\n else:\\n A[k] = rightSubArray[j]\\n j += 1\\n return A\",\n \"def test_20el_shuffled_array(self):\\n res = merge_sort([2, 11, 17, 16, 14, 19, 15, 9, 12,\\n 5, 1, 18, 4, 20, 7, 3, 8, 10, 13, 6])\\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\",\n \"def _quicksort(self, l, r):\\n\\t\\tif l < r:\\n\\t\\t\\tsplitpoint = self._partition(l, r)\\n\\t\\t\\tself._quicksort(l, splitpoint-1)\\n\\t\\t\\tself._quicksort(splitpoint+1, r)\",\n \"def merge_sort(data):\\r\\n\\r\\n if not data or len(data) == 1:\\r\\n # return if list size is 0 or 1\\r\\n return data\\r\\n else:\\r\\n # split data list in half\\r\\n middle = int(len(data) / 2)\\r\\n a = merge_sort(data[:middle])\\r\\n b = merge_sort(data[middle:])\\r\\n # user merge function to merge the two halves\\r\\n # back together while also sorting them\\r\\n return merge(a, b)\",\n \"def sort(arr, filename):\\n if len(arr) > 1:\\n mid = len(arr) // 2 # Finding the mid of the array\\n L = arr[:mid] # Dividing the array elements\\n R = arr[mid:] # into 2 halves\\n sort(L, filename) # Sorting the first half\\n sort(R, filename) # Sorting the second half\\n\\n i = j = k = 0\\n\\n # Copy data to temp arrays L[] and R[]\\n while i < len(L) and j < len(R):\\n if L[i] < R[j]:\\n arr[k] = L[i]\\n i += 1\\n else:\\n arr[k] = R[j]\\n j += 1\\n k += 1\\n\\n # Checking if any element was left\\n while i < len(L):\\n arr[k] = L[i]\\n i += 1\\n k += 1\\n\\n while j < len(R):\\n arr[k] = R[j]\\n j += 1\\n k += 1\\n with open(\\\"output/temp/\\\" + filename, \\\"w\\\") as file:\\n for item in arr:\\n file.write('%s\\\\n' % item)\",\n \"def merge_sort(items, key):\\n # Check endcase\\n if (len(items) / 2) > 1:\\n global COMPARE\\n # Pivot point/middle\\n pivot = int(len(items) / 2)\\n # Recursive call\\n left = merge_sort(items[0:pivot], key)\\n right = merge_sort(items[pivot:len(items)], key)\\n # Init the variables\\n l_index = r_index = 0\\n merged = []\\n # Merging\\n while (l_index < len(left)) and (r_index < len(right)):\\n # If right index is larger, append left[index]; increase l. index\\n if COMPARE(right[r_index], left[l_index]):\\n merged.append(left[l_index])\\n l_index += 1\\n # If left index is larger, append right[index]; increase r. index\\n elif COMPARE(left[l_index], right[r_index]):\\n merged.append(right[r_index])\\n r_index += 1\\n # Add remaining merge\\n if(l_index == len(left)):\\n merged.extend(right[r_index:])\\n elif(r_index == len(left)):\\n merged.extend(left[l_index:])\\n # Return list\\n return merged\\n else:\\n # End of the line!\\n return bubble_sort(items, key)\",\n \"def mergesort_recursive(array):\\n # Base case for empty or singular list\\n n = len(array)\\n if n < 2:\\n return array\\n\\n # Recur on two halves of array and merge results\\n mid = n // 2\\n return merge(\\n mergesort_recursive(array[:mid]),\\n mergesort_recursive(array[mid:]))\",\n \"def merge_sort(a, b):\\n l = []\\n while a and b:\\n if a[0] < b[0]:\\n l.append(a.pop(0))\\n else:\\n l.append(b.pop(0))\\n return l + a + b\",\n \"def sort(self, nums: List[int]) -> None:\\n n = len(nums)\\n for i in range(n):\\n\\n # Set the lowest to the beginning of the unsorted subarray\\n low = i\\n for j in range(i+1,n):\\n\\n # Find the lowest in the unsorted array\\n if nums[j] < nums[low]:\\n low = j\\n \\n # Swap the beginning of the unsorted subarray and the lowest.\\n # The beginning of the unsorted subarray now becomes the end of the sorted subarray\\n nums[i], nums[low] = nums[low], nums[i]\",\n \"def dualPivotQuicksort(A:list, left:int, right:int) -> \\\"void\\\":\\n\\n\\tif right - left <= 32:\\t\\t\\n\\t\\tinsertionsortIndex(A, left, right)\\n\\telse:\\n\\t\\tif A[left] > A[right]:\\n\\t\\t\\tp, q = A[right], A[left]\\n\\t\\telse:\\n\\t\\t\\tp, q = A[left], A[right]\\n\\t\\tl, g = left + 1, right - 1\\n\\t\\tk = l\\n\\n\\t\\twhile k <= g:\\n\\t\\t\\tif A[k] < p:\\n\\t\\t\\t\\tA[k], A[l] = A[l], A[k]\\n\\t\\t\\t\\tl = l + 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif A[k] >= q:\\n\\n\\t\\t\\t\\t\\twhile A[g] > q and k < g:\\n\\t\\t\\t\\t\\t\\tg = g - 1\\n\\n\\t\\t\\t\\t\\tif A[g] >= p:\\n\\t\\t\\t\\t\\t\\tA[k], A[g] = A[g], A[k]\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tA[k], A[g] = A[g], A[k]\\n\\t\\t\\t\\t\\t\\tA[k], A[l] = A[l], A[k]\\n\\t\\t\\t\\t\\t\\tl = l + 1\\n\\n\\t\\t\\t\\t\\tg = g - 1\\t\\t\\t\\t\\t\\n\\t\\t\\tk = k + 1\\n\\n\\t\\tl = l - 1\\n\\t\\tg = g + 1\\n\\t\\tA[left] = A[l]\\n\\t\\tA[l] = p\\n\\t\\tA[right] = A[g]\\n\\t\\tA[g] = q\\n\\t\\tdualPivotQuicksort(A, left, l-1)\\n\\t\\tdualPivotQuicksort(A, l+1, g-1)\\n\\t\\tdualPivotQuicksort(A, g+1, right)\\n\\n\\t\\t# Debe llamarse con: dualPivotQuicksort(A, 0, len(A)-1)\",\n \"def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\\n # # solution one: sort\\n # A[m:] = B\\n # A.sort()\\n\\n # solution two: two point\\n if n == 0: # B = []\\n return\\n i, j, k = m - 1, n - 1, m + n - 1\\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\\n if A[i] <= B[j]:\\n A[k] = B[j]\\n k -= 1\\n j -= 1\\n else:\\n A[k] = A[i]\\n k -= 1\\n i -= 1\\n if j > -1:\\n A[:j + 1] = B[:j + 1] # A = [], B = [1]\",\n \"def mergesort(sequence):\\n\\tif len(sequence) <= 1:\\n\\t\\treturn sequence\\n\\n\\tmiddle_index = len(sequence) // 2\\n\\tleft_half = mergesort(sequence[:middle_index])\\n\\tright_half = mergesort(sequence[middle_index:])\\n\\n\\treturn merge(left_half, right_half)\",\n \"def merge_sort(S):\\n n = len(S)\\n if n < 2:\\n return\\n\\n # devide\\n mid = n//2\\n S1 = S[0:mid]\\n S2 = S[mid:n]\\n\\n # conquer\\n merge_sort(S1)\\n merge_sort(S2)\\n\\n # merge results\\n i = j = 0\\n while i + j < len(S):\\n if j == len(S2) or (i < len(S1) and S1[i] < S2[j]):\\n S[i + j] = S1[i]\\n i += 1\\n else:\\n S[i + j] = S2[j]\\n j += 1\",\n \"def merge_sort(S):\\n n = len(S)\\n if n < 2:\\n return\\n mid = n // 2\\n S1 = S[0:mid]\\n S2 = S[mid:n]\\n merge_sort(S1)\\n merge_sort(S2)\\n merge(S1, S2, S)\",\n \"def merge_sort(alist):\\n print(\\\"Splitting \\\", alist)\\n # Temporary list to store sorted list\\n work = [None] * len(alist)\\n rec_merge_sort(work, start=0, end=len(alist)-1)\",\n \"def merge(array, left, middle, right):\\n\\n len1 = middle - left + 1\\n len2 = right - middle\\n\\n left_side = array[left: left + len1]\\n right_side = array[middle + 1: middle + len2 + 1]\\n\\n i = j = 0\\n k = left\\n\\n while i < len1 and j < len2:\\n if left_side[i] <= right_side[j]:\\n array[k] = left_side[i]\\n i += 1\\n else:\\n array[k] = right_side[j]\\n j += 1\\n\\n k += 1\\n\\n while i < len1:\\n array[k] = left_side[i]\\n i += 1\\n k += 1\\n\\n while j < len2:\\n array[k] = right_side[j]\\n j += 1\\n k += 1\",\n \"def mergesort(T:list) -> \\\"void\\\":\\n\\n\\tif len(T) <= 32:\\n\\t\\tinsertionsort(T)\\n\\n\\telse:\\n\\t\\tU = T[0:len(T)//2]\\n\\t\\tV = T[len(T)//2:len(T)]\\n\\t\\tmergesort(U)\\n\\t\\tmergesort(V)\\n\\t\\tmerge(U, V, T)\",\n \"def merge_sort(aList):\\n #If the aList is size 0 or 1, it's already sorted.\\n if len(aList) <= 1:\\n return aList\\n\\n else:\\n mid = len(aList) // 2\\n\\n # Recursively sort the left and right halves\\n left = merge_sort(aList[:mid])\\n right = merge_sort(aList[mid:])\\n \\n # Merge the two (each sorted) parts back together\\n return merge(left, right)\",\n \"def mergeunsort(arr, inv_seq):\\n\\tif len(arr) <= 1:\\n\\t\\treturn list(arr)\\n\\tcut_idx = (len(arr) + 1) / 2\\n\\tleft = arr[:cut_idx]\\n\\tright = arr[cut_idx:]\\n\\tleft = mergeinvert(left, inv_seq)\\n\\tright = mergeinvert(right, inv_seq)\\n\\treturn invert_merge(left, right, inv_seq)\",\n \"def _merge(arr, temp, left, mid, right):\\n i = left\\n j = mid\\n k = left\\n inv_count = 0\\n while i < mid and j <= right:\\n if arr[i] < arr[j]:\\n temp[k] = arr[i]\\n k += 1\\n i += 1\\n else:\\n temp[k] = arr[j]\\n k += 1\\n j += 1\\n inv_count += (mid -i)\\n while i < mid:\\n temp[k] = arr[i]\\n k += 1\\n i += 1\\n if j <= right:\\n k += right - j + 1\\n j += right - j + 1\\n arr[left:k + 1] = temp[left:k + 1]\\n else:\\n arr[left:right + 1] = temp[left:right + 1]\\n return inv_count\",\n \"def merge_two(l, r):\\n new = []\\n i1, i2 = 0, 0\\n while i1 != len(l) and i2 != len(r):\\n if l[i1] < r[i2]:\\n new.append(l[i1])\\n i1 += 1\\n else:\\n new.append(r[i2])\\n i2 += 1\\n\\n new.extend(l[i1:])\\n new.extend(r[i2:])\\n return new\",\n \"def merge_sort(items):\\r\\n # TODO: Check if list is so small it's already sorted (base case)\\r\\n # TODO: Split items list into approximately equal halves\\r\\n # TODO: Sort each half by recursively calling merge sort\\r\\n # TODO: Merge sorted halves into one list in sorted order\\r\",\n \"def merge_sort(input_list,start,end):\\n if start < end:\\n mid=(start+end)//2\\n merge_sort(input_list,start,mid)\\n merge_sort(input_list,mid+1,end)\\n return merge(input_list,start,mid,end)\",\n \"def merging(arr, s1, e1, s2, e2):\\n p1 = s1\\n p2 = s2\\n tmp = [0 for _ in range(len(arr))]\\n idx = s1\\n\\n while p1 <= e1 and p2 <= e2:\\n if arr[p1] < arr[p2]:\\n tmp[idx] = arr[p1]\\n idx += 1\\n p1 += 1\\n else:\\n tmp[idx] = arr[p2]\\n idx += 1\\n p2 += 1\\n\\n if p1 <= e1:\\n for i in range(p1, e1+1):\\n tmp[idx] = arr[p1]\\n idx += 1\\n p1 += 1\\n else:\\n for i in range(p2, e2+1):\\n tmp[idx] = arr[p2]\\n idx += 1\\n p2 += 1\\n\\n for i in range(s1, e2+1):\\n arr[i] = tmp[i]\\n\\n # done\",\n \"def merge (left, right):\\n i = 0\\n j = 0\\n n = len(left)\\n m = len(right)\\n out = []\\n\\n while i < n and j < m:\\n if left[i] < right[j]:\\n out.append(left[i])\\n i += 1\\n else:\\n out.append(right[j])\\n j += 1\\n\\n if i is n:\\n for l in xrange(j, m):\\n out.append(right[l])\\n elif j is m:\\n for l in xrange(i, n):\\n out.append(left[l])\\n\\n return out\",\n \"def mergesort(x):\\n\\n if len(x) == 0 or len(x) == 1:\\n return x\\n else:\\n middle = int(len(x)/2)\\n a = mergesort(x[:middle])\\n b = mergesort(x[middle:])\\n return merge(a,b)\",\n \"def merge(nums1, m, nums2, n):\\r\\n if not nums2:\\r\\n return\\r\\n\\r\\n while m > 0 and n > 0:\\r\\n # the current element of the final sorted array is the smaller of nums2[n -1] and nums1[m - 1]\\r\\n if nums2[n - 1] < nums1[m - 1]:\\r\\n nums1[m + n - 1] = nums1[m - 1]\\r\\n m -= 1\\r\\n else:\\r\\n nums1[m + n - 1] = nums2[n - 1]\\r\\n n -= 1\\r\\n nums1[:n] = nums2[:n]\",\n \"def RInsertionSort(array):\\n\\n if not isinstance(array, np.ndarray):\\n raise TypeError('_container is not ndarray') \\n\\n # Get array\\n n = len(array)\\n fhelper(array, 1, n)\",\n \"def sort_by_polar_angle_v2(pts):\\n\\n\\t### make a copy of points array to avoid corruption\\n\\t### of original points array\\n\\tcopy_pts = []\\n\\tfor each in pts:\\n\\t\\tif each not in copy_pts:\\n\\t\\t\\tcopy_pts.append(each)\\n\\n\\tP0_idx = copy_pts.index(P0)\\n\\tdel copy_pts[P0_idx]\\n\\n\\n\\t# Call polar_angle function to calculate polar angle\\n\\t# of points with respect to P0\\n\\tp =polar_angle(copy_pts)\\n\\t\\n\\n\\t#########For sorting polar angle array ######\\n\\t# Once we get the polar angle array, we use numpy.argsort\\n\\t# to get the indices of sorted polar angle array\\n\\t# using the indices serves two purpose\\n\\t# 1. Sort polar angle array\\n\\t# 2. Sort list of points array \\n\\t# 3. Develop logic to take farthest point in case of\\n\\t# collinear\\n\\n\\tnp_p = np.asarray(p)\\t\\n\\tsorted_idx = np.argsort(np_p,kind='mergesort')\\n\\n\\n\\t# Do steps 1. and 2. of above commented logic\\n\\tsorted_p = []\\n\\tsorted_pts = []\\n\\tfor each in sorted_idx:\\n\\t\\tsorted_p.append(p[each])\\n\\t\\tsorted_pts.append(copy_pts[each])\\n\\n\\t# Code for step 3.\\n\\tcheck_dict = {}\\n\\tfor i in range(len(sorted_p)-1):\\n\\t\\tfor j in range(i+1,len(sorted_p)):\\n\\t\\t\\tif sorted_p[j] == sorted_p[i]:\\n\\t\\t\\t\\tif sorted_p[i] not in check_dict:\\n\\t\\t\\t\\t\\ttemp_list=[]\\n\\t\\t\\t\\t\\ttemp_list.append(sorted_pts[i])\\n\\t\\t\\t\\t\\tcheck_dict[sorted_p[i]]=temp_list\\n\\t\\t\\t\\ttemp_list2 = []\\n\\t\\t\\t\\ttemp_list2 = check_dict[sorted_p[i]]\\n\\t\\t\\t\\tif sorted_pts[j] not in temp_list2:\\n\\t\\t\\t\\t\\ttemp_list2.append(sorted_pts[j])\\n\\t\\t\\t\\t\\tcheck_dict[sorted_p[i]]=temp_list2\\n\\t\\t\\t\\tif sorted_pts[j] in temp_list2:\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tbreak\\n\\n\\n\\tfor dict_val in check_dict.values():\\n\\n\\t\\tfarthest_pt = dict_val[0]\\n\\t\\tmax_dist = euclidean_distance_v2(farthest_pt,P0)\\n\\n\\t\\tfor each in dict_val[1:]:\\n\\n\\t\\t\\tif euclidean_distance_v2(each,P0) > max_dist:\\n\\t\\t\\t\\tsorted_pts = [x for x in sorted_pts if x!=farthest_pt]\\n\\t\\t\\t\\tmax_dist = euclidean_distance_v2(each,P0)\\n\\t\\t\\t\\tfarthest_pt = each\\n\\t\\t\\tif euclidean_distance_v2(each,P0) < max_dist:\\n\\t\\t\\t\\tsorted_pts = [x for x in sorted_pts if x!=each]\\n\\n\\n\\treturn sorted_pts\",\n \"def bottom_up_merge_sort(items):\\n subarray_size = 1\\n\\n while subarray_size < len(items)//2:\\n ## Continue making passes through items until the subarray size is\\n ## the size of items, since this means items is finally sorted.\\n for i in range(0, len(items), subarray_size):\\n merge(items, i, i+subarray_size*2, subarray_size)\\n subarray_size *= 2\",\n \"def merge(arr1,arr2,n,m) :\\n gap = n + m\\n\\n while gap > 1 :\\n\\n gap = (gap // 2) + (gap % 2)\\n \\n i = 0\\n while (i + gap) <= (n+m-1) :\\n if i < n and (i+gap) < n :\\n if arr1[i] > arr1[i+gap] :\\n arr1[i], arr1[i+gap] = arr1[i+gap], arr1[i]\\n elif i < n and (i + gap) >= n :\\n if arr1[i] > arr2[i+gap-n] :\\n arr1[i], arr2[i+gap-n] = arr2[i+gap-n], arr1[i]\\n elif i >= n :\\n if arr2[i-n] > arr2[i+gap-n] :\\n arr2[i-n], arr2[i+gap-n] = arr2[i+gap-n], arr2[i-n]\\n i += 1\",\n \"def heap_sort(self, A):\\n pass\",\n \"def heap_sort(self, A):\\n pass\",\n \"def merge_sort(list):\\n\\n\\tif len(list) <= 1:\\n\\t\\treturn list\\n\\n\\tleft_half, right_half = split(list)\\n\\tleft = merge_sort(left_half)\\n\\tright = merge_sort(right_half)\\n\\n\\treturn merge(left, right)\",\n \"def merge_sort(list):\\n # Base Condition\\n if len(list) <= 1:\\n return list\\n\\n left_half, right_half = split(list)\\n left = merge_sort(left_half)\\n right = merge_sort(right_half)\\n\\n return merge(left,right)\",\n \"def merge_sort(list):\\r\\n \\r\\n if len(list) <= 1:\\r\\n return list\\r\\n \\r\\n left_half, right_half = split(list)\\r\\n left = merge_sort(left_half)\\r\\n right = merge_sort(right_half)\\r\\n \\r\\n return merge(left, right)\",\n \"def mergeSort(sequence):\\n if len(sequence) <= 1:\\n return sequence\\n\\n mid = len(sequence) // 2\\n left = mergeSort(sequence[:mid])\\n right = mergeSort(sequence[mid:])\\n result = mergeSeq(left, right)\\n return result\",\n \"def test_three_split():\\n run_mergesort([3, 0, 3], [0, 3, 3])\",\n \"def merge_sort(items):\\n if len(items) >1:\\n mid = len(items)//2\\n left = items[:mid]\\n right = items[mid:]\\n\\n merge_sort(left)\\n merge_sort(right)\\n\\n i = j = k = 0\\n\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n items[k] = left[i]\\n i+=1\\n else:\\n items[k] = right[j]\\n j+=1\\n k+=1\\n\\n while i < len(left):\\n items[k] = left[i]\\n i+=1\\n k+=1\\n\\n while j < len(right):\\n items[k] = right[j]\\n j+=1\\n k+=1\\n\\n return items\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83909804","0.82299715","0.7800592","0.752118","0.74472076","0.74064726","0.7010142","0.69270617","0.6911257","0.6762529","0.6758566","0.67509073","0.6742108","0.6702788","0.66815907","0.6673625","0.6635363","0.656472","0.65487516","0.6545953","0.6545235","0.65245897","0.651798","0.651715","0.6483082","0.6474027","0.64657307","0.6434534","0.6417253","0.6413804","0.63903016","0.63662106","0.6350464","0.6314496","0.63039386","0.6298685","0.6296416","0.62740105","0.62395954","0.62040067","0.6203327","0.6194474","0.61895555","0.61569846","0.6155114","0.61125034","0.6103906","0.6102904","0.6089406","0.60763246","0.6064082","0.60346353","0.60162014","0.6011402","0.6007552","0.59941435","0.59900236","0.5983656","0.59820133","0.59809184","0.59684753","0.59673333","0.59592754","0.59511983","0.5922838","0.59064746","0.5901175","0.588746","0.5885712","0.58838254","0.5872814","0.5791015","0.5790538","0.57862383","0.5765831","0.57608885","0.5751227","0.5746377","0.5725958","0.56921524","0.568741","0.56751704","0.5658781","0.5650548","0.5630131","0.56232125","0.56043214","0.55855906","0.5575374","0.55733365","0.5563425","0.5558795","0.55556464","0.55556464","0.5552712","0.5551909","0.55515194","0.55514246","0.553564","0.5534081"],"string":"[\n \"0.83909804\",\n \"0.82299715\",\n \"0.7800592\",\n \"0.752118\",\n \"0.74472076\",\n \"0.74064726\",\n \"0.7010142\",\n \"0.69270617\",\n \"0.6911257\",\n \"0.6762529\",\n \"0.6758566\",\n \"0.67509073\",\n \"0.6742108\",\n \"0.6702788\",\n \"0.66815907\",\n \"0.6673625\",\n \"0.6635363\",\n \"0.656472\",\n \"0.65487516\",\n \"0.6545953\",\n \"0.6545235\",\n \"0.65245897\",\n \"0.651798\",\n \"0.651715\",\n \"0.6483082\",\n \"0.6474027\",\n \"0.64657307\",\n \"0.6434534\",\n \"0.6417253\",\n \"0.6413804\",\n \"0.63903016\",\n \"0.63662106\",\n \"0.6350464\",\n \"0.6314496\",\n \"0.63039386\",\n \"0.6298685\",\n \"0.6296416\",\n \"0.62740105\",\n \"0.62395954\",\n \"0.62040067\",\n \"0.6203327\",\n \"0.6194474\",\n \"0.61895555\",\n \"0.61569846\",\n \"0.6155114\",\n \"0.61125034\",\n \"0.6103906\",\n \"0.6102904\",\n \"0.6089406\",\n \"0.60763246\",\n \"0.6064082\",\n \"0.60346353\",\n \"0.60162014\",\n \"0.6011402\",\n \"0.6007552\",\n \"0.59941435\",\n \"0.59900236\",\n \"0.5983656\",\n \"0.59820133\",\n \"0.59809184\",\n \"0.59684753\",\n \"0.59673333\",\n \"0.59592754\",\n \"0.59511983\",\n \"0.5922838\",\n \"0.59064746\",\n \"0.5901175\",\n \"0.588746\",\n \"0.5885712\",\n \"0.58838254\",\n \"0.5872814\",\n \"0.5791015\",\n \"0.5790538\",\n \"0.57862383\",\n \"0.5765831\",\n \"0.57608885\",\n \"0.5751227\",\n \"0.5746377\",\n \"0.5725958\",\n \"0.56921524\",\n \"0.568741\",\n \"0.56751704\",\n \"0.5658781\",\n \"0.5650548\",\n \"0.5630131\",\n \"0.56232125\",\n \"0.56043214\",\n \"0.55855906\",\n \"0.5575374\",\n \"0.55733365\",\n \"0.5563425\",\n \"0.5558795\",\n \"0.55556464\",\n \"0.55556464\",\n \"0.5552712\",\n \"0.5551909\",\n \"0.55515194\",\n \"0.55514246\",\n \"0.553564\",\n \"0.5534081\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.86928904"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93493,"cells":{"query":{"kind":"string","value":"Sort array elements in A between p and r using mergesort inplace."},"document":{"kind":"string","value":"def mergesort_ip(A, p, r):\n if p < r:\n q = (p+r)//2\n mergesort(A, p, q)\n mergesort(A, q + 1, r)\n merge_in_place(A, p, q, r)"},"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 mergesort(A, p, r):\n if p < r:\n q = (p+r)//2\n mergesort(A, p, q)\n mergesort(A, q + 1, r)\n merge(A, p, q, r)","def sort(self, A, index, p, r, rc_arr):\n\n if p < r:\n q = (p + r) // 2\n\n self.sort(A, index, p, q, rc_arr)\n self.sort(A, index, q + 1, r, rc_arr)\n self.merge(A, index, p, q, r, rc_arr)","def merge(A, p, q, r):\n\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\n n1 = q - p + 1 # will hold A[p..q]\n n2 = r - q # will hold A[q+1..r]\n\n L = [0] * (n1 + 1)\n R = [0] * (n2 + 1)\n \n for i in range(n1):\n L[i] = A[p+i]\n for j in range(n2):\n R[j] = A[q+j+1]\n\n # add sentinels\n L[n1] = float('inf')\n R[n2] = float('inf')\n\n # instead of sentinels, we can check if either L or R is empty,\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\n \n # indices of subarrays L and R (both already previously sorted)\n i = 0\n j = 0\n\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 1","def merge(A, p, q, r):\n left, right = [], []\n for i in range(p, q + 1):\n left.append(A[i])\n\n for j in range(q + 1, r + 1):\n right.append(A[j])\n\n i, j = 0, 0\n for k in range(p, r + 1):\n if i > q - p:\n A[k] = right[j]\n j += 1\n continue\n if j > r - q - 1:\n A[k] = left[i]\n i += 1\n continue\n\n if left[i] <= right[j]:\n A[k] = left[i]\n i += 1\n else:\n A[k] = right[j]\n j += 1","def merge(arr, p, q, r):\r\n assist = np.zeros(r-p+1)\r\n s = p\r\n t = q+1\r\n k = 0\r\n while s<=q and t<=r:\r\n if arr[s] < arr[t]:\r\n assist[k] = arr[s]\r\n s = s+1\r\n else:\r\n assist[k] = arr[t]\r\n t = t+1\r\n k = k+1\r\n if s == q+1:\r\n assist[k:r-p+1] = arr[t:r+1]\r\n else:\r\n assist[k:r-p+1] = arr[s:q+1]\r\n return assist","def merge(A, p, q, r):\n n_1 = q-p+1\n n_2 = r-q\n L = []\n R = []\n for i in range(n_1):\n L.append(A[p+i])\n for j in range(n_2):\n R.append(A[q+j+1])\n L.append(math.inf)\n R.append(math.inf)\n i = 0\n j = 0\n for k in range(p, r+1):\n if L[i] <= R[j]:\n A[k] = L[i]\n i += 1\n else:\n A[k] = R[j]\n j += 1","def insertionsortIndex(A:list, p:int, r:int) -> \"void\":\n\tfor i in range(p + 1, r + 1):\n\t\t\n\t\tkey = A[i]\n\t\tj = i - 1\n\n\t\twhile j >= p and key < A[j]:\n\t\t\tA[j+1] = A[j]\n\t\t\tj = j - 1\n\t\tA[j+1] = key","def quick_sort(array, p, r):\n if p < r:\n # Partition array[p..r]\n q = partition(array, p, r)\n # Recursively call quick-sort on lower partition\n quick_sort(array, p, q - 1)\n # Recursively call quick-sort on upper partition\n quick_sort(array, q + 1, r)\n return array","def merge_in_place(A, p, q, r):\n n_1 = q - p + 1\n n_2 = r - q\n L = 0\n R = 0\n for k in range(p, r+1):\n if A[p] <= A[q + 1]:\n A.insert(r+1, A[p])\n del A[p]\n L += 1\n q -= 1\n else:\n A.insert(r+1, A[q+1])\n del A[q+1]\n R += 1\n\n if L == n_1:\n A[r+1:r+1] = A[p:p+n_2-R]\n del A[p:p+n_2-R]\n break\n\n if R == n_2:\n A[r+1:r+1] = A[p:q+1]\n del A[p:q+1]\n break","def quickSort(array, p, r):\n if p < r:\n q = partition(array, p, r)\n quickSort(array,p, q-1)\n quickSort(array,q+1,r)","def quicksort(A, p, r):\n if p < r:\n q = partition(A, p, r)\n quicksort(A, p, q-1)\n quicksort(A, q + 1, r)","def merge(self, A, ind, p, q, r, rc_array):\n\n left = ind[p:q + 1]\n right = ind[q + 1:r + 1]\n\n i = 0\n j = 0\n ic = 0\n k = p\n\n while i < len(left) and j < len(right):\n if A[left[i]] > A[right[j]]:\n ind[k] = right[j]\n ic += 1\n k += 1\n j += 1\n else:\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n i += 1\n k += 1\n\n while i < len(left):\n rc_array[left[i]] = rc_array[left[i]] + ic\n ind[k] = left[i]\n k += 1\n i += 1\n while j < len(right):\n ind[k] = right[j]\n k += 1\n j += 1","def quicksort(input_, p, r):\n if p < r:\n j = partition(input_, p, r)\n quicksort(input_, p, j - 1)\n quicksort(input_, j + 1, r )","def merge_sort(data: List[Any]):\n if len(data) > 1:\n mid = len(data) // 2\n left = data[:mid]\n right = data[mid:]\n\n merge_sort(left)\n merge_sort(right)\n\n i = j = k = 0\n\n # Copy data to temp arrays L[] and R[]\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n data[k] = left[i]\n i += 1\n else:\n data[k] = right[j]\n j += 1\n k += 1\n\n # Checking if any element was left\n while i < len(left):\n data[k] = left[i]\n i += 1\n k += 1\n\n while j < len(right):\n data[k] = right[j]\n j += 1\n k += 1","def quicksort_random(A, p, r):\n if p < r:\n q = partition_random(A, p, r)\n quicksort_random(A, p, q-1)\n quicksort_random(A, q + 1, r)","def merge_sort(array):\n length = len(array)\n if length < 2:\n return array\n middle = length//2\n left = Merge.merge_sort(array[:middle])\n right = Merge.merge_sort(array[middle:])\n return Merge.merge(left, right)","def mergesort(self, input_array):\n if len(input_array) > 1:\n mid = len(input_array)//2\n left = self.mergesort(input_array[:mid])\n right = self.mergesort(input_array[mid:])\n val = self.sort(left,right)\n return val\n return input_array","def partition(array, p, r):\n # Choose pivot at end\n x = array[r]\n # Setup lower partition counter\n i = p - 1\n # For each element in array[p..r-1]\n for j in range(p, r):\n # If current item is leq than pivot\n if array[j] <= x:\n # Increment i anticipating a swap\n i += 1\n # Swap values at indices i and j in array\n array[i], array[j] = array[j], array[i]\n # Swap pivot with first element of upper sub-array, such that array[p..i] <= pivot <= array[i+2..r]\n array[i + 1], array[r] = array[r], array[i + 1]\n # Return index of pivot for further sorting\n return i + 1","def mergesort_iterative(array):\n n = len(array)\n result = array.copy()\n\n # Merge runs of length 1, 2, 4, 8, ...\n length = 1\n while length < n:\n # Merge each pair of runs\n for i in range(0, n, 2 * length):\n mid = i + length\n upper = i + 2 * length\n result[i:upper] = merge(result[i:mid], result[mid:upper])\n length *= 2\n\n return result","def merge_sort (arr):\n n = len(arr)\n if n is 1: # Base case.\n return arr\n else:\n left = merge_sort(arr[0:int(floor(n/2))])\n right = merge_sort(arr[int(ceil(n/2)):])\n res = merge(left, right)\n return res","def merge_sort(arr):\n if len(arr) == 0 or len(arr) == 1:\n return arr\n start = 0\n end = len(arr)\n mid = start + (end - start) // 2\n left = merge_sort(arr[start:mid])\n right = merge_sort(arr[mid:end])\n return merge(left, right)","def qsort(A, l, r):\n if l < r:\n q = partition(A, l, r)\n qsort(A, l, q-1)\n qsort(A, q+1, r)","def merge_sort(arr):\n\n # Base Case: Array has more than one element.\n if len(arr) > 1:\n\n # Middle must not be float number .\n mid = len(arr) // 2\n\n # Dividing array into 2 halves. On Prime numbers right half will always\n # has greater number of elements by one element.\n left_half = arr[:mid]\n right_half = arr[mid:]\n\n print(f\"Current array is: {arr}\")\n print(f\" Left of the array: {left_half}\")\n print(f\" Right of the array: {right_half} \\n\")\n\n # Each function will keep recurse until array has one element left.\n merge_sort(left_half)\n merge_sort(right_half)\n\n i = j = k = 0\n\n # Copy data to two temporarily arrays left_half[] and right_half[]\n while i < len(left_half) and j < len(right_half):\n if left_half[i] < right_half[j]:\n arr[k] = left_half[i]\n i += 1\n else:\n arr[k] = right_half[j]\n j += 1\n k += 1\n\n # Eventually the above loop will break due the imbalance\n # e.g. False and True, and biggest number from either left or right half\n # will be remained without being added to the temporarily array.\n while i < len(left_half):\n arr[k] = left_half[i]\n i += 1\n k += 1\n\n while j < len(right_half):\n arr[k] = right_half[j]\n j += 1\n k += 1","def __merge_sort(ar,temp,low,high):\n if low == high:\n return\n\n # divide and conqure\n middle = (low+high)//2\n __merge_sort(ar,temp,low,middle)\n __merge_sort(ar,temp,middle+1,high)\n\n # combine\n index = leftindex = low\n rightindex = middle+1\n\n while leftindex <= middle and rightindex <= high:\n if ar[leftindex] < ar[rightindex]:\n temp[index] = ar[leftindex]\n leftindex += 1\n index += 1\n else:\n temp[index] = ar[rightindex]\n rightindex += 1\n index += 1\n\n while leftindex <= middle:\n temp[index] = ar[leftindex]\n index += 1\n leftindex +=1\n\n while rightindex <= high:\n temp[index] =ar[rightindex]\n index += 1\n rightindex +=1\n\n assert index == high+1\n\n # copy back\n for i in xrange(low,high+1):\n ar[i] = temp[i]","def sort(self, nums: List[int]) -> None:\n if len(nums) <= 1: return\n\n # Find the middle of the array\n mid = len(nums) // 2\n\n # Split the array elements into two halves\n left = nums[:mid]\n right = nums[mid:]\n\n # Sort the left half\n self.sort(left)\n\n # Sort the right half\n self.sort(right)\n\n # Merge the left and right arrays into the original array\n i = j = k = 0\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n nums[k] = left[i]\n i += 1\n else:\n nums[k] = right[j]\n j += 1\n k += 1\n\n # Add the remaining elements of the left array if any\n while i < len(left):\n nums[k] = left[i]\n i += 1\n k += 1\n\n # Add the remaining elements of the right array if any\n while j < len(right):\n nums[k] = right[j]\n j += 1\n k += 1","def mergesort(array):\n if len(array) == 1:\n return array\n mid = len(array) // 2 # find the middle point of the array\n left = mergesort(array[:mid])\n right = mergesort(array[mid:])\n return merge(left, right)","def merge_sort(arr):\n if len(arr) <= 1:\n return arr\n mid = len(arr) // 2\n left = merge_sort(arr[:mid])\n right = merge_sort(arr[mid:])\n return merge(left,right)","def partition(A, p, r):\n x = A[r]\n i = p\n for j in range(p, r):\n if A[j] <= x:\n A[i], A[j] = A[j], A[i]\n i += 1\n A[i], A[r] = A[r], A[i]\n return i","def merge_sort(arr):\n if len(arr) <= 1:\n # nothing to sort\n return arr\n\n # split into left and right half\n left = arr[:len(arr) // 2]\n right = arr[len(arr) // 2:]\n\n # recursively sort each half\n left = merge_sort(left)\n right = merge_sort(right)\n\n # merge both sorted halves into a new array\n return merge(left, right)","def merge_sort(arr):\n n = len(arr)\n # Base case\n if n == 1:\n return arr\n # Recursive step: sort each half of the elements\n return merge(merge_sort(arr[:n//2]), merge_sort(arr[n//2:]))","def merge_sort(array):\n\n if len(array) <= 1: # base case\n return array\n\n # divide array in half and merge sort recursively\n half = len(array) // 2\n left = merge_sort(array[:half])\n right = merge_sort(array[half:])\n\n return merge(left, right)","def test_merge_sort(self):\n A = [5, 2, 4, 7, 1, 3, 2, 6]\n A_sorted = mst.merge_sort(A, 0, 8)\n self.assertEqual(A_sorted, [1, 2, 2, 3, 4, 5, 6, 7])","def partition(A:list, p:int, r:int) -> int:\n\n\tx = A[r]\n\ti = p - 1\n\tfor j in range(p, r):\n\t\tif A[j] <= x:\n\t\t\ti = i + 1\n\t\t\tA[i], A[j] = A[j], A[i]\n\tA[i+1], A[r] = A[r], A[i+1]\n\treturn i + 1","def mergesort(a):\n\n\n\n def merge(left,right):\n ll = len(left)\n lr = len(right)\n result = []\n i,j = 0,0\n while i < ll and j< lr:\n if left[i] <= right[j]:\n result.append(left[i])\n i+=1\n else:\n result.append(right[j])\n j+=1\n\n result += left[i:]\n result += right[j:]\n return result \n\n\n \n \n if len(a)<= 1:\n return a\n\n mid = len(a)//2\n left = mergesort(a[:mid])\n right = mergesort(a[mid:])\n return merge(left,right)","def mergesort_iterative_hybrid(array, threshold=37):\n n = len(array)\n result = array.copy()\n\n # Initial insertion sort pass\n for i in range(0, n, threshold):\n result[i:i+threshold] = insertion_sort(result[i:i+threshold])\n\n # Merge runs of length threshold, 2*threshold, ...\n length = threshold\n while length < n:\n # Merge each pair of runs\n for i in range(0, n, 2 * length):\n mid = i + length\n upper = i + 2 * length\n result[i:upper] = merge(result[i:mid], result[mid:upper])\n length *= 2\n\n return result","def custom_sort(arr):\n pass","def mergesort_recursive_hybrid(array, threshold=37):\n # Base case delegates to insertion sort\n n = len(array)\n if n <= threshold:\n return insertion_sort(array)\n\n # Recur on two halves of array and merge results\n mid = n // 2\n return merge(\n mergesort_recursive(array[:mid]),\n mergesort_recursive(array[mid:]))","def merge_sort_algorithm(self, low, high):\n if low < high:\n mid = (low + high) / 2\n self.merge_sort_algorithm(low, mid)\n self.merge_sort_algorithm(mid+1, high)\n self.merge(low, high, mid)","def partition_random(A, p, r):\n n = random.randint(p, r)\n A[n], A[r] = A[r], A[n]\n x = A[r]\n i = p-1\n for j in range(p, r):\n if A[j] <= x:\n i += 1\n A[i], A[j] = A[j], A[i]\n A[i+1], A[r] = A[r], A[i+1]\n return i+1","def mergesort(array):\n if len(array) == 1:\n return array\n else:\n mid = len(array) // 2\n return _subsort(mergesort(array[mid:]), mergesort(array[:mid]))","def sort(self, nums: List[int]) -> None:\n\n # Start at the 2nd element in the array\n for i in range(1, len(nums)):\n\n # Set the key to the beginning of the unsorted subarray\n key = nums[i]\n\n # Set a pointer to the end of the sorted subarray\n j = i-1\n\n # Shift elements in the sorted array to the right as needed\n # until the correct position for the key is found\n while j >= 0 and key < nums[j]:\n nums[j+1] = nums[j]\n j -= 1\n\n # Set the key to the found position\n nums[j+1] = key","def solve_inplace(array1, array2):\n # append all b values to end of a and then sort\n pass","def quicksortSimple(A:list, p:int, r:int) -> \"void\":\n\n\ttamanoSecuencia = r - p + 1\n\n\tif tamanoSecuencia <= 32 and p < r:\t\n\t\tinsertionsortIndex(A, p, r)\n\n\n\telif tamanoSecuencia > 32 and p < r:\n\t\tq = partition(A, p, r)\t\n\t\tquicksortSimple(A, p, q-1)\n\t\tquicksortSimple(A, q+1, r)\n\n\t# Para usarse se llama: quickSort(arreglo, 0, len(arreglo) - 1)","def qsort(array, left, right):\n if left < right:\n p_ind_new = partition(array, left, right)\n qsort(array, left, p_ind_new-1)\n qsort(array, p_ind_new+1, right)","def merge_sort(self, data):\n print \"Splitting\", data\n if len(data) > 1:\n mid = len(data)// 2\n left_half = data[:mid]\n right_half = data[mid:]\n self.merge_sort(left_half)\n self.merge_sort(right_half)\n i,j,k = (0,0,0)\n while i< len(left_half) and j<len(right_half):\n if left_half[i] < right_half[j]:\n data[k] = left_half[i]\n i += 1\n else:\n data[k] = right_half[j]\n j += 1\n k += 1\n #take care of the unbalance\n while i < len(left_half):\n data[k] = left_half[i]\n i += 1\n k += 1\n while j < len(right_half):\n data[k] = right_half[j]\n j += 1\n k += 1\n print \"merging\", data","def sort(self, nums: List[int]) -> None:\n n = len(nums)\n for i in range(n):\n\n # Set the lowest to the beginning of the unsorted subarray\n low = i\n for j in range(i+1,n):\n\n # Find the lowest in the unsorted array\n if nums[j] < nums[low]:\n low = j\n \n # Swap the beginning of the unsorted subarray and the lowest.\n # The beginning of the unsorted subarray now becomes the end of the sorted subarray\n nums[i], nums[low] = nums[low], nums[i]","def sort(self, left_arr, right_arr):\n sorted_array = []\n left_ind, right_ind = 0,0\n while left_ind < len(left_arr) and right_ind < len(right_arr):\n if left_arr[left_ind] < right_arr[right_ind]:\n sorted_array.append(left_arr[left_ind])\n left_ind += 1\n else: \n sorted_array.append(right_arr[right_ind])\n right_ind += 1\n if left_ind == len(left_arr):\n sorted_array.extend(right_arr[right_ind:])\n else:\n sorted_array.extend(left_arr[left_ind:])\n return sorted_array","def merge_sort(arr, start, end):\n if len(arr) <= 1:\n return\n if start >= end:\n return\n\n mid = int((start + end) / 2)\n merge_sort(arr, start, mid)\n merge_sort(arr, mid+1, end)\n merging(arr, start, mid, mid+1, end)","def merge(A, left, middle, right):\n leftSubArray = A[left:middle]\n rightSubArray = A[middle:right+1]\n leftSubArray.append(float(\"inf\"))\n rightSubArray.append(float(\"inf\"))\n i = j = 0\n for k in xrange(left, right + 1):\n if leftSubArray[i] < rightSubArray[j]:\n A[k] = leftSubArray[i]\n i += 1\n else:\n A[k] = rightSubArray[j]\n j += 1\n return A","def mergeunsort(arr, inv_seq):\n\tif len(arr) <= 1:\n\t\treturn list(arr)\n\tcut_idx = (len(arr) + 1) / 2\n\tleft = arr[:cut_idx]\n\tright = arr[cut_idx:]\n\tleft = mergeinvert(left, inv_seq)\n\tright = mergeinvert(right, inv_seq)\n\treturn invert_merge(left, right, inv_seq)","def dualPivotQuicksort(A:list, left:int, right:int) -> \"void\":\n\n\tif right - left <= 32:\t\t\n\t\tinsertionsortIndex(A, left, right)\n\telse:\n\t\tif A[left] > A[right]:\n\t\t\tp, q = A[right], A[left]\n\t\telse:\n\t\t\tp, q = A[left], A[right]\n\t\tl, g = left + 1, right - 1\n\t\tk = l\n\n\t\twhile k <= g:\n\t\t\tif A[k] < p:\n\t\t\t\tA[k], A[l] = A[l], A[k]\n\t\t\t\tl = l + 1\n\t\t\telse:\n\t\t\t\tif A[k] >= q:\n\n\t\t\t\t\twhile A[g] > q and k < g:\n\t\t\t\t\t\tg = g - 1\n\n\t\t\t\t\tif A[g] >= p:\n\t\t\t\t\t\tA[k], A[g] = A[g], A[k]\n\t\t\t\t\telse:\n\t\t\t\t\t\tA[k], A[g] = A[g], A[k]\n\t\t\t\t\t\tA[k], A[l] = A[l], A[k]\n\t\t\t\t\t\tl = l + 1\n\n\t\t\t\t\tg = g - 1\t\t\t\t\t\n\t\t\tk = k + 1\n\n\t\tl = l - 1\n\t\tg = g + 1\n\t\tA[left] = A[l]\n\t\tA[l] = p\n\t\tA[right] = A[g]\n\t\tA[g] = q\n\t\tdualPivotQuicksort(A, left, l-1)\n\t\tdualPivotQuicksort(A, l+1, g-1)\n\t\tdualPivotQuicksort(A, g+1, right)\n\n\t\t# Debe llamarse con: dualPivotQuicksort(A, 0, len(A)-1)","def random_qsort(A, l, r):\n if l < r:\n q = random_partition(A, l, r)\n random_qsort(A, l, q-1)\n random_qsort(A, q+1, r)","def _quicksort(self, l, r):\n\t\tif l < r:\n\t\t\tsplitpoint = self._partition(l, r)\n\t\t\tself._quicksort(l, splitpoint-1)\n\t\t\tself._quicksort(splitpoint+1, r)","def test_20el_sorted_array(self):\n res = merge_sort([1, 2, 3, 4, 5, 6, 7, 8, 9,\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])","def merge_sort (t,cmp):\n n = len(t)\n if n <= 1:\n # cas de base\n return copy.deepcopy(t)\n else:\n # cas general\n t1 = merge_sort((t[0:((n-1)//2+1)]),cmp)\n t2 = merge_sort((t[((n-1)//2+1):n]),cmp)\n return merge(t1,t2,cmp)","def RInsertionSort(array):\n\n if not isinstance(array, np.ndarray):\n raise TypeError('_container is not ndarray') \n\n # Get array\n n = len(array)\n fhelper(array, 1, n)","def mergesort(arr):\n if type(arr) is not list:\n raise TypeError('argument must be list of integers')\n\n if len(arr) <= 1:\n return arr \n\n def recurse(arr):\n half = len(arr)//2\n left = []\n right = []\n\n for i in range(half):\n left = left + [arr[i]]\n right = right + [arr[len(arr) - 1 - i]]\n # print('split', left, right)\n if len(left) > 1:\n left = recurse(left)\n if len(right) > 1:\n right = recurse(right)\n \n return merge(left, right) \n \n def merge(left, right):\n output = []\n i = 0\n j = 0\n while i < len(left) and j < len(right):\n if left[i] <= right[j]:\n output.append(left[i])\n i = i + 1\n elif left[i] >= right[j]:\n output.append(right[j])\n j = j + 1\n # print('merging', left, right, '=>', output)\n output.extend(left[i:])\n output.extend(right[j:])\n\n # print('merged', output, '\\n')\n return output\n\n return recurse(arr)","def merge_sort(a_list):\n\n if len(a_list) > 1:\n mid = len(a_list) // 2\n left_half = a_list[:mid]\n right_half = a_list[mid:]\n\n merge_sort(left_half)\n merge_sort(right_half)\n\n i = 0\n j = 0\n k = 0\n while i < len(left_half) and j < len(right_half):\n if left_half[i] < right_half[j]:\n a_list[k] = left_half[i]\n i += 1\n else:\n a_list[k] = right_half[j]\n j += 1\n k += 1\n\n while i < len(left_half):\n a_list[k] = left_half[i]\n i += 1\n k += 1\n\n while j < len(right_half):\n a_list[k] = right_half[j]\n j += 1\n k += 1\n return a_list","def mergesort(arr):\n len_arr = len(arr)\n if len_arr <= 1:\n return arr\n\n middle = len_arr / 2\n front = mergesort(arr[:middle])\n back = mergesort(arr[middle:])\n\n return merge(front, back)","def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\n # # solution one: sort\n # A[m:] = B\n # A.sort()\n\n # solution two: two point\n if n == 0: # B = []\n return\n i, j, k = m - 1, n - 1, m + n - 1\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\n if A[i] <= B[j]:\n A[k] = B[j]\n k -= 1\n j -= 1\n else:\n A[k] = A[i]\n k -= 1\n i -= 1\n if j > -1:\n A[:j + 1] = B[:j + 1] # A = [], B = [1]","def merge_sort(arr):\r\n if len(arr) == 1:\r\n return arr\r\n middle = len(arr) // 2\r\n first_half = merge_sort(arr[:middle])\r\n second_half = merge_sort(arr[middle:])\r\n return merge(first_half, second_half)","def mergesort(arr1, option):\n length = len(arr1)\n if length < 2:\n return arr1\n # make a copy, since mergesort needs O(n) space\n arr2 = arr1[:]\n step = 1\n while step < length:\n i, curr = 0, 0 # beginning of each pair, current write point\n while i + step < length:\n left, right = i, i + step\n while curr < length and curr < i + 2 * step:\n if right == length or right == i + 2 * step:\n arr2[curr] = arr1[left]\n left += 1\n elif left == i + step:\n arr2[curr] = arr1[right]\n right += 1\n elif arr1[left] <= arr1[right]:\n arr2[curr] = arr1[left]\n left += 1\n elif arr1[left] > arr1[right]:\n arr2[curr] = arr1[right]\n right += 1\n curr += 1\n i += 2 * step\n # important: copy the untouched end to the new array. It's not applied yet\n while curr < length:\n arr2[curr] = arr1[curr]\n curr += 1\n step *= 2\n # swap two arrays for cost efficiency\n arr1, arr2 = arr2, arr1\n return arr1","def sort(arr, filename):\n if len(arr) > 1:\n mid = len(arr) // 2 # Finding the mid of the array\n L = arr[:mid] # Dividing the array elements\n R = arr[mid:] # into 2 halves\n sort(L, filename) # Sorting the first half\n sort(R, filename) # Sorting the second half\n\n i = j = k = 0\n\n # Copy data to temp arrays L[] and R[]\n while i < len(L) and j < len(R):\n if L[i] < R[j]:\n arr[k] = L[i]\n i += 1\n else:\n arr[k] = R[j]\n j += 1\n k += 1\n\n # Checking if any element was left\n while i < len(L):\n arr[k] = L[i]\n i += 1\n k += 1\n\n while j < len(R):\n arr[k] = R[j]\n j += 1\n k += 1\n with open(\"output/temp/\" + filename, \"w\") as file:\n for item in arr:\n file.write('%s\\n' % item)","def merge(array, left, middle, right):\n\n len1 = middle - left + 1\n len2 = right - middle\n\n left_side = array[left: left + len1]\n right_side = array[middle + 1: middle + len2 + 1]\n\n i = j = 0\n k = left\n\n while i < len1 and j < len2:\n if left_side[i] <= right_side[j]:\n array[k] = left_side[i]\n i += 1\n else:\n array[k] = right_side[j]\n j += 1\n\n k += 1\n\n while i < len1:\n array[k] = left_side[i]\n i += 1\n k += 1\n\n while j < len2:\n array[k] = right_side[j]\n j += 1\n k += 1","def merge_sort(L):\n n = len(L)\n if n < 2:\n return L\n mid = n // 2\n left = L[:mid]\n right = L[mid:]\n merge_sort(left)\n merge_sort(right)\n merge(L, left, right)","def test_20el_shuffled_array(self):\n res = merge_sort([2, 11, 17, 16, 14, 19, 15, 9, 12,\n 5, 1, 18, 4, 20, 7, 3, 8, 10, 13, 6])\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])","def mergesort_recursive(array):\n # Base case for empty or singular list\n n = len(array)\n if n < 2:\n return array\n\n # Recur on two halves of array and merge results\n mid = n // 2\n return merge(\n mergesort_recursive(array[:mid]),\n mergesort_recursive(array[mid:]))","def _merge(arr, temp, left, mid, right):\n i = left\n j = mid\n k = left\n inv_count = 0\n while i < mid and j <= right:\n if arr[i] < arr[j]:\n temp[k] = arr[i]\n k += 1\n i += 1\n else:\n temp[k] = arr[j]\n k += 1\n j += 1\n inv_count += (mid -i)\n while i < mid:\n temp[k] = arr[i]\n k += 1\n i += 1\n if j <= right:\n k += right - j + 1\n j += right - j + 1\n arr[left:k + 1] = temp[left:k + 1]\n else:\n arr[left:right + 1] = temp[left:right + 1]\n return inv_count","def merge_sort(nums):\n\n if len(nums) == 1:\n return nums\n\n mid = len(nums)/2 \n left_part = merge_sort(nums[:mid]) \n right_part = merge_sort(nums[mid:]) \n merged = merge(left_part,right_part) \n return merged","def merge_sort(array: list):\n\n # check if the list is not empty and is greater than one element\n if len(array) > 1:\n # get the middle of the list, do an integer division, we don't need decimals\n # assign a left part and a right part\n middle = len(array) // 2\n left_half = array[:middle]\n right_half = array[middle:]\n\n # call merge_sort recursively to keep dividing the list\n merge_sort(left_half)\n merge_sort(right_half)\n\n i = 0 # used to track left half of the list\n j = 0 # used to track right side of the list\n k = 0 # used to track the array itself\n\n # merge both left and right part of the list\n while i < len(left_half) and j < len(right_half):\n if left_half[i] <= right_half[j]:\n array[k] = left_half[i]\n i += 1\n else:\n array[k] = right_half[j]\n j += 1\n k += 1\n\n # merge the left half in an ordered fashion\n while i < len(left_half):\n array[k] = left_half[i]\n i += 1\n k += 1\n\n # merge the right half in an ordered fashion\n while j < len(right_half):\n array[k] = right_half[j]\n j += 1\n k += 1\n\n return array","def merge_sort(arr: list, start: int, end: int):\n if end == start:\n return [arr[start]]\n else:\n mid = start + (end - start)//2\n left = merge_sort(arr, start, mid)\n right = merge_sort(arr, mid+1, end)\n sorted_arr = merge(left, right)\n return sorted_arr","def heap_sort(self, A):\n pass","def heap_sort(self, A):\n pass","def merge(l, r):\n print(\"merge [l={}, r={}]\".format(l, r))\n t = [None] * (len(l) + len(r))\n ti = 0\n \n i, j = 0, 0\n\n while i < len(l) and j < len(r):\n if l[i] <= r[j]:\n t[ti] = l[i]\n i += 1\n else:\n t[ti] = r[j]\n j += 1\n ti += 1\n\n # copy remaining items from one of either l or r...\n if i < len(l):\n while i < len(l):\n t[ti] = l[i]\n i += 1\n ti += 1\n else:\n while j < len(r):\n t[ti] = r[j]\n j+= 1\n ti += 1\n\n return t","def merge_sort(items, key):\n # Check endcase\n if (len(items) / 2) > 1:\n global COMPARE\n # Pivot point/middle\n pivot = int(len(items) / 2)\n # Recursive call\n left = merge_sort(items[0:pivot], key)\n right = merge_sort(items[pivot:len(items)], key)\n # Init the variables\n l_index = r_index = 0\n merged = []\n # Merging\n while (l_index < len(left)) and (r_index < len(right)):\n # If right index is larger, append left[index]; increase l. index\n if COMPARE(right[r_index], left[l_index]):\n merged.append(left[l_index])\n l_index += 1\n # If left index is larger, append right[index]; increase r. index\n elif COMPARE(left[l_index], right[r_index]):\n merged.append(right[r_index])\n r_index += 1\n # Add remaining merge\n if(l_index == len(left)):\n merged.extend(right[r_index:])\n elif(r_index == len(left)):\n merged.extend(left[l_index:])\n # Return list\n return merged\n else:\n # End of the line!\n return bubble_sort(items, key)","def merge_sort(data):\r\n\r\n if not data or len(data) == 1:\r\n # return if list size is 0 or 1\r\n return data\r\n else:\r\n # split data list in half\r\n middle = int(len(data) / 2)\r\n a = merge_sort(data[:middle])\r\n b = merge_sort(data[middle:])\r\n # user merge function to merge the two halves\r\n # back together while also sorting them\r\n return merge(a, b)","def merge_sort(aList):\n\n n = len(aList)\n\n # Check for base case\n if n <= 1:\n return aList\n\n # Split the list into two halves and call recursively\n first = merge_sort(aList[0:int(n/2)])\n\n second = merge_sort(aList[int(n/2):n])\n\n #pdb.set_trace()\n\n # Perform Merge of two sorted lists\n # Initialize counters, lengths and the newly sorted array\n i, j = 0, 0\n firstLen = len(first)\n secondLen = len(second)\n\n sortedList = []\n\n # Populate the sorted list with the lesser of each half-list\n for k in range(n):\n\n # Make sure we won't try to access past the end of a list\n # If we've reached the end of the first array, then\n # add the element from the second array.\n if i == firstLen:\n sortedList.append(second[j])\n j += 1\n\n # If we've reached the end of the second array, add\n # the element from the first array\n elif j == secondLen:\n sortedList.append(first[i])\n i += 1\n\n # The normal case (before we've reached the end of either array)\n elif first[i] < second[j]:\n sortedList.append(first[i])\n i += 1\n\n else:\n sortedList.append(second[j])\n j += 1\n\n\n return sortedList","def merge_sort(S):\n n = len(S)\n if n < 2:\n return\n\n # devide\n mid = n//2\n S1 = S[0:mid]\n S2 = S[mid:n]\n\n # conquer\n merge_sort(S1)\n merge_sort(S2)\n\n # merge results\n i = j = 0\n while i + j < len(S):\n if j == len(S2) or (i < len(S1) and S1[i] < S2[j]):\n S[i + j] = S1[i]\n i += 1\n else:\n S[i + j] = S2[j]\n j += 1","def sort(self, nums: List[int]) -> None:\n\n # Seperates negative and positive integers\n neg, pos = [], []\n for num in nums:\n if num < 0:\n neg.append(-num)\n else:\n pos.append(num)\n\n # Sorts the negative numbers\n self._sort(neg)\n neg.reverse()\n\n # Sorts the positiv numbers\n self._sort(pos)\n \n # Remerges the sorted subarrays back into the original array.\n i = j = k = 0\n while j < len(neg):\n nums[i] = -neg[j]\n j += 1\n i += 1\n\n while k < len(pos):\n nums[i] = pos[k]\n k += 1\n i += 1","def sa_sort(arr: StaticArray) -> None:\n length = arr.size()\n iteration_count = 0\n while iteration_count < (length / 2):\n # sets default values to the next first element\n minimum = arr[iteration_count]\n maximum = arr[iteration_count]\n min_old_index = iteration_count\n max_old_index = iteration_count\n\n # loops through the array to find the smallest and largest elements\n for index in range(iteration_count, (length - iteration_count)):\n\n if arr[index] < minimum:\n minimum = arr[index]\n min_old_index = index\n elif arr[index] > maximum:\n maximum = arr[index]\n max_old_index = index\n\n max_pos = (length - 1) - iteration_count # sets index for next last position\n\n # checks that previously sorted values will not be overwritten\n if arr[iteration_count] != minimum:\n if arr[min_old_index] != maximum and min_old_index > iteration_count:\n # swaps min and element where min was\n arr[min_old_index] = arr[iteration_count]\n else:\n # if swapping would overwrite, then places old value where max was\n arr[max_old_index] = arr[iteration_count]\n # sets smallest value at the next first position\n arr[iteration_count] = minimum\n # checks that previously sorted values will not be overwritten\n if arr[max_pos] != maximum:\n if arr[max_old_index] != minimum and max_old_index < max_pos:\n # swaps max and element where max was\n arr[max_old_index] = arr[max_pos]\n else:\n # if swapping would overwrite, then places old value where min was\n arr[min_old_index] = arr[max_pos]\n arr[max_pos] = maximum\n\n iteration_count += 1","def merge(nums1, m, nums2, n):\r\n if not nums2:\r\n return\r\n\r\n while m > 0 and n > 0:\r\n # the current element of the final sorted array is the smaller of nums2[n -1] and nums1[m - 1]\r\n if nums2[n - 1] < nums1[m - 1]:\r\n nums1[m + n - 1] = nums1[m - 1]\r\n m -= 1\r\n else:\r\n nums1[m + n - 1] = nums2[n - 1]\r\n n -= 1\r\n nums1[:n] = nums2[:n]","def mergeSortedArrays(nums1, m, nums2, n):","def quicksort(arr, left, right, debug=False):\n if left >= right:\n # Base case where left reference and right reference has cross the\n # pivot\n return\n\n if debug: print(\"before index: left={} right={}\".format(left, right))\n\n # Conquer the problem by sorting in this partition\n index = partition(arr, left, right)\n\n if debug:\n print(\"after index left={} right={} index={}\"\n .format(left, right, index))\n print()\n\n # Divide the problem into smaller arrays\n quicksort(arr, left, index - 1)\n quicksort(arr, index, right)","def merge_sort(a, b):\n l = []\n while a and b:\n if a[0] < b[0]:\n l.append(a.pop(0))\n else:\n l.append(b.pop(0))\n return l + a + b","def quicksort(array):\n left, right = 0, len(array) - 1\n initial_pivot(array,right)\n qsort(array,left,right)","def insertionSort(self, array, left_index, right_index):\n for index in range(left_index + 1, right_index):\n temp = array[index]\n upper_pointer = index - 1\n # short the section\n while array[upper_pointer] > temp and upper_pointer >= left_index:\n # swap the elements\n array[upper_pointer + 1] = array[upper_pointer]\n # decrement pointer\n upper_pointer -= 1\n array[upper_pointer + 1] = temp\n return array","def mergesort(sequence):\n\tif len(sequence) <= 1:\n\t\treturn sequence\n\n\tmiddle_index = len(sequence) // 2\n\tleft_half = mergesort(sequence[:middle_index])\n\tright_half = mergesort(sequence[middle_index:])\n\n\treturn merge(left_half, right_half)","def mergesort(T:list) -> \"void\":\n\n\tif len(T) <= 32:\n\t\tinsertionsort(T)\n\n\telse:\n\t\tU = T[0:len(T)//2]\n\t\tV = T[len(T)//2:len(T)]\n\t\tmergesort(U)\n\t\tmergesort(V)\n\t\tmerge(U, V, T)","def quicksort(array, left = 0, right = None):\n def choose_pivot(array, left, right, method = 'RANDOM'):\n if method == 'RANDOM':\n return np.random.randint(left, right+1)\n\n def partition(array, pivot, left, right):\n def swap(array, i, j):\n tmp = array[i]\n array[i] = array[j]\n array[j] = tmp\n\n # Move pivot to first element\n swap(array, left, pivot)\n\n # i is the first element greater than the pivot\n i = left + 1\n\n # Run j through the list comparing each element to the pivot\n for j in range(left + 1, right + 1):\n # If it is less than the pivot, move to the left section and increase size of that by 1\n if array[j] < array[pivot]:\n swap(array, i, j)\n i += 1\n\n # Move the pivot into position\n swap(array, left, i - 1)\n\n\n if right is None:\n right = len(array) - 1\n\n # Base case:\n if right - left <= 0:\n return\n\n pivot = choose_pivot(array, left, right)\n partition(array, pivot, left, right)\n quicksort(array, left, pivot - 1)\n quicksort(array, pivot + 1, right)","def merge_sort(unsorted, threshold, reverse):\r\n length = len(unsorted)\r\n if length < 2:\r\n return unsorted\r\n elif length < threshold:\r\n return insertion_sort(unsorted, reverse)\r\n else:\r\n mid = length//2\r\n list1 = unsorted[0:mid]\r\n list2 = unsorted[mid:length]\r\n list1 = merge_sort(list1, threshold, reverse)\r\n list2 = merge_sort(list2, threshold, reverse)\r\n unsorted = merge(list1, list2, reverse)\r\n return unsorted","def merge_sort(S):\n n = len(S)\n if n < 2:\n return\n mid = n // 2\n S1 = S[0:mid]\n S2 = S[mid:n]\n merge_sort(S1)\n merge_sort(S2)\n merge(S1, S2, S)","def fastsort(a):\n # TODO: the wording in the docstring is nonsense.\n it = np.argsort(a)\n as_ = a[it]\n return as_, it","def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\n A[m:] = B\n A.sort()","def merge_sort(alist):\n print(\"Splitting \", alist)\n # Temporary list to store sorted list\n work = [None] * len(alist)\n rec_merge_sort(work, start=0, end=len(alist)-1)","def merge(L, left, right):\n i = j = 0\n while i < len(left) and j < len(right):\n if left[i] < right[j]:\n L[i + j] = left[i]\n i += 1\n else:\n L[i + j] = right[j]\n j += 1\n while i < len(left):\n L[i + j] = left[i]\n i += 1\n while j < len(right):\n L[i + j] = right[j]\n j += 1","def merge_sort(aList):\n #If the aList is size 0 or 1, it's already sorted.\n if len(aList) <= 1:\n return aList\n\n else:\n mid = len(aList) // 2\n\n # Recursively sort the left and right halves\n left = merge_sort(aList[:mid])\n right = merge_sort(aList[mid:])\n \n # Merge the two (each sorted) parts back together\n return merge(left, right)","def oldsortslice(self):\n ...","def shell_sort(A):\r\n inc = len(A) // 2\r\n while inc:\r\n for i in range(len(A)):\r\n j = i\r\n temp = A[i]\r\n while j >= inc and A[j-inc] > temp:\r\n A[j] = A[j - inc]\r\n j -= inc\r\n A[j] = temp\r\n inc = inc//2 if inc//2 else (0 if inc == 1 else 1)\r\n return A","def sort(array):\n\n for i in range(0, len(array)):\n for j in range(len(array)-1, i, -1):\n if array[j] < array[j-1]:\n ## Move the lighter bubble up\n _temp = array[j]\n array[j] = array[j-1]\n array[j-1] = _temp\n \n return array","def bottom_up_merge_sort(items):\n subarray_size = 1\n\n while subarray_size < len(items)//2:\n ## Continue making passes through items until the subarray size is\n ## the size of items, since this means items is finally sorted.\n for i in range(0, len(items), subarray_size):\n merge(items, i, i+subarray_size*2, subarray_size)\n subarray_size *= 2"],"string":"[\n \"def mergesort(A, p, r):\\n if p < r:\\n q = (p+r)//2\\n mergesort(A, p, q)\\n mergesort(A, q + 1, r)\\n merge(A, p, q, r)\",\n \"def sort(self, A, index, p, r, rc_arr):\\n\\n if p < r:\\n q = (p + r) // 2\\n\\n self.sort(A, index, p, q, rc_arr)\\n self.sort(A, index, q + 1, r, rc_arr)\\n self.merge(A, index, p, q, r, rc_arr)\",\n \"def merge(A, p, q, r):\\n\\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\\n n1 = q - p + 1 # will hold A[p..q]\\n n2 = r - q # will hold A[q+1..r]\\n\\n L = [0] * (n1 + 1)\\n R = [0] * (n2 + 1)\\n \\n for i in range(n1):\\n L[i] = A[p+i]\\n for j in range(n2):\\n R[j] = A[q+j+1]\\n\\n # add sentinels\\n L[n1] = float('inf')\\n R[n2] = float('inf')\\n\\n # instead of sentinels, we can check if either L or R is empty,\\n # and copy the non-empty subarray back into A. (p. 37, ex. 2.3-2)\\n \\n # indices of subarrays L and R (both already previously sorted)\\n i = 0\\n j = 0\\n\\n for k in range(p, r+1):\\n if L[i] <= R[j]:\\n A[k] = L[i]\\n i += 1\\n else:\\n A[k] = R[j]\\n j += 1\",\n \"def merge(A, p, q, r):\\n left, right = [], []\\n for i in range(p, q + 1):\\n left.append(A[i])\\n\\n for j in range(q + 1, r + 1):\\n right.append(A[j])\\n\\n i, j = 0, 0\\n for k in range(p, r + 1):\\n if i > q - p:\\n A[k] = right[j]\\n j += 1\\n continue\\n if j > r - q - 1:\\n A[k] = left[i]\\n i += 1\\n continue\\n\\n if left[i] <= right[j]:\\n A[k] = left[i]\\n i += 1\\n else:\\n A[k] = right[j]\\n j += 1\",\n \"def merge(arr, p, q, r):\\r\\n assist = np.zeros(r-p+1)\\r\\n s = p\\r\\n t = q+1\\r\\n k = 0\\r\\n while s<=q and t<=r:\\r\\n if arr[s] < arr[t]:\\r\\n assist[k] = arr[s]\\r\\n s = s+1\\r\\n else:\\r\\n assist[k] = arr[t]\\r\\n t = t+1\\r\\n k = k+1\\r\\n if s == q+1:\\r\\n assist[k:r-p+1] = arr[t:r+1]\\r\\n else:\\r\\n assist[k:r-p+1] = arr[s:q+1]\\r\\n return assist\",\n \"def merge(A, p, q, r):\\n n_1 = q-p+1\\n n_2 = r-q\\n L = []\\n R = []\\n for i in range(n_1):\\n L.append(A[p+i])\\n for j in range(n_2):\\n R.append(A[q+j+1])\\n L.append(math.inf)\\n R.append(math.inf)\\n i = 0\\n j = 0\\n for k in range(p, r+1):\\n if L[i] <= R[j]:\\n A[k] = L[i]\\n i += 1\\n else:\\n A[k] = R[j]\\n j += 1\",\n \"def insertionsortIndex(A:list, p:int, r:int) -> \\\"void\\\":\\n\\tfor i in range(p + 1, r + 1):\\n\\t\\t\\n\\t\\tkey = A[i]\\n\\t\\tj = i - 1\\n\\n\\t\\twhile j >= p and key < A[j]:\\n\\t\\t\\tA[j+1] = A[j]\\n\\t\\t\\tj = j - 1\\n\\t\\tA[j+1] = key\",\n \"def quick_sort(array, p, r):\\n if p < r:\\n # Partition array[p..r]\\n q = partition(array, p, r)\\n # Recursively call quick-sort on lower partition\\n quick_sort(array, p, q - 1)\\n # Recursively call quick-sort on upper partition\\n quick_sort(array, q + 1, r)\\n return array\",\n \"def merge_in_place(A, p, q, r):\\n n_1 = q - p + 1\\n n_2 = r - q\\n L = 0\\n R = 0\\n for k in range(p, r+1):\\n if A[p] <= A[q + 1]:\\n A.insert(r+1, A[p])\\n del A[p]\\n L += 1\\n q -= 1\\n else:\\n A.insert(r+1, A[q+1])\\n del A[q+1]\\n R += 1\\n\\n if L == n_1:\\n A[r+1:r+1] = A[p:p+n_2-R]\\n del A[p:p+n_2-R]\\n break\\n\\n if R == n_2:\\n A[r+1:r+1] = A[p:q+1]\\n del A[p:q+1]\\n break\",\n \"def quickSort(array, p, r):\\n if p < r:\\n q = partition(array, p, r)\\n quickSort(array,p, q-1)\\n quickSort(array,q+1,r)\",\n \"def quicksort(A, p, r):\\n if p < r:\\n q = partition(A, p, r)\\n quicksort(A, p, q-1)\\n quicksort(A, q + 1, r)\",\n \"def merge(self, A, ind, p, q, r, rc_array):\\n\\n left = ind[p:q + 1]\\n right = ind[q + 1:r + 1]\\n\\n i = 0\\n j = 0\\n ic = 0\\n k = p\\n\\n while i < len(left) and j < len(right):\\n if A[left[i]] > A[right[j]]:\\n ind[k] = right[j]\\n ic += 1\\n k += 1\\n j += 1\\n else:\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n i += 1\\n k += 1\\n\\n while i < len(left):\\n rc_array[left[i]] = rc_array[left[i]] + ic\\n ind[k] = left[i]\\n k += 1\\n i += 1\\n while j < len(right):\\n ind[k] = right[j]\\n k += 1\\n j += 1\",\n \"def quicksort(input_, p, r):\\n if p < r:\\n j = partition(input_, p, r)\\n quicksort(input_, p, j - 1)\\n quicksort(input_, j + 1, r )\",\n \"def merge_sort(data: List[Any]):\\n if len(data) > 1:\\n mid = len(data) // 2\\n left = data[:mid]\\n right = data[mid:]\\n\\n merge_sort(left)\\n merge_sort(right)\\n\\n i = j = k = 0\\n\\n # Copy data to temp arrays L[] and R[]\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n data[k] = left[i]\\n i += 1\\n else:\\n data[k] = right[j]\\n j += 1\\n k += 1\\n\\n # Checking if any element was left\\n while i < len(left):\\n data[k] = left[i]\\n i += 1\\n k += 1\\n\\n while j < len(right):\\n data[k] = right[j]\\n j += 1\\n k += 1\",\n \"def quicksort_random(A, p, r):\\n if p < r:\\n q = partition_random(A, p, r)\\n quicksort_random(A, p, q-1)\\n quicksort_random(A, q + 1, r)\",\n \"def merge_sort(array):\\n length = len(array)\\n if length < 2:\\n return array\\n middle = length//2\\n left = Merge.merge_sort(array[:middle])\\n right = Merge.merge_sort(array[middle:])\\n return Merge.merge(left, right)\",\n \"def mergesort(self, input_array):\\n if len(input_array) > 1:\\n mid = len(input_array)//2\\n left = self.mergesort(input_array[:mid])\\n right = self.mergesort(input_array[mid:])\\n val = self.sort(left,right)\\n return val\\n return input_array\",\n \"def partition(array, p, r):\\n # Choose pivot at end\\n x = array[r]\\n # Setup lower partition counter\\n i = p - 1\\n # For each element in array[p..r-1]\\n for j in range(p, r):\\n # If current item is leq than pivot\\n if array[j] <= x:\\n # Increment i anticipating a swap\\n i += 1\\n # Swap values at indices i and j in array\\n array[i], array[j] = array[j], array[i]\\n # Swap pivot with first element of upper sub-array, such that array[p..i] <= pivot <= array[i+2..r]\\n array[i + 1], array[r] = array[r], array[i + 1]\\n # Return index of pivot for further sorting\\n return i + 1\",\n \"def mergesort_iterative(array):\\n n = len(array)\\n result = array.copy()\\n\\n # Merge runs of length 1, 2, 4, 8, ...\\n length = 1\\n while length < n:\\n # Merge each pair of runs\\n for i in range(0, n, 2 * length):\\n mid = i + length\\n upper = i + 2 * length\\n result[i:upper] = merge(result[i:mid], result[mid:upper])\\n length *= 2\\n\\n return result\",\n \"def merge_sort (arr):\\n n = len(arr)\\n if n is 1: # Base case.\\n return arr\\n else:\\n left = merge_sort(arr[0:int(floor(n/2))])\\n right = merge_sort(arr[int(ceil(n/2)):])\\n res = merge(left, right)\\n return res\",\n \"def merge_sort(arr):\\n if len(arr) == 0 or len(arr) == 1:\\n return arr\\n start = 0\\n end = len(arr)\\n mid = start + (end - start) // 2\\n left = merge_sort(arr[start:mid])\\n right = merge_sort(arr[mid:end])\\n return merge(left, right)\",\n \"def qsort(A, l, r):\\n if l < r:\\n q = partition(A, l, r)\\n qsort(A, l, q-1)\\n qsort(A, q+1, r)\",\n \"def merge_sort(arr):\\n\\n # Base Case: Array has more than one element.\\n if len(arr) > 1:\\n\\n # Middle must not be float number .\\n mid = len(arr) // 2\\n\\n # Dividing array into 2 halves. On Prime numbers right half will always\\n # has greater number of elements by one element.\\n left_half = arr[:mid]\\n right_half = arr[mid:]\\n\\n print(f\\\"Current array is: {arr}\\\")\\n print(f\\\" Left of the array: {left_half}\\\")\\n print(f\\\" Right of the array: {right_half} \\\\n\\\")\\n\\n # Each function will keep recurse until array has one element left.\\n merge_sort(left_half)\\n merge_sort(right_half)\\n\\n i = j = k = 0\\n\\n # Copy data to two temporarily arrays left_half[] and right_half[]\\n while i < len(left_half) and j < len(right_half):\\n if left_half[i] < right_half[j]:\\n arr[k] = left_half[i]\\n i += 1\\n else:\\n arr[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n # Eventually the above loop will break due the imbalance\\n # e.g. False and True, and biggest number from either left or right half\\n # will be remained without being added to the temporarily array.\\n while i < len(left_half):\\n arr[k] = left_half[i]\\n i += 1\\n k += 1\\n\\n while j < len(right_half):\\n arr[k] = right_half[j]\\n j += 1\\n k += 1\",\n \"def __merge_sort(ar,temp,low,high):\\n if low == high:\\n return\\n\\n # divide and conqure\\n middle = (low+high)//2\\n __merge_sort(ar,temp,low,middle)\\n __merge_sort(ar,temp,middle+1,high)\\n\\n # combine\\n index = leftindex = low\\n rightindex = middle+1\\n\\n while leftindex <= middle and rightindex <= high:\\n if ar[leftindex] < ar[rightindex]:\\n temp[index] = ar[leftindex]\\n leftindex += 1\\n index += 1\\n else:\\n temp[index] = ar[rightindex]\\n rightindex += 1\\n index += 1\\n\\n while leftindex <= middle:\\n temp[index] = ar[leftindex]\\n index += 1\\n leftindex +=1\\n\\n while rightindex <= high:\\n temp[index] =ar[rightindex]\\n index += 1\\n rightindex +=1\\n\\n assert index == high+1\\n\\n # copy back\\n for i in xrange(low,high+1):\\n ar[i] = temp[i]\",\n \"def sort(self, nums: List[int]) -> None:\\n if len(nums) <= 1: return\\n\\n # Find the middle of the array\\n mid = len(nums) // 2\\n\\n # Split the array elements into two halves\\n left = nums[:mid]\\n right = nums[mid:]\\n\\n # Sort the left half\\n self.sort(left)\\n\\n # Sort the right half\\n self.sort(right)\\n\\n # Merge the left and right arrays into the original array\\n i = j = k = 0\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n nums[k] = left[i]\\n i += 1\\n else:\\n nums[k] = right[j]\\n j += 1\\n k += 1\\n\\n # Add the remaining elements of the left array if any\\n while i < len(left):\\n nums[k] = left[i]\\n i += 1\\n k += 1\\n\\n # Add the remaining elements of the right array if any\\n while j < len(right):\\n nums[k] = right[j]\\n j += 1\\n k += 1\",\n \"def mergesort(array):\\n if len(array) == 1:\\n return array\\n mid = len(array) // 2 # find the middle point of the array\\n left = mergesort(array[:mid])\\n right = mergesort(array[mid:])\\n return merge(left, right)\",\n \"def merge_sort(arr):\\n if len(arr) <= 1:\\n return arr\\n mid = len(arr) // 2\\n left = merge_sort(arr[:mid])\\n right = merge_sort(arr[mid:])\\n return merge(left,right)\",\n \"def partition(A, p, r):\\n x = A[r]\\n i = p\\n for j in range(p, r):\\n if A[j] <= x:\\n A[i], A[j] = A[j], A[i]\\n i += 1\\n A[i], A[r] = A[r], A[i]\\n return i\",\n \"def merge_sort(arr):\\n if len(arr) <= 1:\\n # nothing to sort\\n return arr\\n\\n # split into left and right half\\n left = arr[:len(arr) // 2]\\n right = arr[len(arr) // 2:]\\n\\n # recursively sort each half\\n left = merge_sort(left)\\n right = merge_sort(right)\\n\\n # merge both sorted halves into a new array\\n return merge(left, right)\",\n \"def merge_sort(arr):\\n n = len(arr)\\n # Base case\\n if n == 1:\\n return arr\\n # Recursive step: sort each half of the elements\\n return merge(merge_sort(arr[:n//2]), merge_sort(arr[n//2:]))\",\n \"def merge_sort(array):\\n\\n if len(array) <= 1: # base case\\n return array\\n\\n # divide array in half and merge sort recursively\\n half = len(array) // 2\\n left = merge_sort(array[:half])\\n right = merge_sort(array[half:])\\n\\n return merge(left, right)\",\n \"def test_merge_sort(self):\\n A = [5, 2, 4, 7, 1, 3, 2, 6]\\n A_sorted = mst.merge_sort(A, 0, 8)\\n self.assertEqual(A_sorted, [1, 2, 2, 3, 4, 5, 6, 7])\",\n \"def partition(A:list, p:int, r:int) -> int:\\n\\n\\tx = A[r]\\n\\ti = p - 1\\n\\tfor j in range(p, r):\\n\\t\\tif A[j] <= x:\\n\\t\\t\\ti = i + 1\\n\\t\\t\\tA[i], A[j] = A[j], A[i]\\n\\tA[i+1], A[r] = A[r], A[i+1]\\n\\treturn i + 1\",\n \"def mergesort(a):\\n\\n\\n\\n def merge(left,right):\\n ll = len(left)\\n lr = len(right)\\n result = []\\n i,j = 0,0\\n while i < ll and j< lr:\\n if left[i] <= right[j]:\\n result.append(left[i])\\n i+=1\\n else:\\n result.append(right[j])\\n j+=1\\n\\n result += left[i:]\\n result += right[j:]\\n return result \\n\\n\\n \\n \\n if len(a)<= 1:\\n return a\\n\\n mid = len(a)//2\\n left = mergesort(a[:mid])\\n right = mergesort(a[mid:])\\n return merge(left,right)\",\n \"def mergesort_iterative_hybrid(array, threshold=37):\\n n = len(array)\\n result = array.copy()\\n\\n # Initial insertion sort pass\\n for i in range(0, n, threshold):\\n result[i:i+threshold] = insertion_sort(result[i:i+threshold])\\n\\n # Merge runs of length threshold, 2*threshold, ...\\n length = threshold\\n while length < n:\\n # Merge each pair of runs\\n for i in range(0, n, 2 * length):\\n mid = i + length\\n upper = i + 2 * length\\n result[i:upper] = merge(result[i:mid], result[mid:upper])\\n length *= 2\\n\\n return result\",\n \"def custom_sort(arr):\\n pass\",\n \"def mergesort_recursive_hybrid(array, threshold=37):\\n # Base case delegates to insertion sort\\n n = len(array)\\n if n <= threshold:\\n return insertion_sort(array)\\n\\n # Recur on two halves of array and merge results\\n mid = n // 2\\n return merge(\\n mergesort_recursive(array[:mid]),\\n mergesort_recursive(array[mid:]))\",\n \"def merge_sort_algorithm(self, low, high):\\n if low < high:\\n mid = (low + high) / 2\\n self.merge_sort_algorithm(low, mid)\\n self.merge_sort_algorithm(mid+1, high)\\n self.merge(low, high, mid)\",\n \"def partition_random(A, p, r):\\n n = random.randint(p, r)\\n A[n], A[r] = A[r], A[n]\\n x = A[r]\\n i = p-1\\n for j in range(p, r):\\n if A[j] <= x:\\n i += 1\\n A[i], A[j] = A[j], A[i]\\n A[i+1], A[r] = A[r], A[i+1]\\n return i+1\",\n \"def mergesort(array):\\n if len(array) == 1:\\n return array\\n else:\\n mid = len(array) // 2\\n return _subsort(mergesort(array[mid:]), mergesort(array[:mid]))\",\n \"def sort(self, nums: List[int]) -> None:\\n\\n # Start at the 2nd element in the array\\n for i in range(1, len(nums)):\\n\\n # Set the key to the beginning of the unsorted subarray\\n key = nums[i]\\n\\n # Set a pointer to the end of the sorted subarray\\n j = i-1\\n\\n # Shift elements in the sorted array to the right as needed\\n # until the correct position for the key is found\\n while j >= 0 and key < nums[j]:\\n nums[j+1] = nums[j]\\n j -= 1\\n\\n # Set the key to the found position\\n nums[j+1] = key\",\n \"def solve_inplace(array1, array2):\\n # append all b values to end of a and then sort\\n pass\",\n \"def quicksortSimple(A:list, p:int, r:int) -> \\\"void\\\":\\n\\n\\ttamanoSecuencia = r - p + 1\\n\\n\\tif tamanoSecuencia <= 32 and p < r:\\t\\n\\t\\tinsertionsortIndex(A, p, r)\\n\\n\\n\\telif tamanoSecuencia > 32 and p < r:\\n\\t\\tq = partition(A, p, r)\\t\\n\\t\\tquicksortSimple(A, p, q-1)\\n\\t\\tquicksortSimple(A, q+1, r)\\n\\n\\t# Para usarse se llama: quickSort(arreglo, 0, len(arreglo) - 1)\",\n \"def qsort(array, left, right):\\n if left < right:\\n p_ind_new = partition(array, left, right)\\n qsort(array, left, p_ind_new-1)\\n qsort(array, p_ind_new+1, right)\",\n \"def merge_sort(self, data):\\n print \\\"Splitting\\\", data\\n if len(data) > 1:\\n mid = len(data)// 2\\n left_half = data[:mid]\\n right_half = data[mid:]\\n self.merge_sort(left_half)\\n self.merge_sort(right_half)\\n i,j,k = (0,0,0)\\n while i< len(left_half) and j<len(right_half):\\n if left_half[i] < right_half[j]:\\n data[k] = left_half[i]\\n i += 1\\n else:\\n data[k] = right_half[j]\\n j += 1\\n k += 1\\n #take care of the unbalance\\n while i < len(left_half):\\n data[k] = left_half[i]\\n i += 1\\n k += 1\\n while j < len(right_half):\\n data[k] = right_half[j]\\n j += 1\\n k += 1\\n print \\\"merging\\\", data\",\n \"def sort(self, nums: List[int]) -> None:\\n n = len(nums)\\n for i in range(n):\\n\\n # Set the lowest to the beginning of the unsorted subarray\\n low = i\\n for j in range(i+1,n):\\n\\n # Find the lowest in the unsorted array\\n if nums[j] < nums[low]:\\n low = j\\n \\n # Swap the beginning of the unsorted subarray and the lowest.\\n # The beginning of the unsorted subarray now becomes the end of the sorted subarray\\n nums[i], nums[low] = nums[low], nums[i]\",\n \"def sort(self, left_arr, right_arr):\\n sorted_array = []\\n left_ind, right_ind = 0,0\\n while left_ind < len(left_arr) and right_ind < len(right_arr):\\n if left_arr[left_ind] < right_arr[right_ind]:\\n sorted_array.append(left_arr[left_ind])\\n left_ind += 1\\n else: \\n sorted_array.append(right_arr[right_ind])\\n right_ind += 1\\n if left_ind == len(left_arr):\\n sorted_array.extend(right_arr[right_ind:])\\n else:\\n sorted_array.extend(left_arr[left_ind:])\\n return sorted_array\",\n \"def merge_sort(arr, start, end):\\n if len(arr) <= 1:\\n return\\n if start >= end:\\n return\\n\\n mid = int((start + end) / 2)\\n merge_sort(arr, start, mid)\\n merge_sort(arr, mid+1, end)\\n merging(arr, start, mid, mid+1, end)\",\n \"def merge(A, left, middle, right):\\n leftSubArray = A[left:middle]\\n rightSubArray = A[middle:right+1]\\n leftSubArray.append(float(\\\"inf\\\"))\\n rightSubArray.append(float(\\\"inf\\\"))\\n i = j = 0\\n for k in xrange(left, right + 1):\\n if leftSubArray[i] < rightSubArray[j]:\\n A[k] = leftSubArray[i]\\n i += 1\\n else:\\n A[k] = rightSubArray[j]\\n j += 1\\n return A\",\n \"def mergeunsort(arr, inv_seq):\\n\\tif len(arr) <= 1:\\n\\t\\treturn list(arr)\\n\\tcut_idx = (len(arr) + 1) / 2\\n\\tleft = arr[:cut_idx]\\n\\tright = arr[cut_idx:]\\n\\tleft = mergeinvert(left, inv_seq)\\n\\tright = mergeinvert(right, inv_seq)\\n\\treturn invert_merge(left, right, inv_seq)\",\n \"def dualPivotQuicksort(A:list, left:int, right:int) -> \\\"void\\\":\\n\\n\\tif right - left <= 32:\\t\\t\\n\\t\\tinsertionsortIndex(A, left, right)\\n\\telse:\\n\\t\\tif A[left] > A[right]:\\n\\t\\t\\tp, q = A[right], A[left]\\n\\t\\telse:\\n\\t\\t\\tp, q = A[left], A[right]\\n\\t\\tl, g = left + 1, right - 1\\n\\t\\tk = l\\n\\n\\t\\twhile k <= g:\\n\\t\\t\\tif A[k] < p:\\n\\t\\t\\t\\tA[k], A[l] = A[l], A[k]\\n\\t\\t\\t\\tl = l + 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif A[k] >= q:\\n\\n\\t\\t\\t\\t\\twhile A[g] > q and k < g:\\n\\t\\t\\t\\t\\t\\tg = g - 1\\n\\n\\t\\t\\t\\t\\tif A[g] >= p:\\n\\t\\t\\t\\t\\t\\tA[k], A[g] = A[g], A[k]\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tA[k], A[g] = A[g], A[k]\\n\\t\\t\\t\\t\\t\\tA[k], A[l] = A[l], A[k]\\n\\t\\t\\t\\t\\t\\tl = l + 1\\n\\n\\t\\t\\t\\t\\tg = g - 1\\t\\t\\t\\t\\t\\n\\t\\t\\tk = k + 1\\n\\n\\t\\tl = l - 1\\n\\t\\tg = g + 1\\n\\t\\tA[left] = A[l]\\n\\t\\tA[l] = p\\n\\t\\tA[right] = A[g]\\n\\t\\tA[g] = q\\n\\t\\tdualPivotQuicksort(A, left, l-1)\\n\\t\\tdualPivotQuicksort(A, l+1, g-1)\\n\\t\\tdualPivotQuicksort(A, g+1, right)\\n\\n\\t\\t# Debe llamarse con: dualPivotQuicksort(A, 0, len(A)-1)\",\n \"def random_qsort(A, l, r):\\n if l < r:\\n q = random_partition(A, l, r)\\n random_qsort(A, l, q-1)\\n random_qsort(A, q+1, r)\",\n \"def _quicksort(self, l, r):\\n\\t\\tif l < r:\\n\\t\\t\\tsplitpoint = self._partition(l, r)\\n\\t\\t\\tself._quicksort(l, splitpoint-1)\\n\\t\\t\\tself._quicksort(splitpoint+1, r)\",\n \"def test_20el_sorted_array(self):\\n res = merge_sort([1, 2, 3, 4, 5, 6, 7, 8, 9,\\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\",\n \"def merge_sort (t,cmp):\\n n = len(t)\\n if n <= 1:\\n # cas de base\\n return copy.deepcopy(t)\\n else:\\n # cas general\\n t1 = merge_sort((t[0:((n-1)//2+1)]),cmp)\\n t2 = merge_sort((t[((n-1)//2+1):n]),cmp)\\n return merge(t1,t2,cmp)\",\n \"def RInsertionSort(array):\\n\\n if not isinstance(array, np.ndarray):\\n raise TypeError('_container is not ndarray') \\n\\n # Get array\\n n = len(array)\\n fhelper(array, 1, n)\",\n \"def mergesort(arr):\\n if type(arr) is not list:\\n raise TypeError('argument must be list of integers')\\n\\n if len(arr) <= 1:\\n return arr \\n\\n def recurse(arr):\\n half = len(arr)//2\\n left = []\\n right = []\\n\\n for i in range(half):\\n left = left + [arr[i]]\\n right = right + [arr[len(arr) - 1 - i]]\\n # print('split', left, right)\\n if len(left) > 1:\\n left = recurse(left)\\n if len(right) > 1:\\n right = recurse(right)\\n \\n return merge(left, right) \\n \\n def merge(left, right):\\n output = []\\n i = 0\\n j = 0\\n while i < len(left) and j < len(right):\\n if left[i] <= right[j]:\\n output.append(left[i])\\n i = i + 1\\n elif left[i] >= right[j]:\\n output.append(right[j])\\n j = j + 1\\n # print('merging', left, right, '=>', output)\\n output.extend(left[i:])\\n output.extend(right[j:])\\n\\n # print('merged', output, '\\\\n')\\n return output\\n\\n return recurse(arr)\",\n \"def merge_sort(a_list):\\n\\n if len(a_list) > 1:\\n mid = len(a_list) // 2\\n left_half = a_list[:mid]\\n right_half = a_list[mid:]\\n\\n merge_sort(left_half)\\n merge_sort(right_half)\\n\\n i = 0\\n j = 0\\n k = 0\\n while i < len(left_half) and j < len(right_half):\\n if left_half[i] < right_half[j]:\\n a_list[k] = left_half[i]\\n i += 1\\n else:\\n a_list[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n while i < len(left_half):\\n a_list[k] = left_half[i]\\n i += 1\\n k += 1\\n\\n while j < len(right_half):\\n a_list[k] = right_half[j]\\n j += 1\\n k += 1\\n return a_list\",\n \"def mergesort(arr):\\n len_arr = len(arr)\\n if len_arr <= 1:\\n return arr\\n\\n middle = len_arr / 2\\n front = mergesort(arr[:middle])\\n back = mergesort(arr[middle:])\\n\\n return merge(front, back)\",\n \"def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\\n # # solution one: sort\\n # A[m:] = B\\n # A.sort()\\n\\n # solution two: two point\\n if n == 0: # B = []\\n return\\n i, j, k = m - 1, n - 1, m + n - 1\\n while i > -1 and j > -1: # > -1, if m = 0 or n = 0, then i = -1 or j = -1\\n if A[i] <= B[j]:\\n A[k] = B[j]\\n k -= 1\\n j -= 1\\n else:\\n A[k] = A[i]\\n k -= 1\\n i -= 1\\n if j > -1:\\n A[:j + 1] = B[:j + 1] # A = [], B = [1]\",\n \"def merge_sort(arr):\\r\\n if len(arr) == 1:\\r\\n return arr\\r\\n middle = len(arr) // 2\\r\\n first_half = merge_sort(arr[:middle])\\r\\n second_half = merge_sort(arr[middle:])\\r\\n return merge(first_half, second_half)\",\n \"def mergesort(arr1, option):\\n length = len(arr1)\\n if length < 2:\\n return arr1\\n # make a copy, since mergesort needs O(n) space\\n arr2 = arr1[:]\\n step = 1\\n while step < length:\\n i, curr = 0, 0 # beginning of each pair, current write point\\n while i + step < length:\\n left, right = i, i + step\\n while curr < length and curr < i + 2 * step:\\n if right == length or right == i + 2 * step:\\n arr2[curr] = arr1[left]\\n left += 1\\n elif left == i + step:\\n arr2[curr] = arr1[right]\\n right += 1\\n elif arr1[left] <= arr1[right]:\\n arr2[curr] = arr1[left]\\n left += 1\\n elif arr1[left] > arr1[right]:\\n arr2[curr] = arr1[right]\\n right += 1\\n curr += 1\\n i += 2 * step\\n # important: copy the untouched end to the new array. It's not applied yet\\n while curr < length:\\n arr2[curr] = arr1[curr]\\n curr += 1\\n step *= 2\\n # swap two arrays for cost efficiency\\n arr1, arr2 = arr2, arr1\\n return arr1\",\n \"def sort(arr, filename):\\n if len(arr) > 1:\\n mid = len(arr) // 2 # Finding the mid of the array\\n L = arr[:mid] # Dividing the array elements\\n R = arr[mid:] # into 2 halves\\n sort(L, filename) # Sorting the first half\\n sort(R, filename) # Sorting the second half\\n\\n i = j = k = 0\\n\\n # Copy data to temp arrays L[] and R[]\\n while i < len(L) and j < len(R):\\n if L[i] < R[j]:\\n arr[k] = L[i]\\n i += 1\\n else:\\n arr[k] = R[j]\\n j += 1\\n k += 1\\n\\n # Checking if any element was left\\n while i < len(L):\\n arr[k] = L[i]\\n i += 1\\n k += 1\\n\\n while j < len(R):\\n arr[k] = R[j]\\n j += 1\\n k += 1\\n with open(\\\"output/temp/\\\" + filename, \\\"w\\\") as file:\\n for item in arr:\\n file.write('%s\\\\n' % item)\",\n \"def merge(array, left, middle, right):\\n\\n len1 = middle - left + 1\\n len2 = right - middle\\n\\n left_side = array[left: left + len1]\\n right_side = array[middle + 1: middle + len2 + 1]\\n\\n i = j = 0\\n k = left\\n\\n while i < len1 and j < len2:\\n if left_side[i] <= right_side[j]:\\n array[k] = left_side[i]\\n i += 1\\n else:\\n array[k] = right_side[j]\\n j += 1\\n\\n k += 1\\n\\n while i < len1:\\n array[k] = left_side[i]\\n i += 1\\n k += 1\\n\\n while j < len2:\\n array[k] = right_side[j]\\n j += 1\\n k += 1\",\n \"def merge_sort(L):\\n n = len(L)\\n if n < 2:\\n return L\\n mid = n // 2\\n left = L[:mid]\\n right = L[mid:]\\n merge_sort(left)\\n merge_sort(right)\\n merge(L, left, right)\",\n \"def test_20el_shuffled_array(self):\\n res = merge_sort([2, 11, 17, 16, 14, 19, 15, 9, 12,\\n 5, 1, 18, 4, 20, 7, 3, 8, 10, 13, 6])\\n self.assertEqual(res, [1, 2, 3, 4, 5, 6, 7, 8, 9,\\n 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])\",\n \"def mergesort_recursive(array):\\n # Base case for empty or singular list\\n n = len(array)\\n if n < 2:\\n return array\\n\\n # Recur on two halves of array and merge results\\n mid = n // 2\\n return merge(\\n mergesort_recursive(array[:mid]),\\n mergesort_recursive(array[mid:]))\",\n \"def _merge(arr, temp, left, mid, right):\\n i = left\\n j = mid\\n k = left\\n inv_count = 0\\n while i < mid and j <= right:\\n if arr[i] < arr[j]:\\n temp[k] = arr[i]\\n k += 1\\n i += 1\\n else:\\n temp[k] = arr[j]\\n k += 1\\n j += 1\\n inv_count += (mid -i)\\n while i < mid:\\n temp[k] = arr[i]\\n k += 1\\n i += 1\\n if j <= right:\\n k += right - j + 1\\n j += right - j + 1\\n arr[left:k + 1] = temp[left:k + 1]\\n else:\\n arr[left:right + 1] = temp[left:right + 1]\\n return inv_count\",\n \"def merge_sort(nums):\\n\\n if len(nums) == 1:\\n return nums\\n\\n mid = len(nums)/2 \\n left_part = merge_sort(nums[:mid]) \\n right_part = merge_sort(nums[mid:]) \\n merged = merge(left_part,right_part) \\n return merged\",\n \"def merge_sort(array: list):\\n\\n # check if the list is not empty and is greater than one element\\n if len(array) > 1:\\n # get the middle of the list, do an integer division, we don't need decimals\\n # assign a left part and a right part\\n middle = len(array) // 2\\n left_half = array[:middle]\\n right_half = array[middle:]\\n\\n # call merge_sort recursively to keep dividing the list\\n merge_sort(left_half)\\n merge_sort(right_half)\\n\\n i = 0 # used to track left half of the list\\n j = 0 # used to track right side of the list\\n k = 0 # used to track the array itself\\n\\n # merge both left and right part of the list\\n while i < len(left_half) and j < len(right_half):\\n if left_half[i] <= right_half[j]:\\n array[k] = left_half[i]\\n i += 1\\n else:\\n array[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n # merge the left half in an ordered fashion\\n while i < len(left_half):\\n array[k] = left_half[i]\\n i += 1\\n k += 1\\n\\n # merge the right half in an ordered fashion\\n while j < len(right_half):\\n array[k] = right_half[j]\\n j += 1\\n k += 1\\n\\n return array\",\n \"def merge_sort(arr: list, start: int, end: int):\\n if end == start:\\n return [arr[start]]\\n else:\\n mid = start + (end - start)//2\\n left = merge_sort(arr, start, mid)\\n right = merge_sort(arr, mid+1, end)\\n sorted_arr = merge(left, right)\\n return sorted_arr\",\n \"def heap_sort(self, A):\\n pass\",\n \"def heap_sort(self, A):\\n pass\",\n \"def merge(l, r):\\n print(\\\"merge [l={}, r={}]\\\".format(l, r))\\n t = [None] * (len(l) + len(r))\\n ti = 0\\n \\n i, j = 0, 0\\n\\n while i < len(l) and j < len(r):\\n if l[i] <= r[j]:\\n t[ti] = l[i]\\n i += 1\\n else:\\n t[ti] = r[j]\\n j += 1\\n ti += 1\\n\\n # copy remaining items from one of either l or r...\\n if i < len(l):\\n while i < len(l):\\n t[ti] = l[i]\\n i += 1\\n ti += 1\\n else:\\n while j < len(r):\\n t[ti] = r[j]\\n j+= 1\\n ti += 1\\n\\n return t\",\n \"def merge_sort(items, key):\\n # Check endcase\\n if (len(items) / 2) > 1:\\n global COMPARE\\n # Pivot point/middle\\n pivot = int(len(items) / 2)\\n # Recursive call\\n left = merge_sort(items[0:pivot], key)\\n right = merge_sort(items[pivot:len(items)], key)\\n # Init the variables\\n l_index = r_index = 0\\n merged = []\\n # Merging\\n while (l_index < len(left)) and (r_index < len(right)):\\n # If right index is larger, append left[index]; increase l. index\\n if COMPARE(right[r_index], left[l_index]):\\n merged.append(left[l_index])\\n l_index += 1\\n # If left index is larger, append right[index]; increase r. index\\n elif COMPARE(left[l_index], right[r_index]):\\n merged.append(right[r_index])\\n r_index += 1\\n # Add remaining merge\\n if(l_index == len(left)):\\n merged.extend(right[r_index:])\\n elif(r_index == len(left)):\\n merged.extend(left[l_index:])\\n # Return list\\n return merged\\n else:\\n # End of the line!\\n return bubble_sort(items, key)\",\n \"def merge_sort(data):\\r\\n\\r\\n if not data or len(data) == 1:\\r\\n # return if list size is 0 or 1\\r\\n return data\\r\\n else:\\r\\n # split data list in half\\r\\n middle = int(len(data) / 2)\\r\\n a = merge_sort(data[:middle])\\r\\n b = merge_sort(data[middle:])\\r\\n # user merge function to merge the two halves\\r\\n # back together while also sorting them\\r\\n return merge(a, b)\",\n \"def merge_sort(aList):\\n\\n n = len(aList)\\n\\n # Check for base case\\n if n <= 1:\\n return aList\\n\\n # Split the list into two halves and call recursively\\n first = merge_sort(aList[0:int(n/2)])\\n\\n second = merge_sort(aList[int(n/2):n])\\n\\n #pdb.set_trace()\\n\\n # Perform Merge of two sorted lists\\n # Initialize counters, lengths and the newly sorted array\\n i, j = 0, 0\\n firstLen = len(first)\\n secondLen = len(second)\\n\\n sortedList = []\\n\\n # Populate the sorted list with the lesser of each half-list\\n for k in range(n):\\n\\n # Make sure we won't try to access past the end of a list\\n # If we've reached the end of the first array, then\\n # add the element from the second array.\\n if i == firstLen:\\n sortedList.append(second[j])\\n j += 1\\n\\n # If we've reached the end of the second array, add\\n # the element from the first array\\n elif j == secondLen:\\n sortedList.append(first[i])\\n i += 1\\n\\n # The normal case (before we've reached the end of either array)\\n elif first[i] < second[j]:\\n sortedList.append(first[i])\\n i += 1\\n\\n else:\\n sortedList.append(second[j])\\n j += 1\\n\\n\\n return sortedList\",\n \"def merge_sort(S):\\n n = len(S)\\n if n < 2:\\n return\\n\\n # devide\\n mid = n//2\\n S1 = S[0:mid]\\n S2 = S[mid:n]\\n\\n # conquer\\n merge_sort(S1)\\n merge_sort(S2)\\n\\n # merge results\\n i = j = 0\\n while i + j < len(S):\\n if j == len(S2) or (i < len(S1) and S1[i] < S2[j]):\\n S[i + j] = S1[i]\\n i += 1\\n else:\\n S[i + j] = S2[j]\\n j += 1\",\n \"def sort(self, nums: List[int]) -> None:\\n\\n # Seperates negative and positive integers\\n neg, pos = [], []\\n for num in nums:\\n if num < 0:\\n neg.append(-num)\\n else:\\n pos.append(num)\\n\\n # Sorts the negative numbers\\n self._sort(neg)\\n neg.reverse()\\n\\n # Sorts the positiv numbers\\n self._sort(pos)\\n \\n # Remerges the sorted subarrays back into the original array.\\n i = j = k = 0\\n while j < len(neg):\\n nums[i] = -neg[j]\\n j += 1\\n i += 1\\n\\n while k < len(pos):\\n nums[i] = pos[k]\\n k += 1\\n i += 1\",\n \"def sa_sort(arr: StaticArray) -> None:\\n length = arr.size()\\n iteration_count = 0\\n while iteration_count < (length / 2):\\n # sets default values to the next first element\\n minimum = arr[iteration_count]\\n maximum = arr[iteration_count]\\n min_old_index = iteration_count\\n max_old_index = iteration_count\\n\\n # loops through the array to find the smallest and largest elements\\n for index in range(iteration_count, (length - iteration_count)):\\n\\n if arr[index] < minimum:\\n minimum = arr[index]\\n min_old_index = index\\n elif arr[index] > maximum:\\n maximum = arr[index]\\n max_old_index = index\\n\\n max_pos = (length - 1) - iteration_count # sets index for next last position\\n\\n # checks that previously sorted values will not be overwritten\\n if arr[iteration_count] != minimum:\\n if arr[min_old_index] != maximum and min_old_index > iteration_count:\\n # swaps min and element where min was\\n arr[min_old_index] = arr[iteration_count]\\n else:\\n # if swapping would overwrite, then places old value where max was\\n arr[max_old_index] = arr[iteration_count]\\n # sets smallest value at the next first position\\n arr[iteration_count] = minimum\\n # checks that previously sorted values will not be overwritten\\n if arr[max_pos] != maximum:\\n if arr[max_old_index] != minimum and max_old_index < max_pos:\\n # swaps max and element where max was\\n arr[max_old_index] = arr[max_pos]\\n else:\\n # if swapping would overwrite, then places old value where min was\\n arr[min_old_index] = arr[max_pos]\\n arr[max_pos] = maximum\\n\\n iteration_count += 1\",\n \"def merge(nums1, m, nums2, n):\\r\\n if not nums2:\\r\\n return\\r\\n\\r\\n while m > 0 and n > 0:\\r\\n # the current element of the final sorted array is the smaller of nums2[n -1] and nums1[m - 1]\\r\\n if nums2[n - 1] < nums1[m - 1]:\\r\\n nums1[m + n - 1] = nums1[m - 1]\\r\\n m -= 1\\r\\n else:\\r\\n nums1[m + n - 1] = nums2[n - 1]\\r\\n n -= 1\\r\\n nums1[:n] = nums2[:n]\",\n \"def mergeSortedArrays(nums1, m, nums2, n):\",\n \"def quicksort(arr, left, right, debug=False):\\n if left >= right:\\n # Base case where left reference and right reference has cross the\\n # pivot\\n return\\n\\n if debug: print(\\\"before index: left={} right={}\\\".format(left, right))\\n\\n # Conquer the problem by sorting in this partition\\n index = partition(arr, left, right)\\n\\n if debug:\\n print(\\\"after index left={} right={} index={}\\\"\\n .format(left, right, index))\\n print()\\n\\n # Divide the problem into smaller arrays\\n quicksort(arr, left, index - 1)\\n quicksort(arr, index, right)\",\n \"def merge_sort(a, b):\\n l = []\\n while a and b:\\n if a[0] < b[0]:\\n l.append(a.pop(0))\\n else:\\n l.append(b.pop(0))\\n return l + a + b\",\n \"def quicksort(array):\\n left, right = 0, len(array) - 1\\n initial_pivot(array,right)\\n qsort(array,left,right)\",\n \"def insertionSort(self, array, left_index, right_index):\\n for index in range(left_index + 1, right_index):\\n temp = array[index]\\n upper_pointer = index - 1\\n # short the section\\n while array[upper_pointer] > temp and upper_pointer >= left_index:\\n # swap the elements\\n array[upper_pointer + 1] = array[upper_pointer]\\n # decrement pointer\\n upper_pointer -= 1\\n array[upper_pointer + 1] = temp\\n return array\",\n \"def mergesort(sequence):\\n\\tif len(sequence) <= 1:\\n\\t\\treturn sequence\\n\\n\\tmiddle_index = len(sequence) // 2\\n\\tleft_half = mergesort(sequence[:middle_index])\\n\\tright_half = mergesort(sequence[middle_index:])\\n\\n\\treturn merge(left_half, right_half)\",\n \"def mergesort(T:list) -> \\\"void\\\":\\n\\n\\tif len(T) <= 32:\\n\\t\\tinsertionsort(T)\\n\\n\\telse:\\n\\t\\tU = T[0:len(T)//2]\\n\\t\\tV = T[len(T)//2:len(T)]\\n\\t\\tmergesort(U)\\n\\t\\tmergesort(V)\\n\\t\\tmerge(U, V, T)\",\n \"def quicksort(array, left = 0, right = None):\\n def choose_pivot(array, left, right, method = 'RANDOM'):\\n if method == 'RANDOM':\\n return np.random.randint(left, right+1)\\n\\n def partition(array, pivot, left, right):\\n def swap(array, i, j):\\n tmp = array[i]\\n array[i] = array[j]\\n array[j] = tmp\\n\\n # Move pivot to first element\\n swap(array, left, pivot)\\n\\n # i is the first element greater than the pivot\\n i = left + 1\\n\\n # Run j through the list comparing each element to the pivot\\n for j in range(left + 1, right + 1):\\n # If it is less than the pivot, move to the left section and increase size of that by 1\\n if array[j] < array[pivot]:\\n swap(array, i, j)\\n i += 1\\n\\n # Move the pivot into position\\n swap(array, left, i - 1)\\n\\n\\n if right is None:\\n right = len(array) - 1\\n\\n # Base case:\\n if right - left <= 0:\\n return\\n\\n pivot = choose_pivot(array, left, right)\\n partition(array, pivot, left, right)\\n quicksort(array, left, pivot - 1)\\n quicksort(array, pivot + 1, right)\",\n \"def merge_sort(unsorted, threshold, reverse):\\r\\n length = len(unsorted)\\r\\n if length < 2:\\r\\n return unsorted\\r\\n elif length < threshold:\\r\\n return insertion_sort(unsorted, reverse)\\r\\n else:\\r\\n mid = length//2\\r\\n list1 = unsorted[0:mid]\\r\\n list2 = unsorted[mid:length]\\r\\n list1 = merge_sort(list1, threshold, reverse)\\r\\n list2 = merge_sort(list2, threshold, reverse)\\r\\n unsorted = merge(list1, list2, reverse)\\r\\n return unsorted\",\n \"def merge_sort(S):\\n n = len(S)\\n if n < 2:\\n return\\n mid = n // 2\\n S1 = S[0:mid]\\n S2 = S[mid:n]\\n merge_sort(S1)\\n merge_sort(S2)\\n merge(S1, S2, S)\",\n \"def fastsort(a):\\n # TODO: the wording in the docstring is nonsense.\\n it = np.argsort(a)\\n as_ = a[it]\\n return as_, it\",\n \"def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:\\n A[m:] = B\\n A.sort()\",\n \"def merge_sort(alist):\\n print(\\\"Splitting \\\", alist)\\n # Temporary list to store sorted list\\n work = [None] * len(alist)\\n rec_merge_sort(work, start=0, end=len(alist)-1)\",\n \"def merge(L, left, right):\\n i = j = 0\\n while i < len(left) and j < len(right):\\n if left[i] < right[j]:\\n L[i + j] = left[i]\\n i += 1\\n else:\\n L[i + j] = right[j]\\n j += 1\\n while i < len(left):\\n L[i + j] = left[i]\\n i += 1\\n while j < len(right):\\n L[i + j] = right[j]\\n j += 1\",\n \"def merge_sort(aList):\\n #If the aList is size 0 or 1, it's already sorted.\\n if len(aList) <= 1:\\n return aList\\n\\n else:\\n mid = len(aList) // 2\\n\\n # Recursively sort the left and right halves\\n left = merge_sort(aList[:mid])\\n right = merge_sort(aList[mid:])\\n \\n # Merge the two (each sorted) parts back together\\n return merge(left, right)\",\n \"def oldsortslice(self):\\n ...\",\n \"def shell_sort(A):\\r\\n inc = len(A) // 2\\r\\n while inc:\\r\\n for i in range(len(A)):\\r\\n j = i\\r\\n temp = A[i]\\r\\n while j >= inc and A[j-inc] > temp:\\r\\n A[j] = A[j - inc]\\r\\n j -= inc\\r\\n A[j] = temp\\r\\n inc = inc//2 if inc//2 else (0 if inc == 1 else 1)\\r\\n return A\",\n \"def sort(array):\\n\\n for i in range(0, len(array)):\\n for j in range(len(array)-1, i, -1):\\n if array[j] < array[j-1]:\\n ## Move the lighter bubble up\\n _temp = array[j]\\n array[j] = array[j-1]\\n array[j-1] = _temp\\n \\n return array\",\n \"def bottom_up_merge_sort(items):\\n subarray_size = 1\\n\\n while subarray_size < len(items)//2:\\n ## Continue making passes through items until the subarray size is\\n ## the size of items, since this means items is finally sorted.\\n for i in range(0, len(items), subarray_size):\\n merge(items, i, i+subarray_size*2, subarray_size)\\n subarray_size *= 2\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84125704","0.83105433","0.7512306","0.7361288","0.73299336","0.7286003","0.6971325","0.69071525","0.689582","0.6885693","0.68768835","0.6779977","0.66591114","0.662605","0.6586384","0.65090984","0.6479134","0.64221436","0.64146775","0.64103496","0.63233346","0.6322725","0.6292906","0.6284771","0.6275771","0.626061","0.62571096","0.6247195","0.622316","0.62186646","0.6197379","0.6181655","0.61808157","0.61706936","0.6170375","0.6155144","0.6142098","0.6136152","0.61352766","0.6123908","0.61226046","0.60812795","0.6069653","0.6052548","0.6047128","0.60308975","0.6030749","0.5990309","0.5985708","0.59538466","0.59522617","0.5951815","0.5926601","0.5918975","0.5917","0.5912372","0.58570033","0.5841407","0.5832594","0.58144313","0.5811794","0.5796283","0.5781361","0.57570004","0.5755743","0.57504237","0.5742218","0.57335585","0.573058","0.57117426","0.56915426","0.5639847","0.5639847","0.56253123","0.5620525","0.5613872","0.5608552","0.5588394","0.5585443","0.55761653","0.5574567","0.5567804","0.5550862","0.55505514","0.55487156","0.55479646","0.5544454","0.5535739","0.55355614","0.5528638","0.552458","0.5523793","0.55007124","0.5498912","0.5492841","0.5489195","0.54869425","0.5483985","0.54830915","0.54778993"],"string":"[\n \"0.84125704\",\n \"0.83105433\",\n \"0.7512306\",\n \"0.7361288\",\n \"0.73299336\",\n \"0.7286003\",\n \"0.6971325\",\n \"0.69071525\",\n \"0.689582\",\n \"0.6885693\",\n \"0.68768835\",\n \"0.6779977\",\n \"0.66591114\",\n \"0.662605\",\n \"0.6586384\",\n \"0.65090984\",\n \"0.6479134\",\n \"0.64221436\",\n \"0.64146775\",\n \"0.64103496\",\n \"0.63233346\",\n \"0.6322725\",\n \"0.6292906\",\n \"0.6284771\",\n \"0.6275771\",\n \"0.626061\",\n \"0.62571096\",\n \"0.6247195\",\n \"0.622316\",\n \"0.62186646\",\n \"0.6197379\",\n \"0.6181655\",\n \"0.61808157\",\n \"0.61706936\",\n \"0.6170375\",\n \"0.6155144\",\n \"0.6142098\",\n \"0.6136152\",\n \"0.61352766\",\n \"0.6123908\",\n \"0.61226046\",\n \"0.60812795\",\n \"0.6069653\",\n \"0.6052548\",\n \"0.6047128\",\n \"0.60308975\",\n \"0.6030749\",\n \"0.5990309\",\n \"0.5985708\",\n \"0.59538466\",\n \"0.59522617\",\n \"0.5951815\",\n \"0.5926601\",\n \"0.5918975\",\n \"0.5917\",\n \"0.5912372\",\n \"0.58570033\",\n \"0.5841407\",\n \"0.5832594\",\n \"0.58144313\",\n \"0.5811794\",\n \"0.5796283\",\n \"0.5781361\",\n \"0.57570004\",\n \"0.5755743\",\n \"0.57504237\",\n \"0.5742218\",\n \"0.57335585\",\n \"0.573058\",\n \"0.57117426\",\n \"0.56915426\",\n \"0.5639847\",\n \"0.5639847\",\n \"0.56253123\",\n \"0.5620525\",\n \"0.5613872\",\n \"0.5608552\",\n \"0.5588394\",\n \"0.5585443\",\n \"0.55761653\",\n \"0.5574567\",\n \"0.5567804\",\n \"0.5550862\",\n \"0.55505514\",\n \"0.55487156\",\n \"0.55479646\",\n \"0.5544454\",\n \"0.5535739\",\n \"0.55355614\",\n \"0.5528638\",\n \"0.552458\",\n \"0.5523793\",\n \"0.55007124\",\n \"0.5498912\",\n \"0.5492841\",\n \"0.5489195\",\n \"0.54869425\",\n \"0.5483985\",\n \"0.54830915\",\n \"0.54778993\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83402205"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93494,"cells":{"query":{"kind":"string","value":"Store an object's key."},"document":{"kind":"string","value":"def save(self, object_id, object_key, unique_type=None):\n self.storage.save(\"\", object_id, {\n \"object_key\": object_key,\n \"unique_type\": unique_type\n })\n\n self.key_object[object_key] = object_id\n if unique_type:\n if unique_type not in self.unique_objects:\n self.unique_objects[unique_type] = {}\n self.unique_objects[unique_type][object_id] = object_key"},"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 store(self, key, obj):\n attrs = self.load_attrs()\n attrs[key] = obj\n self.store_attrs(attrs)","def store(self, key, value):\n pass","def setKey(self, key):\n if hasattr(key, '__class__') and issubclass(key.__class__, ObjectKey):\n key = key.getKey()\n\n self.__key = key","def __setitem__(self, key, obj):\n self.add(key, obj, self._mode)","def dal_set(key, obj):\n global store\n return store.set(urllib.quote(key), obj)","def put(self, key, obj):\n \n\n def find(found_item, hash_table_cell):\n \"\"\"This function is a closer function which will pass to the find_by_key function to get the value. the purpose of this \n function is to check if key is already present than replace the value else append the value in same bucket.\"\"\"\n if found_item:\n found_item[1] = obj\n else:\n hash_table_cell.append([key, obj])\n self.size += 1\n self._keys.append(key)\n\n self._find_by_key(key, find)\n return self","def key(self, key):\n self._key = key","def key(self, key):\n self._key = key","def save(self, key, sort_key, _object):\n return self.storage.set(key, sort_key, _object.to_json())","def set_key(self, key):\n self.key = key","def add(self, key, obj):\n with self._lock:\n slot = self._dict.get(key, None)\n if slot is None:\n slot = [obj, 0]\n else:\n slot[1] += 1\n self._dict[key] = slot","def __setattr__(self, key, value):\n if key not in self._key_order:\n self._key_order.append(key)\n self.__dict__[key] = value","def save(self, key=None):\n\n # we can override our key by passing one in explicitly\n if key: self._key = key\n\n # now save in the db\n if self._key:\n self._dbag[self._key] = self.to_python()\n else:\n self._key = self._dbag.add(self.to_python())\n return self._key","def store_attr(self, key, obj):\n attr = self.node.get_attr(PythonAttrType)\n attr.store(key, obj)","def key(self, key):\n\n self._key = key","def key(self, key):\n\n self._key = key","def store(self, key: object, value: object):\n self._user_data.update({key: value})","def key(self, key_val):\r\n\r\n if self.key_exists():\r\n raise EncryptedField.KeyAlreadyExists()\r\n\r\n validate_key(key_val)\r\n\r\n if self.model_class not in self._keys:\r\n EncryptedField._keys[self.model_class] = {}\r\n\r\n EncryptedField._keys[self.model_class][id(self)] = key_val","def key(self, key):\n return self.__key.set(key)","def store(self, key, obj, timeout=0):\n with self._lock:\n self._check_expire()\n\n self._log.debug(\"storing '%s' (type=%s) with TO=%f\",\n key, type(obj), timeout)\n self._obj_cache[key] = obj\n self._obj_last_access[key] = time.time()\n self._obj_timeouts[key] = timeout","def put(self, key, val):\n pass","def put(self, key, value):\n self._store[key] = value","def _put(self, key: str, value):\n pass","def obj_key(objname):\n return OBJ_PREFIX + objname","def add_key(self,key,index):\r\n\r\n #with shelf\r\n\r\n if self.using_shelf:\r\n\r\n if key in self.key_dict:\r\n\r\n self.key_dict[key].add(str(index))\r\n\r\n else:\r\n self.key_dict[key] = {str(index)}\r\n\r\n #with database\r\n if self.using_database:\r\n\r\n value_tuple = (notebookname, key,)\r\n db_cursor.execute(\"INSERT OR REPLACE\"\r\n +\" INTO all_keys (keyword, notebook)\"\r\n +\" VALUES (?,?);\",\r\n value_tuple)\r\n value_tuple = (notebookname, key, str(index))\r\n db_cursor.execute(\"INSERT OR REPLACE\"\r\n +\" INTO keys_to_indexes\"\r\n +\" (notebook, keyword, note_index)\"\r\n +\" VALUES (?,?,?);\",\r\n value_tuple)","def add(self, obj):\n ID = id(obj)\n self.pDict[ID] = obj\n return ID","def _set_key(cls, spec, value):\n spec[cls.KEY] = value\n if cls.REF:\n spec[\"ref\"] = value","def add_key(self, key, save_pkl=True):\r\n assert key not in self.keys\r\n self.keys.add(key)\r\n if save_pkl:\r\n self.save_pkl()","def _key_generated(self, key, index):\n self.keys[self.get_address(key)] = key\n self.last_generated_index = index","def put(self, name, obj, lifetime=ObjectLifetime.Event):\n\n # check if object with the same name is already stored?\n if name in self.store.keys():\n raise AlreadyInDataStore()\n # no, store it!\n self.store[name] = (lifetime, obj)","def __setitem__(self, key, value):\n Identifier.checkIdentifier(key)\n self.graph.saveExtendedAttributes(self.entityId, {key: value})","def add(self, key, value):\n self._store[key] = value","def initiate_new_key (self,key,index):\r\n\r\n #with shelf\r\n if self.using_shelf:\r\n\r\n\r\n self.key_dict[key] = {str(index)}\r\n\r\n #with database\r\n if self.using_database:\r\n\r\n value_tuple = (notebookname, key,)\r\n db_cursor.execute(\"INSERT OR REPLACE \"\r\n +\"INTO all_keys (keyword, notebook)\"\r\n +\" VALUES (?,?);\",\r\n value_tuple)\r\n value_tuple = (notebookname, key, str(index))\r\n db_cursor.execute(\"INSERT OR REPLACE \"\r\n +\"INTO keys_to_indexes\"\r\n +\" (notebook, keyword, note_index)\"\r\n +\" VALUES (?,?,?);\",\r\n value_tuple)","def setKey(self, time, attributeIndex, hash, value, view) -> None:\n ...","def __setitem__(self, key, value):\n\t\tself.__dStore[key] = value","def put(self, key, value, key_type=None, value_type=None):\n pass","def __setattr__(self, key, value):\n self[key] = value","def __setitem__(self, key: str, value: Any) -> None:\n self._store[key.lower()] = (key, value)","def set(self, key, value):","def set(self, key, value):","def key(self):\n def validate(name):\n '''Compute the key if necessary and validate'''\n found = getattr(self, name)\n value = found() if callable(found) else found\n if value is None:\n raise BadKeyError(\"The key for %s cannot be None\" % self)\n return str(value) \n if self.__key is None:\n namespace, kind, key = Schema.Get(self)\n self.__id = key\n value = validate(key)\n self.__key = Key(namespace, kind, value)\n else:\n self.__key.id = validate(self.__id)\n return self.__key","def store(key):\n\n @node(name=\"store('{}')\".format(key))\n @bind_call_state\n def storer(call_state, val):\n call_state.data[key] = val\n return val\n\n return storer","def set_key_id(self, key_id=''):\n self.key_id = key_id","def store_object(self, namespace, key, value=True):\n # Store the item to not reprocess it \n if namespace not in self.env:\n self.env[namespace] = {}\n self.env[namespace][key] = value","def object_key(self) -> str:\n return self._event.get('object_key')","def put(self, key, value):\n self.__setitem__(key=key, value=value)","def save (self):\n if self.newobj:\n using_sequence = self.sequence ()\n self.keyvals['id'] = using_sequence\n self.seq = using_sequence\n else:\n using_sequence = self.seq\n for key, val in self.keyvals.items ():\n r_key = self.prepare_key (key, using_sequence)\n r.set (r_key, val)\n self.keyvals = {}\n self.newobj = False","def keyify_obj(o):\n return keyify(o.content_type.pk, o.pk)","def object_key(self) -> str:\n return self._values.get('object_key')","def key_id(self, key_id):\n\n self._key_id = key_id","def create_key ():","def keyify(self):\n return keyify_obj(self)","def __setattr__(self, key, value):\n return setattr(self.__dict__['_obj'], key, value)","def _put(self, key, data):\n path = self._get_key_path(key)\n with open(path, \"wb\") as pickle_file:\n pickle.dump(data, pickle_file)","def __setattr__(self, key: Any, value: Any):\n self[key] = value","def _put(self, key, value, current_node):\n pass","def put(cls, obj):\n pass","def _newKey(self, key):\n pass","def object_cache_key_adapter(obj):\n return hex(id(obj))[2:]","def addKey(self, time, name, value, view) -> None:\n ...","def stringKey(obj):\n unproxied = proxy.removeSecurityProxy(obj)\n mapper = orm.object_mapper(unproxied)\n #primary_key = mapper.primary_key_from_instance(unproxied)\n identity_values = [ getattr(unproxied, c.name) for c in mapper.primary_key ]\n identity_key = \"-\".join(map(str, identity_values))\n return \"obj-%s\" % (identity_key)","def put(self, _id, _value):\n self.objects[_id] = _value","def __setitem__(self, key, value):\n\n key = to_unicode(key)\n\n if key in self:\n key = self.get_data_reference(key, default=key)\n else:\n if self.is_view:\n self._view.append(key)\n\n self._storage[key] = to_unicode(value)","def put(self, key, value):\n self.container[key] = value","def __setitem__(self, key, value):\n self._get_storage()[key] = value","def key(key):\n return key","def put(k, v):\n index = get_index(k)\n hash_data[index] = v","def put(self, key: int, value: int) -> None:\n pos = self.hash(key)\n self.table[pos][key] = value","def setattr_and_save(self, key, value):\n setattr(self, key, value)\n self.save()","def put(self, key, value):\n hash_key = key % self.key_space\n self.hash_table[hash_key].update(key, value)","def put(self, key, value):\n return self.sp.put(key, value)","def __setitem__(self, key, document, *args, **kwargs):\n self._put(key, document, *args, **kwargs)","def get_key(self, obj):\n if hasattr(obj, \"id\"):\n hashed_id = hashlib.md5(str(obj.id).encode(\"utf-8\")).hexdigest()\n return hashed_id\n else:\n return None","def __setitem__(self, key, value):\n self.put(key, value)","def __setitem__(self, key, value):\n self.put(key, value)","def new_key(self, key_name=None):\r\n return self.key_class(self, key_name)","def addKey(self,\n keyObj):\n # Note, internal key number index starts with 1.\n if (self.__keyCount.has_key(keyObj.getKey()) == 0):\n self.__keyCount[keyObj.getKey()] = 0\n if (self.getAllowRepetition() == 1):\n # If repetition is enabled, just add the keyword.\n count = self.__incKeyCount(keyObj.getKey())\n key = keyObj.getKey() + \"___\" + str(count)\n self.__keyObjs[key] = keyObj\n self.__keyList.append(key)\n else:\n # If repetition is not enabled, check if the keyword is there,\n # if yes, replace the existing one.\n count = set.setKeyCount_(keyObj.getKey(), 1)\n key = keyObj.getKey() + \"___\" + str(count)\n if (self.__keyList.count(key) == 0):\n self.__keyList.append(key)\n self.__keyObjs[key] = keyObj\n\n return self","def key(self):\n return self.__key","def get_key (self, name):\n return self + name","def _pre_key_for(self, *objects):\n obj_type = objtype(objects[0])\n return \"{}/{}/%s/{}\".format(self.cache_prefix, obj_type, str(self.pk))","def put(self, key: str, value):\n self._put(key, value)","def at_new_key_put(self, value):\n key = self.new_key()\n self.code_table[key] = value\n return key","def add(self, key, value):","def load_key(self, key):\n self.key = key","def write_object(self, object: Any, object_id: Optional[str] = None) -> str:\n # Create a new object identifier if none is given.\n object_id = object_id if object_id is not None else util.unique_identifier()\n self.objects[object_id] = object\n return object_id","def insert_key(self, key : str, value : int) -> None:\n \n hash_key = self.hash_key(key)\n head = self.array[hash_key]\n \n while head.next:\n if head.next.key == key:\n head.next.value = value\n return\n head = head.next\n head.next = Node(key,value)\n self.keys.append(key)","def store(self, key, headers, value):","def __setitem__(self, key, value):\n try:\n kvp = self.keyvaluepair_set.get(key=key)\n except KeyValuePair.DoesNotExist:\n KeyValuePair.objects.create(container=self, key=key, value=value)\n else:\n kvp.value = value\n kvp.save()","def __setitem__(self, key, value):\n if key not in self.ordered_keys:\n self.ordered_keys.append(key)\n super().__setitem__(key, value)","def store_job(self, job_id: Hashable, key: Hashable, value: Any) -> None:\n self._redis.json().set(f\"job:{job_id}\", f\".{key}\", value)","def put(self, key, value):\n self.execute_command('sudo -i bash -c \\'echo -n \"{0}\" > {1}{2}\\''\n .format(value, self._store_path, key))","async def set(self, key, value):\n trace_log(\"PersistantStorage: setting key \", key, \" to value \", value)\n self.dict[key] = value\n #self.log_set(key, value)","def hash_key(self):","def __setattr__(self, key, value):\n if key in self.__dict__:\n self.__dict__[key] = value\n else:\n self.__setitem__(key, value)","def store(self, dikt):\n if self.key is not None and self.body is not None:\n dikt[self.key] = self\n elif self.key in dikt:\n del dikt[self.key]","def __setitem__(self, index, value):\n\t\t# create value and key storage\n\t\tself.filep.write(pack('<LL',len(index), len(value)))\n\t\tself.filep.write(index)\n\t\tself.filep.write(value)\n\n\t\t# grab a hash for the key\n\t\thash = calc_hash(index)\n\n\t\t# dump a new hash into our bucket\n\t\tself.hashbucket[hash % 256].fromlist([hash, self.position_hash])\n\t\tself.position_hash += 8 + (len(index) + len(value))","def __setitem__(self, key_to_store: int, value: Any):\n hash = self.compute_hash(key_to_store)\n\n # First time we're seeing this\n if hash not in self.storage:\n self.storage[hash] = list()\n\n self.storage[hash].append((key_to_store, value))","def __setitem__(self, key, value):\n if key not in self.attribute_dict.keys():\n raise KeyError(\"Object does not have parameter: {}.\".format(key))\n self.attribute_dict[key] = value","def put(self, key: int, value: int) -> None:\n if key in self.keys:\n self.values[self.keys.index(key)] = value\n else:\n self.keys.append(key)\n self.values.append(value)","def store(self, key, value):\n self._cache[key] = value"],"string":"[\n \"def store(self, key, obj):\\n attrs = self.load_attrs()\\n attrs[key] = obj\\n self.store_attrs(attrs)\",\n \"def store(self, key, value):\\n pass\",\n \"def setKey(self, key):\\n if hasattr(key, '__class__') and issubclass(key.__class__, ObjectKey):\\n key = key.getKey()\\n\\n self.__key = key\",\n \"def __setitem__(self, key, obj):\\n self.add(key, obj, self._mode)\",\n \"def dal_set(key, obj):\\n global store\\n return store.set(urllib.quote(key), obj)\",\n \"def put(self, key, obj):\\n \\n\\n def find(found_item, hash_table_cell):\\n \\\"\\\"\\\"This function is a closer function which will pass to the find_by_key function to get the value. the purpose of this \\n function is to check if key is already present than replace the value else append the value in same bucket.\\\"\\\"\\\"\\n if found_item:\\n found_item[1] = obj\\n else:\\n hash_table_cell.append([key, obj])\\n self.size += 1\\n self._keys.append(key)\\n\\n self._find_by_key(key, find)\\n return self\",\n \"def key(self, key):\\n self._key = key\",\n \"def key(self, key):\\n self._key = key\",\n \"def save(self, key, sort_key, _object):\\n return self.storage.set(key, sort_key, _object.to_json())\",\n \"def set_key(self, key):\\n self.key = key\",\n \"def add(self, key, obj):\\n with self._lock:\\n slot = self._dict.get(key, None)\\n if slot is None:\\n slot = [obj, 0]\\n else:\\n slot[1] += 1\\n self._dict[key] = slot\",\n \"def __setattr__(self, key, value):\\n if key not in self._key_order:\\n self._key_order.append(key)\\n self.__dict__[key] = value\",\n \"def save(self, key=None):\\n\\n # we can override our key by passing one in explicitly\\n if key: self._key = key\\n\\n # now save in the db\\n if self._key:\\n self._dbag[self._key] = self.to_python()\\n else:\\n self._key = self._dbag.add(self.to_python())\\n return self._key\",\n \"def store_attr(self, key, obj):\\n attr = self.node.get_attr(PythonAttrType)\\n attr.store(key, obj)\",\n \"def key(self, key):\\n\\n self._key = key\",\n \"def key(self, key):\\n\\n self._key = key\",\n \"def store(self, key: object, value: object):\\n self._user_data.update({key: value})\",\n \"def key(self, key_val):\\r\\n\\r\\n if self.key_exists():\\r\\n raise EncryptedField.KeyAlreadyExists()\\r\\n\\r\\n validate_key(key_val)\\r\\n\\r\\n if self.model_class not in self._keys:\\r\\n EncryptedField._keys[self.model_class] = {}\\r\\n\\r\\n EncryptedField._keys[self.model_class][id(self)] = key_val\",\n \"def key(self, key):\\n return self.__key.set(key)\",\n \"def store(self, key, obj, timeout=0):\\n with self._lock:\\n self._check_expire()\\n\\n self._log.debug(\\\"storing '%s' (type=%s) with TO=%f\\\",\\n key, type(obj), timeout)\\n self._obj_cache[key] = obj\\n self._obj_last_access[key] = time.time()\\n self._obj_timeouts[key] = timeout\",\n \"def put(self, key, val):\\n pass\",\n \"def put(self, key, value):\\n self._store[key] = value\",\n \"def _put(self, key: str, value):\\n pass\",\n \"def obj_key(objname):\\n return OBJ_PREFIX + objname\",\n \"def add_key(self,key,index):\\r\\n\\r\\n #with shelf\\r\\n\\r\\n if self.using_shelf:\\r\\n\\r\\n if key in self.key_dict:\\r\\n\\r\\n self.key_dict[key].add(str(index))\\r\\n\\r\\n else:\\r\\n self.key_dict[key] = {str(index)}\\r\\n\\r\\n #with database\\r\\n if self.using_database:\\r\\n\\r\\n value_tuple = (notebookname, key,)\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE\\\"\\r\\n +\\\" INTO all_keys (keyword, notebook)\\\"\\r\\n +\\\" VALUES (?,?);\\\",\\r\\n value_tuple)\\r\\n value_tuple = (notebookname, key, str(index))\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE\\\"\\r\\n +\\\" INTO keys_to_indexes\\\"\\r\\n +\\\" (notebook, keyword, note_index)\\\"\\r\\n +\\\" VALUES (?,?,?);\\\",\\r\\n value_tuple)\",\n \"def add(self, obj):\\n ID = id(obj)\\n self.pDict[ID] = obj\\n return ID\",\n \"def _set_key(cls, spec, value):\\n spec[cls.KEY] = value\\n if cls.REF:\\n spec[\\\"ref\\\"] = value\",\n \"def add_key(self, key, save_pkl=True):\\r\\n assert key not in self.keys\\r\\n self.keys.add(key)\\r\\n if save_pkl:\\r\\n self.save_pkl()\",\n \"def _key_generated(self, key, index):\\n self.keys[self.get_address(key)] = key\\n self.last_generated_index = index\",\n \"def put(self, name, obj, lifetime=ObjectLifetime.Event):\\n\\n # check if object with the same name is already stored?\\n if name in self.store.keys():\\n raise AlreadyInDataStore()\\n # no, store it!\\n self.store[name] = (lifetime, obj)\",\n \"def __setitem__(self, key, value):\\n Identifier.checkIdentifier(key)\\n self.graph.saveExtendedAttributes(self.entityId, {key: value})\",\n \"def add(self, key, value):\\n self._store[key] = value\",\n \"def initiate_new_key (self,key,index):\\r\\n\\r\\n #with shelf\\r\\n if self.using_shelf:\\r\\n\\r\\n\\r\\n self.key_dict[key] = {str(index)}\\r\\n\\r\\n #with database\\r\\n if self.using_database:\\r\\n\\r\\n value_tuple = (notebookname, key,)\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE \\\"\\r\\n +\\\"INTO all_keys (keyword, notebook)\\\"\\r\\n +\\\" VALUES (?,?);\\\",\\r\\n value_tuple)\\r\\n value_tuple = (notebookname, key, str(index))\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE \\\"\\r\\n +\\\"INTO keys_to_indexes\\\"\\r\\n +\\\" (notebook, keyword, note_index)\\\"\\r\\n +\\\" VALUES (?,?,?);\\\",\\r\\n value_tuple)\",\n \"def setKey(self, time, attributeIndex, hash, value, view) -> None:\\n ...\",\n \"def __setitem__(self, key, value):\\n\\t\\tself.__dStore[key] = value\",\n \"def put(self, key, value, key_type=None, value_type=None):\\n pass\",\n \"def __setattr__(self, key, value):\\n self[key] = value\",\n \"def __setitem__(self, key: str, value: Any) -> None:\\n self._store[key.lower()] = (key, value)\",\n \"def set(self, key, value):\",\n \"def set(self, key, value):\",\n \"def key(self):\\n def validate(name):\\n '''Compute the key if necessary and validate'''\\n found = getattr(self, name)\\n value = found() if callable(found) else found\\n if value is None:\\n raise BadKeyError(\\\"The key for %s cannot be None\\\" % self)\\n return str(value) \\n if self.__key is None:\\n namespace, kind, key = Schema.Get(self)\\n self.__id = key\\n value = validate(key)\\n self.__key = Key(namespace, kind, value)\\n else:\\n self.__key.id = validate(self.__id)\\n return self.__key\",\n \"def store(key):\\n\\n @node(name=\\\"store('{}')\\\".format(key))\\n @bind_call_state\\n def storer(call_state, val):\\n call_state.data[key] = val\\n return val\\n\\n return storer\",\n \"def set_key_id(self, key_id=''):\\n self.key_id = key_id\",\n \"def store_object(self, namespace, key, value=True):\\n # Store the item to not reprocess it \\n if namespace not in self.env:\\n self.env[namespace] = {}\\n self.env[namespace][key] = value\",\n \"def object_key(self) -> str:\\n return self._event.get('object_key')\",\n \"def put(self, key, value):\\n self.__setitem__(key=key, value=value)\",\n \"def save (self):\\n if self.newobj:\\n using_sequence = self.sequence ()\\n self.keyvals['id'] = using_sequence\\n self.seq = using_sequence\\n else:\\n using_sequence = self.seq\\n for key, val in self.keyvals.items ():\\n r_key = self.prepare_key (key, using_sequence)\\n r.set (r_key, val)\\n self.keyvals = {}\\n self.newobj = False\",\n \"def keyify_obj(o):\\n return keyify(o.content_type.pk, o.pk)\",\n \"def object_key(self) -> str:\\n return self._values.get('object_key')\",\n \"def key_id(self, key_id):\\n\\n self._key_id = key_id\",\n \"def create_key ():\",\n \"def keyify(self):\\n return keyify_obj(self)\",\n \"def __setattr__(self, key, value):\\n return setattr(self.__dict__['_obj'], key, value)\",\n \"def _put(self, key, data):\\n path = self._get_key_path(key)\\n with open(path, \\\"wb\\\") as pickle_file:\\n pickle.dump(data, pickle_file)\",\n \"def __setattr__(self, key: Any, value: Any):\\n self[key] = value\",\n \"def _put(self, key, value, current_node):\\n pass\",\n \"def put(cls, obj):\\n pass\",\n \"def _newKey(self, key):\\n pass\",\n \"def object_cache_key_adapter(obj):\\n return hex(id(obj))[2:]\",\n \"def addKey(self, time, name, value, view) -> None:\\n ...\",\n \"def stringKey(obj):\\n unproxied = proxy.removeSecurityProxy(obj)\\n mapper = orm.object_mapper(unproxied)\\n #primary_key = mapper.primary_key_from_instance(unproxied)\\n identity_values = [ getattr(unproxied, c.name) for c in mapper.primary_key ]\\n identity_key = \\\"-\\\".join(map(str, identity_values))\\n return \\\"obj-%s\\\" % (identity_key)\",\n \"def put(self, _id, _value):\\n self.objects[_id] = _value\",\n \"def __setitem__(self, key, value):\\n\\n key = to_unicode(key)\\n\\n if key in self:\\n key = self.get_data_reference(key, default=key)\\n else:\\n if self.is_view:\\n self._view.append(key)\\n\\n self._storage[key] = to_unicode(value)\",\n \"def put(self, key, value):\\n self.container[key] = value\",\n \"def __setitem__(self, key, value):\\n self._get_storage()[key] = value\",\n \"def key(key):\\n return key\",\n \"def put(k, v):\\n index = get_index(k)\\n hash_data[index] = v\",\n \"def put(self, key: int, value: int) -> None:\\n pos = self.hash(key)\\n self.table[pos][key] = value\",\n \"def setattr_and_save(self, key, value):\\n setattr(self, key, value)\\n self.save()\",\n \"def put(self, key, value):\\n hash_key = key % self.key_space\\n self.hash_table[hash_key].update(key, value)\",\n \"def put(self, key, value):\\n return self.sp.put(key, value)\",\n \"def __setitem__(self, key, document, *args, **kwargs):\\n self._put(key, document, *args, **kwargs)\",\n \"def get_key(self, obj):\\n if hasattr(obj, \\\"id\\\"):\\n hashed_id = hashlib.md5(str(obj.id).encode(\\\"utf-8\\\")).hexdigest()\\n return hashed_id\\n else:\\n return None\",\n \"def __setitem__(self, key, value):\\n self.put(key, value)\",\n \"def __setitem__(self, key, value):\\n self.put(key, value)\",\n \"def new_key(self, key_name=None):\\r\\n return self.key_class(self, key_name)\",\n \"def addKey(self,\\n keyObj):\\n # Note, internal key number index starts with 1.\\n if (self.__keyCount.has_key(keyObj.getKey()) == 0):\\n self.__keyCount[keyObj.getKey()] = 0\\n if (self.getAllowRepetition() == 1):\\n # If repetition is enabled, just add the keyword.\\n count = self.__incKeyCount(keyObj.getKey())\\n key = keyObj.getKey() + \\\"___\\\" + str(count)\\n self.__keyObjs[key] = keyObj\\n self.__keyList.append(key)\\n else:\\n # If repetition is not enabled, check if the keyword is there,\\n # if yes, replace the existing one.\\n count = set.setKeyCount_(keyObj.getKey(), 1)\\n key = keyObj.getKey() + \\\"___\\\" + str(count)\\n if (self.__keyList.count(key) == 0):\\n self.__keyList.append(key)\\n self.__keyObjs[key] = keyObj\\n\\n return self\",\n \"def key(self):\\n return self.__key\",\n \"def get_key (self, name):\\n return self + name\",\n \"def _pre_key_for(self, *objects):\\n obj_type = objtype(objects[0])\\n return \\\"{}/{}/%s/{}\\\".format(self.cache_prefix, obj_type, str(self.pk))\",\n \"def put(self, key: str, value):\\n self._put(key, value)\",\n \"def at_new_key_put(self, value):\\n key = self.new_key()\\n self.code_table[key] = value\\n return key\",\n \"def add(self, key, value):\",\n \"def load_key(self, key):\\n self.key = key\",\n \"def write_object(self, object: Any, object_id: Optional[str] = None) -> str:\\n # Create a new object identifier if none is given.\\n object_id = object_id if object_id is not None else util.unique_identifier()\\n self.objects[object_id] = object\\n return object_id\",\n \"def insert_key(self, key : str, value : int) -> None:\\n \\n hash_key = self.hash_key(key)\\n head = self.array[hash_key]\\n \\n while head.next:\\n if head.next.key == key:\\n head.next.value = value\\n return\\n head = head.next\\n head.next = Node(key,value)\\n self.keys.append(key)\",\n \"def store(self, key, headers, value):\",\n \"def __setitem__(self, key, value):\\n try:\\n kvp = self.keyvaluepair_set.get(key=key)\\n except KeyValuePair.DoesNotExist:\\n KeyValuePair.objects.create(container=self, key=key, value=value)\\n else:\\n kvp.value = value\\n kvp.save()\",\n \"def __setitem__(self, key, value):\\n if key not in self.ordered_keys:\\n self.ordered_keys.append(key)\\n super().__setitem__(key, value)\",\n \"def store_job(self, job_id: Hashable, key: Hashable, value: Any) -> None:\\n self._redis.json().set(f\\\"job:{job_id}\\\", f\\\".{key}\\\", value)\",\n \"def put(self, key, value):\\n self.execute_command('sudo -i bash -c \\\\'echo -n \\\"{0}\\\" > {1}{2}\\\\''\\n .format(value, self._store_path, key))\",\n \"async def set(self, key, value):\\n trace_log(\\\"PersistantStorage: setting key \\\", key, \\\" to value \\\", value)\\n self.dict[key] = value\\n #self.log_set(key, value)\",\n \"def hash_key(self):\",\n \"def __setattr__(self, key, value):\\n if key in self.__dict__:\\n self.__dict__[key] = value\\n else:\\n self.__setitem__(key, value)\",\n \"def store(self, dikt):\\n if self.key is not None and self.body is not None:\\n dikt[self.key] = self\\n elif self.key in dikt:\\n del dikt[self.key]\",\n \"def __setitem__(self, index, value):\\n\\t\\t# create value and key storage\\n\\t\\tself.filep.write(pack('<LL',len(index), len(value)))\\n\\t\\tself.filep.write(index)\\n\\t\\tself.filep.write(value)\\n\\n\\t\\t# grab a hash for the key\\n\\t\\thash = calc_hash(index)\\n\\n\\t\\t# dump a new hash into our bucket\\n\\t\\tself.hashbucket[hash % 256].fromlist([hash, self.position_hash])\\n\\t\\tself.position_hash += 8 + (len(index) + len(value))\",\n \"def __setitem__(self, key_to_store: int, value: Any):\\n hash = self.compute_hash(key_to_store)\\n\\n # First time we're seeing this\\n if hash not in self.storage:\\n self.storage[hash] = list()\\n\\n self.storage[hash].append((key_to_store, value))\",\n \"def __setitem__(self, key, value):\\n if key not in self.attribute_dict.keys():\\n raise KeyError(\\\"Object does not have parameter: {}.\\\".format(key))\\n self.attribute_dict[key] = value\",\n \"def put(self, key: int, value: int) -> None:\\n if key in self.keys:\\n self.values[self.keys.index(key)] = value\\n else:\\n self.keys.append(key)\\n self.values.append(value)\",\n \"def store(self, key, value):\\n self._cache[key] = value\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7458511","0.71172404","0.6803623","0.6750187","0.6709677","0.66902435","0.6667568","0.6667568","0.6667472","0.66614276","0.6657352","0.6639487","0.66291237","0.66127026","0.65728253","0.65728253","0.6540316","0.6503544","0.649624","0.64704573","0.64563775","0.6445895","0.64318156","0.6384495","0.63191766","0.6311445","0.62839025","0.6271863","0.6252281","0.6237288","0.6220416","0.62032485","0.6200034","0.6183249","0.6175074","0.61662924","0.6154266","0.6147013","0.614632","0.614632","0.61414486","0.61411136","0.6123218","0.61160374","0.61127484","0.6092301","0.60921377","0.6089331","0.60876703","0.60816777","0.60643953","0.6040447","0.6038465","0.6032141","0.60098547","0.6004525","0.60024583","0.5999766","0.5991511","0.59812397","0.5976656","0.59763014","0.5964914","0.5964219","0.59587497","0.5949698","0.5947783","0.5941697","0.59319615","0.59263587","0.5923376","0.5922673","0.5922437","0.5921576","0.5921576","0.59198546","0.5919062","0.5915982","0.5907033","0.590524","0.59020245","0.58966035","0.58912504","0.58788836","0.58757573","0.5875706","0.5873184","0.58708894","0.58669406","0.5866694","0.58625746","0.5849433","0.5848188","0.58467185","0.5845088","0.58337635","0.5832329","0.5832273","0.58306384","0.58215255"],"string":"[\n \"0.7458511\",\n \"0.71172404\",\n \"0.6803623\",\n \"0.6750187\",\n \"0.6709677\",\n \"0.66902435\",\n \"0.6667568\",\n \"0.6667568\",\n \"0.6667472\",\n \"0.66614276\",\n \"0.6657352\",\n \"0.6639487\",\n \"0.66291237\",\n \"0.66127026\",\n \"0.65728253\",\n \"0.65728253\",\n \"0.6540316\",\n \"0.6503544\",\n \"0.649624\",\n \"0.64704573\",\n \"0.64563775\",\n \"0.6445895\",\n \"0.64318156\",\n \"0.6384495\",\n \"0.63191766\",\n \"0.6311445\",\n \"0.62839025\",\n \"0.6271863\",\n \"0.6252281\",\n \"0.6237288\",\n \"0.6220416\",\n \"0.62032485\",\n \"0.6200034\",\n \"0.6183249\",\n \"0.6175074\",\n \"0.61662924\",\n \"0.6154266\",\n \"0.6147013\",\n \"0.614632\",\n \"0.614632\",\n \"0.61414486\",\n \"0.61411136\",\n \"0.6123218\",\n \"0.61160374\",\n \"0.61127484\",\n \"0.6092301\",\n \"0.60921377\",\n \"0.6089331\",\n \"0.60876703\",\n \"0.60816777\",\n \"0.60643953\",\n \"0.6040447\",\n \"0.6038465\",\n \"0.6032141\",\n \"0.60098547\",\n \"0.6004525\",\n \"0.60024583\",\n \"0.5999766\",\n \"0.5991511\",\n \"0.59812397\",\n \"0.5976656\",\n \"0.59763014\",\n \"0.5964914\",\n \"0.5964219\",\n \"0.59587497\",\n \"0.5949698\",\n \"0.5947783\",\n \"0.5941697\",\n \"0.59319615\",\n \"0.59263587\",\n \"0.5923376\",\n \"0.5922673\",\n \"0.5922437\",\n \"0.5921576\",\n \"0.5921576\",\n \"0.59198546\",\n \"0.5919062\",\n \"0.5915982\",\n \"0.5907033\",\n \"0.590524\",\n \"0.59020245\",\n \"0.58966035\",\n \"0.58912504\",\n \"0.58788836\",\n \"0.58757573\",\n \"0.5875706\",\n \"0.5873184\",\n \"0.58708894\",\n \"0.58669406\",\n \"0.5866694\",\n \"0.58625746\",\n \"0.5849433\",\n \"0.5848188\",\n \"0.58467185\",\n \"0.5845088\",\n \"0.58337635\",\n \"0.5832329\",\n \"0.5832273\",\n \"0.58306384\",\n \"0.58215255\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68876964"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":93495,"cells":{"query":{"kind":"string","value":"Get an object's element key."},"document":{"kind":"string","value":"def get_key(self, object_id):\n try:\n info = self.storage.load(\"\", object_id)\n return info[\"object_key\"]\n except KeyError:\n return None"},"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 object_key(self) -> str:\n return self._values.get('object_key')","def get_key(self, item):\r\n return item[0]","def key(self):\n raise NotImplementedError(\"'key' not implemented for Element subclass\")","def obj_key(objname):\n return OBJ_PREFIX + objname","def get_key(self, obj):\n if hasattr(obj, \"id\"):\n hashed_id = hashlib.md5(str(obj.id).encode(\"utf-8\")).hexdigest()\n return hashed_id\n else:\n return None","def object_key(self) -> str:\n return self._event.get('object_key')","def key(self):\n return self.value()._key","def key(self):\n if \"key\" in self._prop_dict:\n return self._prop_dict[\"key\"]\n else:\n return None","def getKey(instance):\n return instance['name']","def key(self):\n return self.__key","def get_key_at_index(self, index):\n return self.chain_key.subkey(index)","def getKeyObj(self,\n key,\n no = 0):\n keyword = key + \"___\" + str(no + 1)\n return self.__keyObjs[keyword]","def key(self):\n return self.key_for(self.id)","def key(self):\n return key_for_name(self.name)","def get_key(self):\n return self.key","def get_key(self):\n return self.key","def get_key(self):\n return self._determine_key()","def get_key(self) -> int:\n return self.__key","def key(key):\n return key","def key(self):\n return self._key if self._key else self.factory().key","def key(self):\n\n for member in self.members:\n if member.key:\n return member.name","def get_key(self):\n\n return self._key","def get_object_id(self, key):\n try:\n return self.key_object[key]\n except KeyError:\n return None","def key(self):\n if self._key is None:\n fields = []\n for attr in self.__fields__:\n val = getattr(self, attr)\n if isinstance(val, list):\n val = tuple(val)\n fields.append(val)\n self._key = hash(tuple(fields))\n return self._key","def get_key(self) -> int:\n return self.key","def getKeyObjNo(self,\n no):\n return self.__keyObjs[self.__keyList[no]]","def getKey(self):\n return self.__key","def get_key(self, proxy_index):\n return self.treeItem(proxy_index)","def object_cache_key_adapter(obj):\n return hex(id(obj))[2:]","def get_id(self, index):\n return self.__keys[index]","def __getitem__(self, item: int) -> int:\n return self.root[item].key","def key_object_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"key_object_name\")","def key(self):\n def validate(name):\n '''Compute the key if necessary and validate'''\n found = getattr(self, name)\n value = found() if callable(found) else found\n if value is None:\n raise BadKeyError(\"The key for %s cannot be None\" % self)\n return str(value) \n if self.__key is None:\n namespace, kind, key = Schema.Get(self)\n self.__id = key\n value = validate(key)\n self.__key = Key(namespace, kind, value)\n else:\n self.__key.id = validate(self.__id)\n return self.__key","def get_key_id(self):","def tourney_key(proto_obj):\n return tourney_key_full(proto_obj.id_str)","def getKey(self):\n\t\treturn self.key","def get_key (self, name):\n return self + name","def key(self):\n return self._key","def key(self):\n return self._key","def key(self):\n return self._key","def key(self):\n return self._key","def key(self) -> \"str\":\n return self._attrs.get(\"key\")","def key(self):\n return self.name","def key(self) -> Key:\n return self._key","def get_corresponding_key_for_object(arg_schema: Dict[str, Any]) -> str:\n return arg_schema['schema']['new_key_for_argument']","def getKey(self):\n return self.key","def stringKey(obj):\n unproxied = proxy.removeSecurityProxy(obj)\n mapper = orm.object_mapper(unproxied)\n #primary_key = mapper.primary_key_from_instance(unproxied)\n identity_values = [ getattr(unproxied, c.name) for c in mapper.primary_key ]\n identity_key = \"-\".join(map(str, identity_values))\n return \"obj-%s\" % (identity_key)","def _get_key(self, object_type, user_key = None):\n\t\tif not user_key and not self.object_type_keys.has_key(object_type):\n\t\t\traise ParserError(\"Unknown key for object type: %s\\n\" % object_type)\n\n\t\t## Use a default key\n\t\tif not user_key:\n\t\t\tuser_key = self.object_type_keys[object_type]\n\n\t\treturn user_key","def key(self) -> str:\n return self.__key","def getKey(self):\n return self.key","def key(self, name):\n return name","def key (self):\r\n return self.variable","def _key(self):\n return (self.name, self.type_.upper(), self.value)","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")","def key(self) -> str:\n return pulumi.get(self, \"key\")"],"string":"[\n \"def object_key(self) -> str:\\n return self._values.get('object_key')\",\n \"def get_key(self, item):\\r\\n return item[0]\",\n \"def key(self):\\n raise NotImplementedError(\\\"'key' not implemented for Element subclass\\\")\",\n \"def obj_key(objname):\\n return OBJ_PREFIX + objname\",\n \"def get_key(self, obj):\\n if hasattr(obj, \\\"id\\\"):\\n hashed_id = hashlib.md5(str(obj.id).encode(\\\"utf-8\\\")).hexdigest()\\n return hashed_id\\n else:\\n return None\",\n \"def object_key(self) -> str:\\n return self._event.get('object_key')\",\n \"def key(self):\\n return self.value()._key\",\n \"def key(self):\\n if \\\"key\\\" in self._prop_dict:\\n return self._prop_dict[\\\"key\\\"]\\n else:\\n return None\",\n \"def getKey(instance):\\n return instance['name']\",\n \"def key(self):\\n return self.__key\",\n \"def get_key_at_index(self, index):\\n return self.chain_key.subkey(index)\",\n \"def getKeyObj(self,\\n key,\\n no = 0):\\n keyword = key + \\\"___\\\" + str(no + 1)\\n return self.__keyObjs[keyword]\",\n \"def key(self):\\n return self.key_for(self.id)\",\n \"def key(self):\\n return key_for_name(self.name)\",\n \"def get_key(self):\\n return self.key\",\n \"def get_key(self):\\n return self.key\",\n \"def get_key(self):\\n return self._determine_key()\",\n \"def get_key(self) -> int:\\n return self.__key\",\n \"def key(key):\\n return key\",\n \"def key(self):\\n return self._key if self._key else self.factory().key\",\n \"def key(self):\\n\\n for member in self.members:\\n if member.key:\\n return member.name\",\n \"def get_key(self):\\n\\n return self._key\",\n \"def get_object_id(self, key):\\n try:\\n return self.key_object[key]\\n except KeyError:\\n return None\",\n \"def key(self):\\n if self._key is None:\\n fields = []\\n for attr in self.__fields__:\\n val = getattr(self, attr)\\n if isinstance(val, list):\\n val = tuple(val)\\n fields.append(val)\\n self._key = hash(tuple(fields))\\n return self._key\",\n \"def get_key(self) -> int:\\n return self.key\",\n \"def getKeyObjNo(self,\\n no):\\n return self.__keyObjs[self.__keyList[no]]\",\n \"def getKey(self):\\n return self.__key\",\n \"def get_key(self, proxy_index):\\n return self.treeItem(proxy_index)\",\n \"def object_cache_key_adapter(obj):\\n return hex(id(obj))[2:]\",\n \"def get_id(self, index):\\n return self.__keys[index]\",\n \"def __getitem__(self, item: int) -> int:\\n return self.root[item].key\",\n \"def key_object_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"key_object_name\\\")\",\n \"def key(self):\\n def validate(name):\\n '''Compute the key if necessary and validate'''\\n found = getattr(self, name)\\n value = found() if callable(found) else found\\n if value is None:\\n raise BadKeyError(\\\"The key for %s cannot be None\\\" % self)\\n return str(value) \\n if self.__key is None:\\n namespace, kind, key = Schema.Get(self)\\n self.__id = key\\n value = validate(key)\\n self.__key = Key(namespace, kind, value)\\n else:\\n self.__key.id = validate(self.__id)\\n return self.__key\",\n \"def get_key_id(self):\",\n \"def tourney_key(proto_obj):\\n return tourney_key_full(proto_obj.id_str)\",\n \"def getKey(self):\\n\\t\\treturn self.key\",\n \"def get_key (self, name):\\n return self + name\",\n \"def key(self):\\n return self._key\",\n \"def key(self):\\n return self._key\",\n \"def key(self):\\n return self._key\",\n \"def key(self):\\n return self._key\",\n \"def key(self) -> \\\"str\\\":\\n return self._attrs.get(\\\"key\\\")\",\n \"def key(self):\\n return self.name\",\n \"def key(self) -> Key:\\n return self._key\",\n \"def get_corresponding_key_for_object(arg_schema: Dict[str, Any]) -> str:\\n return arg_schema['schema']['new_key_for_argument']\",\n \"def getKey(self):\\n return self.key\",\n \"def stringKey(obj):\\n unproxied = proxy.removeSecurityProxy(obj)\\n mapper = orm.object_mapper(unproxied)\\n #primary_key = mapper.primary_key_from_instance(unproxied)\\n identity_values = [ getattr(unproxied, c.name) for c in mapper.primary_key ]\\n identity_key = \\\"-\\\".join(map(str, identity_values))\\n return \\\"obj-%s\\\" % (identity_key)\",\n \"def _get_key(self, object_type, user_key = None):\\n\\t\\tif not user_key and not self.object_type_keys.has_key(object_type):\\n\\t\\t\\traise ParserError(\\\"Unknown key for object type: %s\\\\n\\\" % object_type)\\n\\n\\t\\t## Use a default key\\n\\t\\tif not user_key:\\n\\t\\t\\tuser_key = self.object_type_keys[object_type]\\n\\n\\t\\treturn user_key\",\n \"def key(self) -> str:\\n return self.__key\",\n \"def getKey(self):\\n return self.key\",\n \"def key(self, name):\\n return name\",\n \"def key (self):\\r\\n return self.variable\",\n \"def _key(self):\\n return (self.name, self.type_.upper(), self.value)\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\",\n \"def key(self) -> str:\\n return pulumi.get(self, \\\"key\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7112568","0.705819","0.6947471","0.6844022","0.6839712","0.67814183","0.67632306","0.67580813","0.6720763","0.6639502","0.6636918","0.66335106","0.6631516","0.6629096","0.6537854","0.6537854","0.6499949","0.6489818","0.64673126","0.6444907","0.6434619","0.64080894","0.63849306","0.6369889","0.6368473","0.63464904","0.6343121","0.63380677","0.6317918","0.6303488","0.6290302","0.6284369","0.62820274","0.62752736","0.6264601","0.6252432","0.62491286","0.6241192","0.6241192","0.6241192","0.6241192","0.6240695","0.62076926","0.61603785","0.6156046","0.61478144","0.6119354","0.6119099","0.61112195","0.61044294","0.6097976","0.6091413","0.6079358","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975","0.60778975"],"string":"[\n \"0.7112568\",\n \"0.705819\",\n \"0.6947471\",\n \"0.6844022\",\n \"0.6839712\",\n \"0.67814183\",\n \"0.67632306\",\n \"0.67580813\",\n \"0.6720763\",\n \"0.6639502\",\n \"0.6636918\",\n \"0.66335106\",\n \"0.6631516\",\n \"0.6629096\",\n \"0.6537854\",\n \"0.6537854\",\n \"0.6499949\",\n \"0.6489818\",\n \"0.64673126\",\n \"0.6444907\",\n \"0.6434619\",\n \"0.64080894\",\n \"0.63849306\",\n \"0.6369889\",\n \"0.6368473\",\n \"0.63464904\",\n \"0.6343121\",\n \"0.63380677\",\n \"0.6317918\",\n \"0.6303488\",\n \"0.6290302\",\n \"0.6284369\",\n \"0.62820274\",\n \"0.62752736\",\n \"0.6264601\",\n \"0.6252432\",\n \"0.62491286\",\n \"0.6241192\",\n \"0.6241192\",\n \"0.6241192\",\n \"0.6241192\",\n \"0.6240695\",\n \"0.62076926\",\n \"0.61603785\",\n \"0.6156046\",\n \"0.61478144\",\n \"0.6119354\",\n \"0.6119099\",\n \"0.61112195\",\n \"0.61044294\",\n \"0.6097976\",\n \"0.6091413\",\n \"0.6079358\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\",\n \"0.60778975\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7098794"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93496,"cells":{"query":{"kind":"string","value":"Get an object by its element key."},"document":{"kind":"string","value":"def get_object_id(self, key):\n try:\n return self.key_object[key]\n except KeyError:\n return None"},"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 __getitem__(self, key):\n return self()[key]","def __getitem__(self, key):\n if self.containsKey(key):\n return self.get(key)\n else:\n raise IndexError()","def __getitem__(self, key):\n return self._[key]","def _single_getitem(self, key):\n return getattr(self._cpp_obj, self._getter)(key)","def __getitem__(self, key):\n return self._get(key)","def __getitem__(self, key):\n return self._dict[key]","def __getitem__(self, key):\n return self.get(key)","def __getitem__(self, key):\n return self.get(key)","def __getitem__(self, key):\n return self.get(key)","def get(self, key):","def get(self, key):","def get_item(dictionary, key):\n return dictionary.get(key)","def get_item(dictionary, key):\n return dictionary.get(key)","def get_item(dictionary, key):\n return dictionary.get(key)","def get_item(dictionary, key):\n return dictionary.get(key)","def __getitem__(self, key):\n return self.__getattr__(key)","def __getitem__(self, key):\n for k,v in list(self.__dict__.items()):\n if k == key:\n return v\n try:\n return v[key]\n except:\n pass\n\n print((\"Item %s could not be found...\" %key))","def get(self, key: K) -> Optional[V]:\n return self.mget([key])[0]","def __getitem__(self, key):\n return dict.__getitem__(self, key)","def __getitem__(self, key: T) -> T:\n return self.lookup(key)","def get_element(self, key, value):\n if isinstance(key, int):\n lst = [s for s in self if s.values[key] == value]\n elif isinstance(key, str):\n lst = [s for s in self if key in s and s[key][0] == name]\n else:\n raise ValueError(\"Key argument must be int or str\")\n if len(lst) == 1:\n return lst[0]\n elif len(lst) == 0:\n raise ValueError(\"contents with '%s=%s' not found\" % (key, value))\n else:\n raise ValueError(\"Multiple contents with '%s=%s' not found\" % (key, value))","def get_by_id(self, model, key_name):\n return model.get_by_id(key_name)","def __getitem__(self, key):\n return self.get_attribute(key)","def getKeyObj(self,\n key,\n no = 0):\n keyword = key + \"___\" + str(no + 1)\n return self.__keyObjs[keyword]","def __getitem__(self, key):\n return self._d[key]","def __getitem__(self, key):\n return self._get_storage()[key]","def __getitem__(self, key):\n result = mongo['readable-api'].foo.find_one({\"foo\": key})\n if result:\n return self.make_child(key)\n return None","def __getitem__(self, key):\n return self.p[key]","def __getitem__(self, key):\n return getattr(self, key)","def __getitem__(self, key):\n return getattr(self, key)","def get(self, key):\n return self[key]","def __getitem__(self, key):\n return self.__getattr__(key)","def __getitem__(self, key):\n return self.get_field(key)","def __getitem__(self, key):\n return self._root.__getitem__(key)","def __getitem__(self, key):\n if key not in self.attribute_dict.keys():\n raise KeyError(\"Object does not have parameter: {}.\".format(key))\n\n return self.attribute_dict[key]","def __getattr__(self, key):\n if key in self.__dict__:\n return self.key\n return self.__getitem__(key)","def __getitem__(self, key):\r\n return self.items[bytes(key)]","def get(self, key):\n pass","def __getitem__(self, key, *args, **kwargs):\n # And if it exist\n if not self.has_key(key, *args, **kwargs):\n raise IndexError\n\n return self._get(key, *args, **kwargs)","def __getitem__(self, key):\n return self.d[key]","def __getitem__(self, key):\n return self.list[key]","def __getitem__(self, key):\n for entry_key, value in self.read(key):\n if entry_key != key:\n raise KeyError(key)\n return value\n raise KeyError(key)","def get(self, key):\n return self.arr[key]","def __getitem__(self, key):\n return self.spec[key]","def __getitem__(self, key):\n self.semaphore_lock.acquire()\n item = self.__dict.get(key)\n self.semaphore_lock.release()\n return item","def get_obj(self, key):\n obj = self.get(key)\n try:\n obj = pickle.loads(obj)\n except TypeError:\n obj = None\n return obj","def __getitem__(self, key):\n self.__check_key_validity(key)\n return self.data[key[0]][key[1]]","def get(self, key):\n return self.container[key]","def __getitem__(self, key):\n return self","def __getitem__(self, key):\r\n\r\n return getattr(self, key)","def get(self, key):\n\t\treturn self.__get(key, key[1:])","def __getitem__(self, key):\n try:\n if key in self.fields:\n return getattr(self, key)\n except AttributeError:\n pass\n raise KeyError(key)","def __getitem__(self, key):\n if not isinstance(key, str) or '.' not in key:\n return dict.__getitem__(self, key)\n obj, token = _descend(self, key)\n return _get(obj, token)","def get(self, key):\n pass","def __getattr__(self, key):\n return self.__getitem__(key)","def test_Container_Get_Item_By_Key(self):\n test = ee.Dictionary({\"key1\": 1, \"key2\": 2})[\"key1\"]\n self.assertIsInstance(test, ee.computedobject.ComputedObject)","def get_item(obj, key):\n val = None\n if obj and type(obj) == dict:\n val = obj.get(key)\n elif obj and hasattr(obj, key):\n val = getattr(obj, key)\n val = val or ''\n return val","def __getitem__(self, key):\n try:\n return self._get_slice(self.data_array, key)\n except KeyError:\n return self.read(bls=key)[0][key]","def __getitem__(self, key):\n return self.get_models()[str(key)]","def get(self, key):\n return getattr(self, key)","def __getitem__(self, key):\n #print( key)\n\n if key == '':\n return self\n\n if not isinstance(key, str):\n return self.__getattr__(key)\n elif not '.' in key:\n return self.__getattr__(key)\n else:\n k1, k2 = key.split('.', 1)\n return self.__getattr__(k1)[k2]","def __getitem__(self, key):","def __getitem__(self, key):\n return self.__data[key]","def __getitem__(self, key):\n return self.query(key)","def get_item_fx(self, key):\n if hasattr(self, key):\n return getattr(self, key)\n else:\n raise KeyError","def __getitem__(self, key):\n key_split = key.split('.')\n current = self\n for k in key_split:\n current = getattr(current, k)\n return current","def __getitem__(self, key):\n\n bucket_key = self.key_for_bucket(key)\n return self.buckets[bucket_key][key]","def __getitem__(self, key):\n hash_ = self._hash(key)\n start = bisect.bisect(self._keys, hash_)\n if start == len(self._keys):\n start = 0\n return self._nodes[self._keys[start]]","def __getitem__(self, key):\n hash_ = self._hash(key)\n start = bisect.bisect(self._keys, hash_)\n if start == len(self._keys):\n start = 0\n return self._nodes[self._keys[start]]","def __getattr__(self, key):\n if key.startswith(\"_\") or key in self.__dict__:\n return object.__getattribute__(self, key)\n\n return self._util.find_value(key)","def get(self, key):\n if key is None:\n return None # None is not a valid key\n return get_from_subtree(self.root, key)","def __getitem__(self, key):\r\n return self._getAttrMap()[key]","def get(self, key):\n raise NotImplementedError","def search_key(cls, key, element):\n if isinstance(element, dict):\n for k, v in element.items():\n if k == key:\n return v\n elif isinstance(v, dict):\n cls.search_key(key, v)\n elif isinstance(v, list):\n cls.search_key(key, v)\n elif isinstance(element, list):\n for obj in element:\n v = cls.search_key(key, obj)\n if v:\n return v","def _map___getitem__(self, key):\n if not isinstance(key, self.keytype):\n raise KeyError('type of key should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))\n if key not in self:\n raise KeyError('key not found')\n return self.second(self.find(key))","def __getitem__(self, key):\n return self.keyvaluepair_set.get(key=key).value","def get(self, key: t.Hashable) -> t.Any:","def __getitem__(self, key):\r\n return self.data[key]","def get(self, key):\n return self.sp.get(key)","def get(self, key):\n result = self.search({\n \"field\": \"identity.key\",\n \"operator\": \"=\",\n \"value\": key})\n if len(result) > 1:\n raise SarasvatiException(\"Entity is not unique {}\".format(key))\n return result[0] if len(result) > 0 else None","def __getitem__(self, key):\n return self.data[key]","def __getitem__(self, key):\n return self.data[key]","def __getitem__(self, key):\n return self.data[key]","def get(key):\n return current().values[key]","def get(key, nodename=None):\n return _get_property(key, nodename, None)","def get(self, key):\n return self._cache[key]","def __getitem__(self, key):\n\t\treturn self.__dStore[key]","def find(cls, key):\r\n return cls.query().get(key)","def retrieve(self, key):\n\n # Map key to an index in main_array\n item_index = self._key_hash(key)\n\n # Retrieve corresponding linked list\n bucket = self.main_array[item_index]\n\n # Lookup key in linked list, returning its value\n return self._linked_list_lookup(bucket, key)","def __getitem__(cls, key):\n return cls(cls._nameToValue[key])","def __getitem__(self, key):\n with SessionContext(self.SessionClass) as session:\n q = session.query(PAW2_DBObject)\n return q.filter(PAW2_DBObject.key == key).one()","def get_by_element(self, element):\n token_ct = ContentType.objects.get_for_model(element)\n try:\n return self.get(\n elements__content_type=token_ct,\n elements__object_id=element.pk,\n )\n except ObjectDoesNotExist:\n return None","def __getitem__(self, key: Hashable) -> Any:\n return self.contents[key]","def __getitem__(self,key):\n if not hasattr(self,\"_register\"):\n self._register = dict()\n if key in self._register:\n return self._register[key]\n raise IndexError(\"No such key: %s\" % key)","def __getitem__(self, key):\n pass","def __getitem__(self, key):\n if isinstance(key, int):\n return self.attributes[key]\n\n assert isinstance(key, basestring)\n attr = dwarf_attribute.name_to_value[key]\n for c in self.attributes:\n if c.attr == attr:\n return c\n raise KeyError('No such attribute: {}'.format(attr))","def get(self, key):\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\n inner = self.keys[index]\n if inner == None:\n return None\n i = 0\n while len(inner):\n innerKey = inner[i]\n if innerKey == self.EMPTY_KEY:\n return None\n elif innerKey == key:\n return self.values[index][i]\n i += 1\n return None","def __getitem__(self, key):\n self._remove_expired()\n\n cache_entry = self._d.get(key, None)\n log.debug(\"__getitem__: {}\".format(cache_entry))\n\n return cache_entry","def get(self, key):\n bucket = self.table[self._hash(key)]\n return [item for item in bucket if item[0] == key][0]","def get(self, key):\n bucket = self.table[self._hash(key)]\n return [item for item in bucket if item[0] == key][0]","def __getattr__(self, key):\n return self._items[key]"],"string":"[\n \"def __getitem__(self, key):\\n return self()[key]\",\n \"def __getitem__(self, key):\\n if self.containsKey(key):\\n return self.get(key)\\n else:\\n raise IndexError()\",\n \"def __getitem__(self, key):\\n return self._[key]\",\n \"def _single_getitem(self, key):\\n return getattr(self._cpp_obj, self._getter)(key)\",\n \"def __getitem__(self, key):\\n return self._get(key)\",\n \"def __getitem__(self, key):\\n return self._dict[key]\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def get(self, key):\",\n \"def get(self, key):\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def __getitem__(self, key):\\n return self.__getattr__(key)\",\n \"def __getitem__(self, key):\\n for k,v in list(self.__dict__.items()):\\n if k == key:\\n return v\\n try:\\n return v[key]\\n except:\\n pass\\n\\n print((\\\"Item %s could not be found...\\\" %key))\",\n \"def get(self, key: K) -> Optional[V]:\\n return self.mget([key])[0]\",\n \"def __getitem__(self, key):\\n return dict.__getitem__(self, key)\",\n \"def __getitem__(self, key: T) -> T:\\n return self.lookup(key)\",\n \"def get_element(self, key, value):\\n if isinstance(key, int):\\n lst = [s for s in self if s.values[key] == value]\\n elif isinstance(key, str):\\n lst = [s for s in self if key in s and s[key][0] == name]\\n else:\\n raise ValueError(\\\"Key argument must be int or str\\\")\\n if len(lst) == 1:\\n return lst[0]\\n elif len(lst) == 0:\\n raise ValueError(\\\"contents with '%s=%s' not found\\\" % (key, value))\\n else:\\n raise ValueError(\\\"Multiple contents with '%s=%s' not found\\\" % (key, value))\",\n \"def get_by_id(self, model, key_name):\\n return model.get_by_id(key_name)\",\n \"def __getitem__(self, key):\\n return self.get_attribute(key)\",\n \"def getKeyObj(self,\\n key,\\n no = 0):\\n keyword = key + \\\"___\\\" + str(no + 1)\\n return self.__keyObjs[keyword]\",\n \"def __getitem__(self, key):\\n return self._d[key]\",\n \"def __getitem__(self, key):\\n return self._get_storage()[key]\",\n \"def __getitem__(self, key):\\n result = mongo['readable-api'].foo.find_one({\\\"foo\\\": key})\\n if result:\\n return self.make_child(key)\\n return None\",\n \"def __getitem__(self, key):\\n return self.p[key]\",\n \"def __getitem__(self, key):\\n return getattr(self, key)\",\n \"def __getitem__(self, key):\\n return getattr(self, key)\",\n \"def get(self, key):\\n return self[key]\",\n \"def __getitem__(self, key):\\n return self.__getattr__(key)\",\n \"def __getitem__(self, key):\\n return self.get_field(key)\",\n \"def __getitem__(self, key):\\n return self._root.__getitem__(key)\",\n \"def __getitem__(self, key):\\n if key not in self.attribute_dict.keys():\\n raise KeyError(\\\"Object does not have parameter: {}.\\\".format(key))\\n\\n return self.attribute_dict[key]\",\n \"def __getattr__(self, key):\\n if key in self.__dict__:\\n return self.key\\n return self.__getitem__(key)\",\n \"def __getitem__(self, key):\\r\\n return self.items[bytes(key)]\",\n \"def get(self, key):\\n pass\",\n \"def __getitem__(self, key, *args, **kwargs):\\n # And if it exist\\n if not self.has_key(key, *args, **kwargs):\\n raise IndexError\\n\\n return self._get(key, *args, **kwargs)\",\n \"def __getitem__(self, key):\\n return self.d[key]\",\n \"def __getitem__(self, key):\\n return self.list[key]\",\n \"def __getitem__(self, key):\\n for entry_key, value in self.read(key):\\n if entry_key != key:\\n raise KeyError(key)\\n return value\\n raise KeyError(key)\",\n \"def get(self, key):\\n return self.arr[key]\",\n \"def __getitem__(self, key):\\n return self.spec[key]\",\n \"def __getitem__(self, key):\\n self.semaphore_lock.acquire()\\n item = self.__dict.get(key)\\n self.semaphore_lock.release()\\n return item\",\n \"def get_obj(self, key):\\n obj = self.get(key)\\n try:\\n obj = pickle.loads(obj)\\n except TypeError:\\n obj = None\\n return obj\",\n \"def __getitem__(self, key):\\n self.__check_key_validity(key)\\n return self.data[key[0]][key[1]]\",\n \"def get(self, key):\\n return self.container[key]\",\n \"def __getitem__(self, key):\\n return self\",\n \"def __getitem__(self, key):\\r\\n\\r\\n return getattr(self, key)\",\n \"def get(self, key):\\n\\t\\treturn self.__get(key, key[1:])\",\n \"def __getitem__(self, key):\\n try:\\n if key in self.fields:\\n return getattr(self, key)\\n except AttributeError:\\n pass\\n raise KeyError(key)\",\n \"def __getitem__(self, key):\\n if not isinstance(key, str) or '.' not in key:\\n return dict.__getitem__(self, key)\\n obj, token = _descend(self, key)\\n return _get(obj, token)\",\n \"def get(self, key):\\n pass\",\n \"def __getattr__(self, key):\\n return self.__getitem__(key)\",\n \"def test_Container_Get_Item_By_Key(self):\\n test = ee.Dictionary({\\\"key1\\\": 1, \\\"key2\\\": 2})[\\\"key1\\\"]\\n self.assertIsInstance(test, ee.computedobject.ComputedObject)\",\n \"def get_item(obj, key):\\n val = None\\n if obj and type(obj) == dict:\\n val = obj.get(key)\\n elif obj and hasattr(obj, key):\\n val = getattr(obj, key)\\n val = val or ''\\n return val\",\n \"def __getitem__(self, key):\\n try:\\n return self._get_slice(self.data_array, key)\\n except KeyError:\\n return self.read(bls=key)[0][key]\",\n \"def __getitem__(self, key):\\n return self.get_models()[str(key)]\",\n \"def get(self, key):\\n return getattr(self, key)\",\n \"def __getitem__(self, key):\\n #print( key)\\n\\n if key == '':\\n return self\\n\\n if not isinstance(key, str):\\n return self.__getattr__(key)\\n elif not '.' in key:\\n return self.__getattr__(key)\\n else:\\n k1, k2 = key.split('.', 1)\\n return self.__getattr__(k1)[k2]\",\n \"def __getitem__(self, key):\",\n \"def __getitem__(self, key):\\n return self.__data[key]\",\n \"def __getitem__(self, key):\\n return self.query(key)\",\n \"def get_item_fx(self, key):\\n if hasattr(self, key):\\n return getattr(self, key)\\n else:\\n raise KeyError\",\n \"def __getitem__(self, key):\\n key_split = key.split('.')\\n current = self\\n for k in key_split:\\n current = getattr(current, k)\\n return current\",\n \"def __getitem__(self, key):\\n\\n bucket_key = self.key_for_bucket(key)\\n return self.buckets[bucket_key][key]\",\n \"def __getitem__(self, key):\\n hash_ = self._hash(key)\\n start = bisect.bisect(self._keys, hash_)\\n if start == len(self._keys):\\n start = 0\\n return self._nodes[self._keys[start]]\",\n \"def __getitem__(self, key):\\n hash_ = self._hash(key)\\n start = bisect.bisect(self._keys, hash_)\\n if start == len(self._keys):\\n start = 0\\n return self._nodes[self._keys[start]]\",\n \"def __getattr__(self, key):\\n if key.startswith(\\\"_\\\") or key in self.__dict__:\\n return object.__getattribute__(self, key)\\n\\n return self._util.find_value(key)\",\n \"def get(self, key):\\n if key is None:\\n return None # None is not a valid key\\n return get_from_subtree(self.root, key)\",\n \"def __getitem__(self, key):\\r\\n return self._getAttrMap()[key]\",\n \"def get(self, key):\\n raise NotImplementedError\",\n \"def search_key(cls, key, element):\\n if isinstance(element, dict):\\n for k, v in element.items():\\n if k == key:\\n return v\\n elif isinstance(v, dict):\\n cls.search_key(key, v)\\n elif isinstance(v, list):\\n cls.search_key(key, v)\\n elif isinstance(element, list):\\n for obj in element:\\n v = cls.search_key(key, obj)\\n if v:\\n return v\",\n \"def _map___getitem__(self, key):\\n if not isinstance(key, self.keytype):\\n raise KeyError('type of key should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))\\n if key not in self:\\n raise KeyError('key not found')\\n return self.second(self.find(key))\",\n \"def __getitem__(self, key):\\n return self.keyvaluepair_set.get(key=key).value\",\n \"def get(self, key: t.Hashable) -> t.Any:\",\n \"def __getitem__(self, key):\\r\\n return self.data[key]\",\n \"def get(self, key):\\n return self.sp.get(key)\",\n \"def get(self, key):\\n result = self.search({\\n \\\"field\\\": \\\"identity.key\\\",\\n \\\"operator\\\": \\\"=\\\",\\n \\\"value\\\": key})\\n if len(result) > 1:\\n raise SarasvatiException(\\\"Entity is not unique {}\\\".format(key))\\n return result[0] if len(result) > 0 else None\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def get(key):\\n return current().values[key]\",\n \"def get(key, nodename=None):\\n return _get_property(key, nodename, None)\",\n \"def get(self, key):\\n return self._cache[key]\",\n \"def __getitem__(self, key):\\n\\t\\treturn self.__dStore[key]\",\n \"def find(cls, key):\\r\\n return cls.query().get(key)\",\n \"def retrieve(self, key):\\n\\n # Map key to an index in main_array\\n item_index = self._key_hash(key)\\n\\n # Retrieve corresponding linked list\\n bucket = self.main_array[item_index]\\n\\n # Lookup key in linked list, returning its value\\n return self._linked_list_lookup(bucket, key)\",\n \"def __getitem__(cls, key):\\n return cls(cls._nameToValue[key])\",\n \"def __getitem__(self, key):\\n with SessionContext(self.SessionClass) as session:\\n q = session.query(PAW2_DBObject)\\n return q.filter(PAW2_DBObject.key == key).one()\",\n \"def get_by_element(self, element):\\n token_ct = ContentType.objects.get_for_model(element)\\n try:\\n return self.get(\\n elements__content_type=token_ct,\\n elements__object_id=element.pk,\\n )\\n except ObjectDoesNotExist:\\n return None\",\n \"def __getitem__(self, key: Hashable) -> Any:\\n return self.contents[key]\",\n \"def __getitem__(self,key):\\n if not hasattr(self,\\\"_register\\\"):\\n self._register = dict()\\n if key in self._register:\\n return self._register[key]\\n raise IndexError(\\\"No such key: %s\\\" % key)\",\n \"def __getitem__(self, key):\\n pass\",\n \"def __getitem__(self, key):\\n if isinstance(key, int):\\n return self.attributes[key]\\n\\n assert isinstance(key, basestring)\\n attr = dwarf_attribute.name_to_value[key]\\n for c in self.attributes:\\n if c.attr == attr:\\n return c\\n raise KeyError('No such attribute: {}'.format(attr))\",\n \"def get(self, key):\\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\\n inner = self.keys[index]\\n if inner == None:\\n return None\\n i = 0\\n while len(inner):\\n innerKey = inner[i]\\n if innerKey == self.EMPTY_KEY:\\n return None\\n elif innerKey == key:\\n return self.values[index][i]\\n i += 1\\n return None\",\n \"def __getitem__(self, key):\\n self._remove_expired()\\n\\n cache_entry = self._d.get(key, None)\\n log.debug(\\\"__getitem__: {}\\\".format(cache_entry))\\n\\n return cache_entry\",\n \"def get(self, key):\\n bucket = self.table[self._hash(key)]\\n return [item for item in bucket if item[0] == key][0]\",\n \"def get(self, key):\\n bucket = self.table[self._hash(key)]\\n return [item for item in bucket if item[0] == key][0]\",\n \"def __getattr__(self, key):\\n return self._items[key]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6758728","0.6676352","0.6675846","0.6639574","0.66102517","0.6604584","0.6603278","0.6603278","0.6603278","0.6601982","0.6601982","0.66018176","0.66018176","0.66018176","0.66018176","0.65997744","0.6594028","0.65724087","0.6571191","0.656945","0.6553533","0.6544059","0.65339583","0.6521616","0.6515972","0.6513072","0.6494707","0.6468548","0.6467212","0.6467212","0.64630204","0.64618504","0.6435719","0.64270335","0.64268625","0.64225024","0.6417181","0.6396843","0.63908947","0.6388246","0.6387659","0.6371654","0.63674504","0.63670427","0.63659966","0.6362058","0.6352887","0.6350686","0.63385135","0.6325187","0.63192844","0.63131386","0.6308236","0.63045573","0.6289953","0.62776595","0.62675977","0.62572306","0.6254166","0.62499624","0.6249694","0.62496305","0.6238629","0.6236304","0.6234393","0.6228511","0.62242717","0.6224051","0.6224051","0.6206086","0.6199316","0.61985815","0.61954486","0.619115","0.6173924","0.6170727","0.61694574","0.61681205","0.61673963","0.6165615","0.61589694","0.61589694","0.61589694","0.6154037","0.61475277","0.61449486","0.6123439","0.6121286","0.6120753","0.61073476","0.6103052","0.60974586","0.6090807","0.60886097","0.60882586","0.6088108","0.6087392","0.6086211","0.6084928","0.6084928","0.60842943"],"string":"[\n \"0.6758728\",\n \"0.6676352\",\n \"0.6675846\",\n \"0.6639574\",\n \"0.66102517\",\n \"0.6604584\",\n \"0.6603278\",\n \"0.6603278\",\n \"0.6603278\",\n \"0.6601982\",\n \"0.6601982\",\n \"0.66018176\",\n \"0.66018176\",\n \"0.66018176\",\n \"0.66018176\",\n \"0.65997744\",\n \"0.6594028\",\n \"0.65724087\",\n \"0.6571191\",\n \"0.656945\",\n \"0.6553533\",\n \"0.6544059\",\n \"0.65339583\",\n \"0.6521616\",\n \"0.6515972\",\n \"0.6513072\",\n \"0.6494707\",\n \"0.6468548\",\n \"0.6467212\",\n \"0.6467212\",\n \"0.64630204\",\n \"0.64618504\",\n \"0.6435719\",\n \"0.64270335\",\n \"0.64268625\",\n \"0.64225024\",\n \"0.6417181\",\n \"0.6396843\",\n \"0.63908947\",\n \"0.6388246\",\n \"0.6387659\",\n \"0.6371654\",\n \"0.63674504\",\n \"0.63670427\",\n \"0.63659966\",\n \"0.6362058\",\n \"0.6352887\",\n \"0.6350686\",\n \"0.63385135\",\n \"0.6325187\",\n \"0.63192844\",\n \"0.63131386\",\n \"0.6308236\",\n \"0.63045573\",\n \"0.6289953\",\n \"0.62776595\",\n \"0.62675977\",\n \"0.62572306\",\n \"0.6254166\",\n \"0.62499624\",\n \"0.6249694\",\n \"0.62496305\",\n \"0.6238629\",\n \"0.6236304\",\n \"0.6234393\",\n \"0.6228511\",\n \"0.62242717\",\n \"0.6224051\",\n \"0.6224051\",\n \"0.6206086\",\n \"0.6199316\",\n \"0.61985815\",\n \"0.61954486\",\n \"0.619115\",\n \"0.6173924\",\n \"0.6170727\",\n \"0.61694574\",\n \"0.61681205\",\n \"0.61673963\",\n \"0.6165615\",\n \"0.61589694\",\n \"0.61589694\",\n \"0.61589694\",\n \"0.6154037\",\n \"0.61475277\",\n \"0.61449486\",\n \"0.6123439\",\n \"0.6121286\",\n \"0.6120753\",\n \"0.61073476\",\n \"0.6103052\",\n \"0.60974586\",\n \"0.6090807\",\n \"0.60886097\",\n \"0.60882586\",\n \"0.6088108\",\n \"0.6087392\",\n \"0.6086211\",\n \"0.6084928\",\n \"0.6084928\",\n \"0.60842943\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93497,"cells":{"query":{"kind":"string","value":"Get an object by its element key."},"document":{"kind":"string","value":"def get_unique_objects(self, unique_type):\n try:\n return self.unique_objects[unique_type]\n except KeyError:\n return {}"},"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 __getitem__(self, key):\n return self()[key]","def __getitem__(self, key):\n if self.containsKey(key):\n return self.get(key)\n else:\n raise IndexError()","def __getitem__(self, key):\n return self._[key]","def _single_getitem(self, key):\n return getattr(self._cpp_obj, self._getter)(key)","def __getitem__(self, key):\n return self._get(key)","def __getitem__(self, key):\n return self._dict[key]","def __getitem__(self, key):\n return self.get(key)","def __getitem__(self, key):\n return self.get(key)","def __getitem__(self, key):\n return self.get(key)","def get(self, key):","def get(self, key):","def get_item(dictionary, key):\n return dictionary.get(key)","def get_item(dictionary, key):\n return dictionary.get(key)","def get_item(dictionary, key):\n return dictionary.get(key)","def get_item(dictionary, key):\n return dictionary.get(key)","def __getitem__(self, key):\n return self.__getattr__(key)","def __getitem__(self, key):\n for k,v in list(self.__dict__.items()):\n if k == key:\n return v\n try:\n return v[key]\n except:\n pass\n\n print((\"Item %s could not be found...\" %key))","def get(self, key: K) -> Optional[V]:\n return self.mget([key])[0]","def __getitem__(self, key):\n return dict.__getitem__(self, key)","def __getitem__(self, key: T) -> T:\n return self.lookup(key)","def get_element(self, key, value):\n if isinstance(key, int):\n lst = [s for s in self if s.values[key] == value]\n elif isinstance(key, str):\n lst = [s for s in self if key in s and s[key][0] == name]\n else:\n raise ValueError(\"Key argument must be int or str\")\n if len(lst) == 1:\n return lst[0]\n elif len(lst) == 0:\n raise ValueError(\"contents with '%s=%s' not found\" % (key, value))\n else:\n raise ValueError(\"Multiple contents with '%s=%s' not found\" % (key, value))","def get_by_id(self, model, key_name):\n return model.get_by_id(key_name)","def __getitem__(self, key):\n return self.get_attribute(key)","def getKeyObj(self,\n key,\n no = 0):\n keyword = key + \"___\" + str(no + 1)\n return self.__keyObjs[keyword]","def __getitem__(self, key):\n return self._d[key]","def __getitem__(self, key):\n return self._get_storage()[key]","def __getitem__(self, key):\n result = mongo['readable-api'].foo.find_one({\"foo\": key})\n if result:\n return self.make_child(key)\n return None","def __getitem__(self, key):\n return self.p[key]","def __getitem__(self, key):\n return getattr(self, key)","def __getitem__(self, key):\n return getattr(self, key)","def get(self, key):\n return self[key]","def __getitem__(self, key):\n return self.__getattr__(key)","def __getitem__(self, key):\n return self.get_field(key)","def __getitem__(self, key):\n return self._root.__getitem__(key)","def __getitem__(self, key):\n if key not in self.attribute_dict.keys():\n raise KeyError(\"Object does not have parameter: {}.\".format(key))\n\n return self.attribute_dict[key]","def __getattr__(self, key):\n if key in self.__dict__:\n return self.key\n return self.__getitem__(key)","def __getitem__(self, key):\r\n return self.items[bytes(key)]","def get(self, key):\n pass","def __getitem__(self, key, *args, **kwargs):\n # And if it exist\n if not self.has_key(key, *args, **kwargs):\n raise IndexError\n\n return self._get(key, *args, **kwargs)","def __getitem__(self, key):\n return self.d[key]","def __getitem__(self, key):\n return self.list[key]","def __getitem__(self, key):\n for entry_key, value in self.read(key):\n if entry_key != key:\n raise KeyError(key)\n return value\n raise KeyError(key)","def get(self, key):\n return self.arr[key]","def __getitem__(self, key):\n return self.spec[key]","def __getitem__(self, key):\n self.semaphore_lock.acquire()\n item = self.__dict.get(key)\n self.semaphore_lock.release()\n return item","def get_obj(self, key):\n obj = self.get(key)\n try:\n obj = pickle.loads(obj)\n except TypeError:\n obj = None\n return obj","def __getitem__(self, key):\n self.__check_key_validity(key)\n return self.data[key[0]][key[1]]","def get(self, key):\n return self.container[key]","def __getitem__(self, key):\n return self","def __getitem__(self, key):\r\n\r\n return getattr(self, key)","def get(self, key):\n\t\treturn self.__get(key, key[1:])","def __getitem__(self, key):\n try:\n if key in self.fields:\n return getattr(self, key)\n except AttributeError:\n pass\n raise KeyError(key)","def __getitem__(self, key):\n if not isinstance(key, str) or '.' not in key:\n return dict.__getitem__(self, key)\n obj, token = _descend(self, key)\n return _get(obj, token)","def get(self, key):\n pass","def __getattr__(self, key):\n return self.__getitem__(key)","def test_Container_Get_Item_By_Key(self):\n test = ee.Dictionary({\"key1\": 1, \"key2\": 2})[\"key1\"]\n self.assertIsInstance(test, ee.computedobject.ComputedObject)","def get_item(obj, key):\n val = None\n if obj and type(obj) == dict:\n val = obj.get(key)\n elif obj and hasattr(obj, key):\n val = getattr(obj, key)\n val = val or ''\n return val","def __getitem__(self, key):\n try:\n return self._get_slice(self.data_array, key)\n except KeyError:\n return self.read(bls=key)[0][key]","def __getitem__(self, key):\n return self.get_models()[str(key)]","def get(self, key):\n return getattr(self, key)","def __getitem__(self, key):\n #print( key)\n\n if key == '':\n return self\n\n if not isinstance(key, str):\n return self.__getattr__(key)\n elif not '.' in key:\n return self.__getattr__(key)\n else:\n k1, k2 = key.split('.', 1)\n return self.__getattr__(k1)[k2]","def __getitem__(self, key):","def __getitem__(self, key):\n return self.__data[key]","def __getitem__(self, key):\n return self.query(key)","def get_item_fx(self, key):\n if hasattr(self, key):\n return getattr(self, key)\n else:\n raise KeyError","def __getitem__(self, key):\n key_split = key.split('.')\n current = self\n for k in key_split:\n current = getattr(current, k)\n return current","def __getitem__(self, key):\n\n bucket_key = self.key_for_bucket(key)\n return self.buckets[bucket_key][key]","def __getitem__(self, key):\n hash_ = self._hash(key)\n start = bisect.bisect(self._keys, hash_)\n if start == len(self._keys):\n start = 0\n return self._nodes[self._keys[start]]","def __getitem__(self, key):\n hash_ = self._hash(key)\n start = bisect.bisect(self._keys, hash_)\n if start == len(self._keys):\n start = 0\n return self._nodes[self._keys[start]]","def __getattr__(self, key):\n if key.startswith(\"_\") or key in self.__dict__:\n return object.__getattribute__(self, key)\n\n return self._util.find_value(key)","def get(self, key):\n if key is None:\n return None # None is not a valid key\n return get_from_subtree(self.root, key)","def __getitem__(self, key):\r\n return self._getAttrMap()[key]","def get(self, key):\n raise NotImplementedError","def search_key(cls, key, element):\n if isinstance(element, dict):\n for k, v in element.items():\n if k == key:\n return v\n elif isinstance(v, dict):\n cls.search_key(key, v)\n elif isinstance(v, list):\n cls.search_key(key, v)\n elif isinstance(element, list):\n for obj in element:\n v = cls.search_key(key, obj)\n if v:\n return v","def _map___getitem__(self, key):\n if not isinstance(key, self.keytype):\n raise KeyError('type of key should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))\n if key not in self:\n raise KeyError('key not found')\n return self.second(self.find(key))","def __getitem__(self, key):\n return self.keyvaluepair_set.get(key=key).value","def get(self, key: t.Hashable) -> t.Any:","def __getitem__(self, key):\r\n return self.data[key]","def get(self, key):\n return self.sp.get(key)","def get(self, key):\n result = self.search({\n \"field\": \"identity.key\",\n \"operator\": \"=\",\n \"value\": key})\n if len(result) > 1:\n raise SarasvatiException(\"Entity is not unique {}\".format(key))\n return result[0] if len(result) > 0 else None","def __getitem__(self, key):\n return self.data[key]","def __getitem__(self, key):\n return self.data[key]","def __getitem__(self, key):\n return self.data[key]","def get(key):\n return current().values[key]","def get(key, nodename=None):\n return _get_property(key, nodename, None)","def get(self, key):\n return self._cache[key]","def __getitem__(self, key):\n\t\treturn self.__dStore[key]","def find(cls, key):\r\n return cls.query().get(key)","def retrieve(self, key):\n\n # Map key to an index in main_array\n item_index = self._key_hash(key)\n\n # Retrieve corresponding linked list\n bucket = self.main_array[item_index]\n\n # Lookup key in linked list, returning its value\n return self._linked_list_lookup(bucket, key)","def __getitem__(cls, key):\n return cls(cls._nameToValue[key])","def __getitem__(self, key):\n with SessionContext(self.SessionClass) as session:\n q = session.query(PAW2_DBObject)\n return q.filter(PAW2_DBObject.key == key).one()","def get_by_element(self, element):\n token_ct = ContentType.objects.get_for_model(element)\n try:\n return self.get(\n elements__content_type=token_ct,\n elements__object_id=element.pk,\n )\n except ObjectDoesNotExist:\n return None","def __getitem__(self, key: Hashable) -> Any:\n return self.contents[key]","def __getitem__(self,key):\n if not hasattr(self,\"_register\"):\n self._register = dict()\n if key in self._register:\n return self._register[key]\n raise IndexError(\"No such key: %s\" % key)","def __getitem__(self, key):\n pass","def __getitem__(self, key):\n if isinstance(key, int):\n return self.attributes[key]\n\n assert isinstance(key, basestring)\n attr = dwarf_attribute.name_to_value[key]\n for c in self.attributes:\n if c.attr == attr:\n return c\n raise KeyError('No such attribute: {}'.format(attr))","def get(self, key):\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\n inner = self.keys[index]\n if inner == None:\n return None\n i = 0\n while len(inner):\n innerKey = inner[i]\n if innerKey == self.EMPTY_KEY:\n return None\n elif innerKey == key:\n return self.values[index][i]\n i += 1\n return None","def __getitem__(self, key):\n self._remove_expired()\n\n cache_entry = self._d.get(key, None)\n log.debug(\"__getitem__: {}\".format(cache_entry))\n\n return cache_entry","def get(self, key):\n bucket = self.table[self._hash(key)]\n return [item for item in bucket if item[0] == key][0]","def get(self, key):\n bucket = self.table[self._hash(key)]\n return [item for item in bucket if item[0] == key][0]","def __getattr__(self, key):\n return self._items[key]"],"string":"[\n \"def __getitem__(self, key):\\n return self()[key]\",\n \"def __getitem__(self, key):\\n if self.containsKey(key):\\n return self.get(key)\\n else:\\n raise IndexError()\",\n \"def __getitem__(self, key):\\n return self._[key]\",\n \"def _single_getitem(self, key):\\n return getattr(self._cpp_obj, self._getter)(key)\",\n \"def __getitem__(self, key):\\n return self._get(key)\",\n \"def __getitem__(self, key):\\n return self._dict[key]\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def __getitem__(self, key):\\n return self.get(key)\",\n \"def get(self, key):\",\n \"def get(self, key):\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def get_item(dictionary, key):\\n return dictionary.get(key)\",\n \"def __getitem__(self, key):\\n return self.__getattr__(key)\",\n \"def __getitem__(self, key):\\n for k,v in list(self.__dict__.items()):\\n if k == key:\\n return v\\n try:\\n return v[key]\\n except:\\n pass\\n\\n print((\\\"Item %s could not be found...\\\" %key))\",\n \"def get(self, key: K) -> Optional[V]:\\n return self.mget([key])[0]\",\n \"def __getitem__(self, key):\\n return dict.__getitem__(self, key)\",\n \"def __getitem__(self, key: T) -> T:\\n return self.lookup(key)\",\n \"def get_element(self, key, value):\\n if isinstance(key, int):\\n lst = [s for s in self if s.values[key] == value]\\n elif isinstance(key, str):\\n lst = [s for s in self if key in s and s[key][0] == name]\\n else:\\n raise ValueError(\\\"Key argument must be int or str\\\")\\n if len(lst) == 1:\\n return lst[0]\\n elif len(lst) == 0:\\n raise ValueError(\\\"contents with '%s=%s' not found\\\" % (key, value))\\n else:\\n raise ValueError(\\\"Multiple contents with '%s=%s' not found\\\" % (key, value))\",\n \"def get_by_id(self, model, key_name):\\n return model.get_by_id(key_name)\",\n \"def __getitem__(self, key):\\n return self.get_attribute(key)\",\n \"def getKeyObj(self,\\n key,\\n no = 0):\\n keyword = key + \\\"___\\\" + str(no + 1)\\n return self.__keyObjs[keyword]\",\n \"def __getitem__(self, key):\\n return self._d[key]\",\n \"def __getitem__(self, key):\\n return self._get_storage()[key]\",\n \"def __getitem__(self, key):\\n result = mongo['readable-api'].foo.find_one({\\\"foo\\\": key})\\n if result:\\n return self.make_child(key)\\n return None\",\n \"def __getitem__(self, key):\\n return self.p[key]\",\n \"def __getitem__(self, key):\\n return getattr(self, key)\",\n \"def __getitem__(self, key):\\n return getattr(self, key)\",\n \"def get(self, key):\\n return self[key]\",\n \"def __getitem__(self, key):\\n return self.__getattr__(key)\",\n \"def __getitem__(self, key):\\n return self.get_field(key)\",\n \"def __getitem__(self, key):\\n return self._root.__getitem__(key)\",\n \"def __getitem__(self, key):\\n if key not in self.attribute_dict.keys():\\n raise KeyError(\\\"Object does not have parameter: {}.\\\".format(key))\\n\\n return self.attribute_dict[key]\",\n \"def __getattr__(self, key):\\n if key in self.__dict__:\\n return self.key\\n return self.__getitem__(key)\",\n \"def __getitem__(self, key):\\r\\n return self.items[bytes(key)]\",\n \"def get(self, key):\\n pass\",\n \"def __getitem__(self, key, *args, **kwargs):\\n # And if it exist\\n if not self.has_key(key, *args, **kwargs):\\n raise IndexError\\n\\n return self._get(key, *args, **kwargs)\",\n \"def __getitem__(self, key):\\n return self.d[key]\",\n \"def __getitem__(self, key):\\n return self.list[key]\",\n \"def __getitem__(self, key):\\n for entry_key, value in self.read(key):\\n if entry_key != key:\\n raise KeyError(key)\\n return value\\n raise KeyError(key)\",\n \"def get(self, key):\\n return self.arr[key]\",\n \"def __getitem__(self, key):\\n return self.spec[key]\",\n \"def __getitem__(self, key):\\n self.semaphore_lock.acquire()\\n item = self.__dict.get(key)\\n self.semaphore_lock.release()\\n return item\",\n \"def get_obj(self, key):\\n obj = self.get(key)\\n try:\\n obj = pickle.loads(obj)\\n except TypeError:\\n obj = None\\n return obj\",\n \"def __getitem__(self, key):\\n self.__check_key_validity(key)\\n return self.data[key[0]][key[1]]\",\n \"def get(self, key):\\n return self.container[key]\",\n \"def __getitem__(self, key):\\n return self\",\n \"def __getitem__(self, key):\\r\\n\\r\\n return getattr(self, key)\",\n \"def get(self, key):\\n\\t\\treturn self.__get(key, key[1:])\",\n \"def __getitem__(self, key):\\n try:\\n if key in self.fields:\\n return getattr(self, key)\\n except AttributeError:\\n pass\\n raise KeyError(key)\",\n \"def __getitem__(self, key):\\n if not isinstance(key, str) or '.' not in key:\\n return dict.__getitem__(self, key)\\n obj, token = _descend(self, key)\\n return _get(obj, token)\",\n \"def get(self, key):\\n pass\",\n \"def __getattr__(self, key):\\n return self.__getitem__(key)\",\n \"def test_Container_Get_Item_By_Key(self):\\n test = ee.Dictionary({\\\"key1\\\": 1, \\\"key2\\\": 2})[\\\"key1\\\"]\\n self.assertIsInstance(test, ee.computedobject.ComputedObject)\",\n \"def get_item(obj, key):\\n val = None\\n if obj and type(obj) == dict:\\n val = obj.get(key)\\n elif obj and hasattr(obj, key):\\n val = getattr(obj, key)\\n val = val or ''\\n return val\",\n \"def __getitem__(self, key):\\n try:\\n return self._get_slice(self.data_array, key)\\n except KeyError:\\n return self.read(bls=key)[0][key]\",\n \"def __getitem__(self, key):\\n return self.get_models()[str(key)]\",\n \"def get(self, key):\\n return getattr(self, key)\",\n \"def __getitem__(self, key):\\n #print( key)\\n\\n if key == '':\\n return self\\n\\n if not isinstance(key, str):\\n return self.__getattr__(key)\\n elif not '.' in key:\\n return self.__getattr__(key)\\n else:\\n k1, k2 = key.split('.', 1)\\n return self.__getattr__(k1)[k2]\",\n \"def __getitem__(self, key):\",\n \"def __getitem__(self, key):\\n return self.__data[key]\",\n \"def __getitem__(self, key):\\n return self.query(key)\",\n \"def get_item_fx(self, key):\\n if hasattr(self, key):\\n return getattr(self, key)\\n else:\\n raise KeyError\",\n \"def __getitem__(self, key):\\n key_split = key.split('.')\\n current = self\\n for k in key_split:\\n current = getattr(current, k)\\n return current\",\n \"def __getitem__(self, key):\\n\\n bucket_key = self.key_for_bucket(key)\\n return self.buckets[bucket_key][key]\",\n \"def __getitem__(self, key):\\n hash_ = self._hash(key)\\n start = bisect.bisect(self._keys, hash_)\\n if start == len(self._keys):\\n start = 0\\n return self._nodes[self._keys[start]]\",\n \"def __getitem__(self, key):\\n hash_ = self._hash(key)\\n start = bisect.bisect(self._keys, hash_)\\n if start == len(self._keys):\\n start = 0\\n return self._nodes[self._keys[start]]\",\n \"def __getattr__(self, key):\\n if key.startswith(\\\"_\\\") or key in self.__dict__:\\n return object.__getattribute__(self, key)\\n\\n return self._util.find_value(key)\",\n \"def get(self, key):\\n if key is None:\\n return None # None is not a valid key\\n return get_from_subtree(self.root, key)\",\n \"def __getitem__(self, key):\\r\\n return self._getAttrMap()[key]\",\n \"def get(self, key):\\n raise NotImplementedError\",\n \"def search_key(cls, key, element):\\n if isinstance(element, dict):\\n for k, v in element.items():\\n if k == key:\\n return v\\n elif isinstance(v, dict):\\n cls.search_key(key, v)\\n elif isinstance(v, list):\\n cls.search_key(key, v)\\n elif isinstance(element, list):\\n for obj in element:\\n v = cls.search_key(key, obj)\\n if v:\\n return v\",\n \"def _map___getitem__(self, key):\\n if not isinstance(key, self.keytype):\\n raise KeyError('type of key should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))\\n if key not in self:\\n raise KeyError('key not found')\\n return self.second(self.find(key))\",\n \"def __getitem__(self, key):\\n return self.keyvaluepair_set.get(key=key).value\",\n \"def get(self, key: t.Hashable) -> t.Any:\",\n \"def __getitem__(self, key):\\r\\n return self.data[key]\",\n \"def get(self, key):\\n return self.sp.get(key)\",\n \"def get(self, key):\\n result = self.search({\\n \\\"field\\\": \\\"identity.key\\\",\\n \\\"operator\\\": \\\"=\\\",\\n \\\"value\\\": key})\\n if len(result) > 1:\\n raise SarasvatiException(\\\"Entity is not unique {}\\\".format(key))\\n return result[0] if len(result) > 0 else None\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def __getitem__(self, key):\\n return self.data[key]\",\n \"def get(key):\\n return current().values[key]\",\n \"def get(key, nodename=None):\\n return _get_property(key, nodename, None)\",\n \"def get(self, key):\\n return self._cache[key]\",\n \"def __getitem__(self, key):\\n\\t\\treturn self.__dStore[key]\",\n \"def find(cls, key):\\r\\n return cls.query().get(key)\",\n \"def retrieve(self, key):\\n\\n # Map key to an index in main_array\\n item_index = self._key_hash(key)\\n\\n # Retrieve corresponding linked list\\n bucket = self.main_array[item_index]\\n\\n # Lookup key in linked list, returning its value\\n return self._linked_list_lookup(bucket, key)\",\n \"def __getitem__(cls, key):\\n return cls(cls._nameToValue[key])\",\n \"def __getitem__(self, key):\\n with SessionContext(self.SessionClass) as session:\\n q = session.query(PAW2_DBObject)\\n return q.filter(PAW2_DBObject.key == key).one()\",\n \"def get_by_element(self, element):\\n token_ct = ContentType.objects.get_for_model(element)\\n try:\\n return self.get(\\n elements__content_type=token_ct,\\n elements__object_id=element.pk,\\n )\\n except ObjectDoesNotExist:\\n return None\",\n \"def __getitem__(self, key: Hashable) -> Any:\\n return self.contents[key]\",\n \"def __getitem__(self,key):\\n if not hasattr(self,\\\"_register\\\"):\\n self._register = dict()\\n if key in self._register:\\n return self._register[key]\\n raise IndexError(\\\"No such key: %s\\\" % key)\",\n \"def __getitem__(self, key):\\n pass\",\n \"def __getitem__(self, key):\\n if isinstance(key, int):\\n return self.attributes[key]\\n\\n assert isinstance(key, basestring)\\n attr = dwarf_attribute.name_to_value[key]\\n for c in self.attributes:\\n if c.attr == attr:\\n return c\\n raise KeyError('No such attribute: {}'.format(attr))\",\n \"def get(self, key):\\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\\n inner = self.keys[index]\\n if inner == None:\\n return None\\n i = 0\\n while len(inner):\\n innerKey = inner[i]\\n if innerKey == self.EMPTY_KEY:\\n return None\\n elif innerKey == key:\\n return self.values[index][i]\\n i += 1\\n return None\",\n \"def __getitem__(self, key):\\n self._remove_expired()\\n\\n cache_entry = self._d.get(key, None)\\n log.debug(\\\"__getitem__: {}\\\".format(cache_entry))\\n\\n return cache_entry\",\n \"def get(self, key):\\n bucket = self.table[self._hash(key)]\\n return [item for item in bucket if item[0] == key][0]\",\n \"def get(self, key):\\n bucket = self.table[self._hash(key)]\\n return [item for item in bucket if item[0] == key][0]\",\n \"def __getattr__(self, key):\\n return self._items[key]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6758728","0.6676352","0.6675846","0.6639574","0.66102517","0.6604584","0.6603278","0.6603278","0.6603278","0.6601982","0.6601982","0.66018176","0.66018176","0.66018176","0.66018176","0.65997744","0.6594028","0.65724087","0.6571191","0.656945","0.6553533","0.6544059","0.65339583","0.6521616","0.6515972","0.6513072","0.6494707","0.6468548","0.6467212","0.6467212","0.64630204","0.64618504","0.6435719","0.64270335","0.64268625","0.64225024","0.6417181","0.6396843","0.63908947","0.6388246","0.6387659","0.6371654","0.63674504","0.63670427","0.63659966","0.6362058","0.6352887","0.6350686","0.63385135","0.6325187","0.63192844","0.63131386","0.6308236","0.63045573","0.6289953","0.62776595","0.62675977","0.62572306","0.6254166","0.62499624","0.6249694","0.62496305","0.6238629","0.6236304","0.6234393","0.6228511","0.62242717","0.6224051","0.6224051","0.6206086","0.6199316","0.61985815","0.61954486","0.619115","0.6173924","0.6170727","0.61694574","0.61681205","0.61673963","0.6165615","0.61589694","0.61589694","0.61589694","0.6154037","0.61475277","0.61449486","0.6123439","0.6121286","0.6120753","0.61073476","0.6103052","0.60974586","0.6090807","0.60886097","0.60882586","0.6088108","0.6087392","0.6086211","0.6084928","0.6084928","0.60842943"],"string":"[\n \"0.6758728\",\n \"0.6676352\",\n \"0.6675846\",\n \"0.6639574\",\n \"0.66102517\",\n \"0.6604584\",\n \"0.6603278\",\n \"0.6603278\",\n \"0.6603278\",\n \"0.6601982\",\n \"0.6601982\",\n \"0.66018176\",\n \"0.66018176\",\n \"0.66018176\",\n \"0.66018176\",\n \"0.65997744\",\n \"0.6594028\",\n \"0.65724087\",\n \"0.6571191\",\n \"0.656945\",\n \"0.6553533\",\n \"0.6544059\",\n \"0.65339583\",\n \"0.6521616\",\n \"0.6515972\",\n \"0.6513072\",\n \"0.6494707\",\n \"0.6468548\",\n \"0.6467212\",\n \"0.6467212\",\n \"0.64630204\",\n \"0.64618504\",\n \"0.6435719\",\n \"0.64270335\",\n \"0.64268625\",\n \"0.64225024\",\n \"0.6417181\",\n \"0.6396843\",\n \"0.63908947\",\n \"0.6388246\",\n \"0.6387659\",\n \"0.6371654\",\n \"0.63674504\",\n \"0.63670427\",\n \"0.63659966\",\n \"0.6362058\",\n \"0.6352887\",\n \"0.6350686\",\n \"0.63385135\",\n \"0.6325187\",\n \"0.63192844\",\n \"0.63131386\",\n \"0.6308236\",\n \"0.63045573\",\n \"0.6289953\",\n \"0.62776595\",\n \"0.62675977\",\n \"0.62572306\",\n \"0.6254166\",\n \"0.62499624\",\n \"0.6249694\",\n \"0.62496305\",\n \"0.6238629\",\n \"0.6236304\",\n \"0.6234393\",\n \"0.6228511\",\n \"0.62242717\",\n \"0.6224051\",\n \"0.6224051\",\n \"0.6206086\",\n \"0.6199316\",\n \"0.61985815\",\n \"0.61954486\",\n \"0.619115\",\n \"0.6173924\",\n \"0.6170727\",\n \"0.61694574\",\n \"0.61681205\",\n \"0.61673963\",\n \"0.6165615\",\n \"0.61589694\",\n \"0.61589694\",\n \"0.61589694\",\n \"0.6154037\",\n \"0.61475277\",\n \"0.61449486\",\n \"0.6123439\",\n \"0.6121286\",\n \"0.6120753\",\n \"0.61073476\",\n \"0.6103052\",\n \"0.60974586\",\n \"0.6090807\",\n \"0.60886097\",\n \"0.60882586\",\n \"0.6088108\",\n \"0.6087392\",\n \"0.6086211\",\n \"0.6084928\",\n \"0.6084928\",\n \"0.60842943\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93498,"cells":{"query":{"kind":"string","value":"Setup of creation of shared libraries in 2 Steps."},"document":{"kind":"string","value":"def _shared_library_in_2steps(env):\r\n\r\n if not config.shared_library_1st in env['BUILDERS']:\r\n # The 1st builder\r\n shlinkcom_name = config.shared_library_1st + \"COM\"\r\n env[shlinkcom_name] = \"${TEMPFILE('$AR /DEF $ARFLAGS /OUT:$TARGET $SOURCES')}\"\r\n ar_action = SCons.Action.Action(\"$\" + shlinkcom_name, \"building '$TARGET' from '$SOURCE'\")\r\n emitter_name = config.shared_library_1st + \"EMITTER\"\r\n env[emitter_name] = [__lib_export_emitter]\r\n env[\"BUILDERS\"][config.shared_library_1st] = SCons.Builder.Builder(\r\n action=ar_action,\r\n emitter=\"$\" + emitter_name,\r\n prefix=\"$LIBPREFIX\",\r\n suffix=\"$LIBSUFFIX\",\r\n src_suffix=\"$SHOBJSUFFIX\",\r\n src_builder=\"SharedObject\")\r\n\r\n if not config.shared_library_2nd in env['BUILDERS']:\r\n # The 2nd builder\r\n emitter_name = config.shared_library_2nd + \"EMITTER\"\r\n env[emitter_name] = [__win32_lib_emitter]\r\n env[\"BUILDERS\"][config.shared_library_2nd] = SCons.Builder.Builder(\r\n action=[SCons.Defaults.SharedCheck,\r\n SCons.Action.Action(\"$SHLINKCOM\", \"building '$TARGET' from '$SOURCE'\")],\r\n emitter=\"$\" + emitter_name,\r\n prefix=\"$SHLIBPREFIX\",\r\n suffix=\"$SHLIBSUFFIX\",\r\n target_scanner=SCons.Scanner.Prog.ProgramScanner(),\r\n src_suffix=\"$SHOBJSUFFIX\",\r\n src_builder=\"SharedObject\")"},"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 setup_lib(CLIB):\n # {{ SETUP_LIB }}","def setup_module():\n common_setup_module()","def initialize_library():\n # return the handle to the shared object\n if os.name == \"nt\":\n pass\n # libc = load_windows_dll()\n else:\n libc = load_linux_so()\n return libc","def setup_environment():\n global _ENV_SETUP_DONE\n if _ENV_SETUP_DONE:\n return\n _ENV_SETUP_DONE = True\n\n _configure_libraries()\n\n custom_module_path = os.environ.get(\"DETECTRON2_ENV_MODULE\")\n\n if custom_module_path:\n setup_custom_environment(custom_module_path)\n else:\n # The default setup is a no-op\n pass","def test_sharedlibs():\n mappath = os.path.join(test_location, \"../test_data/test_gdb_plugin/info_sharedlibs\")\n p = angr.Project(binpath, load_options={\"gdb_map\":mappath, \"gdb_fix\":True})\n check_addrs(p)","def set_up(self):\n self.path.state = self.path.gen.joinpath(\"state\")\n if self.path.state.exists():\n self.path.state.rmtree(ignore_errors=True)\n self.path.state.mkdir()\n\n for script in self.given.get(\"scripts\", []):\n script_path = self.path.state.joinpath(script)\n\n if not script_path.dirname().exists():\n script_path.dirname().makedirs()\n\n script_path.write_text(self.given[\"scripts\"][script])\n script_path.chmod(\"u+x\")\n\n for filename, contents in self.given.get(\"files\", {}).items():\n self.path.state.joinpath(filename).write_text(contents)\n\n self.python = hitchpylibrarytoolkit.project_build(\n \"commandlib\", self.path, self.given[\"python version\"]\n ).bin.python\n\n self.example_py_code = (\n ExamplePythonCode(self.python, self.path.state)\n .with_code(self.given.get(\"code\", \"\"))\n .with_setup_code(self.given.get(\"setup\", \"\"))\n )","def setup_python(self, context: SimpleNamespace) -> None:\n super().setup_python(context)\n\n if os.name == 'nt':\n return\n\n # copy pypy libs\n for libname in ('libpypy3-c.so', 'libpypy3-c.dylib'):\n src_library = Path(context.executable).resolve().parent / libname\n if not src_library.exists():\n continue\n\n dest_library = Path(context.bin_path) / libname\n if dest_library.exists():\n continue\n\n self.symlink_or_copy(str(src_library), str(dest_library))\n if not dest_library.is_symlink():\n dest_library.chmod(0o755)","def elinos_init():\n elinos_env = get_elinos_environment()\n\n solib_dirs = []\n\n # System libraries\n if None in (elinos_env[key] for key in (\"cdk\", \"target\")):\n warn(\"ELinOS system libraries will not be loaded\")\n else:\n solib_prefix = \"%s/%s\" % (elinos_env[\"cdk\"], elinos_env[\"target\"])\n solib_dirs += [\"%s/%s\" % (solib_prefix, \"lib\")]\n gdb.execute(\"set solib-absolute-prefix %s\" % solib_prefix)\n\n # Xenomai libraries. Those are optional, so have a lighter warning\n # if they cannot be located.\n if elinos_env[\"project\"] is None:\n warn(\"Xenomai libraries may not be loaded\")\n else:\n for dir in elinos_env['xenomai']:\n solib_dirs += [\"%s/%s\"\n % (dir, \"xenomai-build/usr/realtime/lib\")]\n\n if len(solib_dirs) != 0:\n gdb.execute(\"set solib-search-path %s\" % \":\".join(solib_dirs))","def init():\n run('mkdir -p %(releases_dir)s' % env)\n execute(cleanup)\n execute(create_directories)","def linking_library_dirs(self):","def shared_temporal_libraries(self):\n foo='shared_temporal_libraries () {\\n'\n foo+='#bring or delete necessary temporary libraries\\n'\n foo+=' e=1\\n' #initialize exit status as error\n if self.shared:\n cmd=sharedexe+' -a \"'+self.shared+'\" -b $$ -c $1' #$1== _PREPARE_ or _CLEANUP_\n foo+=' if '+cmd+'; then e=0;fi\\n'\n else:\n foo+=' echo \"no shared temporal libraries to $1\" && e=0\\n'\n foo+=' return $e\\n'\n foo+='}'\n return foo","def _setup(self):","def _setup(self):","def setup():\n require('hosts', provided_by=[prod])\n require('code_root')\n sudo('apt-get update')\n sudo('apt-get install -y python-setuptools')\n sudo('easy_install pip')\n sudo('pip install virtualenv')\n sudo('aptitude install -y apache2')\n sudo('aptitude install -y libapache2-mod-wsgi')\n sudo('apt-get install -y nginx')\n update_webserver_config()\n sudo('mkdir -p %s; cd %s; virtualenv .;' % (env.code_root, env.code_root))\n sudo('cd %s;mkdir releases; mkdir shared; mkdir packages; mkdir shared/media; mkdir shared/media/file;' % (env.code_root))\n deploy()","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def _copy_bins():\n # STEP 1: If we're performing a build from a copied source tree,\n # copy the generated python files into the package\n\n _clean_bins()\n\n py_z3_build_dir = os.path.join(BUILD_DIR, 'python', 'z3')\n root_z3_dir = os.path.join(ROOT_DIR, 'z3')\n shutil.copy(os.path.join(py_z3_build_dir, 'z3core.py'), root_z3_dir)\n shutil.copy(os.path.join(py_z3_build_dir, 'z3consts.py'), root_z3_dir)\n\n # STEP 2: Copy the shared library, the executable and the headers\n\n os.mkdir(LIBS_DIR)\n os.mkdir(BINS_DIR)\n os.mkdir(HEADERS_DIR)\n shutil.copy(os.path.join(BUILD_DIR, LIBRARY_FILE), LIBS_DIR)\n shutil.copy(os.path.join(BUILD_DIR, EXECUTABLE_FILE), BINS_DIR)\n path1 = glob.glob(os.path.join(BUILD_DIR, \"msvcp*\"))\n path2 = glob.glob(os.path.join(BUILD_DIR, \"vcomp*\"))\n path3 = glob.glob(os.path.join(BUILD_DIR, \"vcrun*\"))\n for filepath in path1 + path2 + path3:\n shutil.copy(filepath, LIBS_DIR)\n\n for header_dir in HEADER_DIRS:\n for fname in os.listdir(header_dir):\n if not fname.endswith('.h'):\n continue\n shutil.copy(os.path.join(header_dir, fname), os.path.join(HEADERS_DIR, fname))\n\n # This hack lets z3 installed libs link on M1 macs; it is a hack, not a proper fix\n # @TODO: Linked issue: https://github.com/Z3Prover/z3/issues/5926\n major_minor = '.'.join(_z3_version().split('.')[:2])\n link_name = None\n if BUILD_PLATFORM in ('win32', 'cygwin', 'win'):\n pass # TODO: When windows VMs work on M1, fill this in\n elif BUILD_PLATFORM in ('darwin', 'osx'):\n split = LIBRARY_FILE.split('.')\n link_name = split[0] + '.' + major_minor + '.' + split[1]\n else:\n link_name = LIBRARY_FILE + '.' + major_minor\n if link_name:\n os.symlink(LIBRARY_FILE, os.path.join(LIBS_DIR, link_name), True)","def setup_once():\n # type: () -> None\n _install_httpx_client()\n _install_httpx_async_client()","def _init_remote():\r\n require('path', provided_by = [staging])\r\n\r\n create_project_dir()\r\n deploy_nosyncdb()\r\n create_virtualenv()\r\n install_requirements()\r\n create_db()\r\n create_secret_settings()\r\n syncdb()\r\n createsuperuser()\r\n install_site()\r\n reload()","def bootstrap():\n validate_configurator_version()\n\n # put new mkinitcpio.conf in place\n run(\"mv /etc/mkinitcpio.conf.pacnew /etc/mkinitcpio.conf\")\n sed(\"/etc/mkinitcpio.conf\",\n 'MODULES=\"\"',\n 'MODULES=\"xen-blkfront xen-fbfront xen-kbdfront xen-netfront xen-pcifront xenbus_probe_frontend xenfs\"') # nopep8\n sed(\"/etc/mkinitcpio.conf\",\n 'HOOKS=\"base udev autodetect modconf block filesystems keyboard fsck',\n 'HOOKS=\"base udev block filesystems shutdown autodetect\"')\n\n # upgrade pacakges\n run(\"pacman --noconfirm -Syu\")\n\n # put new pacman.conf in place\n run(\"mv /etc/pacman.conf.pacnew /etc/pacman.conf\")\n\n # install essential packages\n run(\"pacman --noconfirm -S base-devel\")\n run(\"pacman --noconfirm -S curl git rsync\")\n\n # create a user, named 'aur', to safely install AUR packages under fakeroot\n # uid and gid values auto increment from 1000\n # to prevent conficts set the 'aur' user's gid and uid to 902\n run(\"groupadd -g 902 aur && useradd -m -u 902 -g 902 -G wheel aur\")\n\n # allow users in the wheel group to sudo without a password\n uncomment(\"/etc/sudoers\", \"wheel.*NOPASSWD\")\n\n # install yaourt and upgrade non-pacman rackspace installed packages\n sudo(\"rm -rf /home/aur/.builds && mkdir /home/aur/.builds/\", user=\"aur\")\n with cd(\"/home/aur/.builds/\"):\n sudo(\"bash <(curl aur.sh) -si --noconfirm package-query yaourt\", user=\"aur\")\n sudo(\"yaourt --noconfirm -S xe-guest-utilities\", user=\"aur\")\n\n # allow fabric to sftp with contrib.files.put\n # http://stackoverflow.com/questions/10221839/cant-use-fabric-put-is-there-any-server-configuration-needed # nopep8\n # change before reboot because then the sshd config will be reloaded\n # sed(\"/etc/ssh/sshd_config\", \"Subsystem sftp /usr/lib/openssh/sftp-server\",\n # \"Subsystem sftp internal-sftp\")\n\n # systemd\n sed(\"/boot/grub/menu.lst\",\n \"kernel /boot/vmlinuz-linux root=/dev/xvda1 ro console=hvc0\",\n \"kernel /boot/vmlinuz-linux root=/dev/xvda1 ro console=hvc0 init=/usr/lib/systemd/systemd\")\n reboot()\n if not contains(\"/proc/1/comm\", \"systemd\"):\n abort(\"systemd is not installed properly\")\n server = [s for s in env.bootmachine_servers if s.public_ip == env.host][0]\n run(\"hostnamectl set-hostname {0}\".format(server.name))\n run(\"mv /etc/locale.gen.pacnew /etc/locale.gen.conf\")\n uncomment(\"/etc/locale.gen\", \"en_US.UTF-8 UTF-8\")\n uncomment(\"/etc/locale.gen\", \"en_US ISO-8859-1\")\n run(\"locale-gen\")\n run(\"localectl set-locale LANG='en_US.utf8'\")\n run(\"timedatectl set-timezone US/Central\")","def setup():\n op_dir = rootfs.get_working_dir()\n if not os.path.isdir(op_dir):\n os.mkdir(op_dir)","def main ( ) :\r\n\r\n # checks the command line\r\n\r\n libraryPath = checkArguments()\r\n\r\n # checks whether the library path is defined in a file pythonLibrary.txt\r\n\r\n if libraryPath is None : libraryPath = readLink()\r\n\r\n # checks for current directory\r\n\r\n if libraryPath is None : libraryPath = findDirectory( os.getcwd() )\r\n\r\n # checks whether the current execution prefix ( the directory where we are running python ) contains libraryPython\r\n\r\n if libraryPath is None : libraryPath = findDirectory( sys.exec_prefix )\r\n\r\n # not found\r\n\r\n if libraryPath is None :\r\n\r\n raw_input( sys.argv[ 0 ] + \" - fatal error : library not found. Press any key\" )\r\n\r\n sys.exit( 1 )\r\n\r\n # adds final / if required\r\n\r\n libraryPath = libraryPath.rstrip( \"\\\\/\" ) + os.sep\r\n\r\n # writes the link file (contains library path, speeds up next execution)\r\n\r\n writeLink( libraryPath )\r\n\r\n # appends library and root to search path\r\n\r\n if not libraryPath in sys.path : sys.path = [ libraryPath ] + sys.path\r\n\r\n # appends library and the local copy of python to the system search path so that local python modules have priority\r\n\r\n if os.path.exists( libraryPath + os.sep + sys.platform ) : localPath = libraryPath + os.sep + sys.platform + os.sep\r\n\r\n elif os.path.exists( libraryPath + os.sep + \"python\" ) : localPath = libraryPath + os.sep + \"python\" + os.sep\r\n\r\n else : localPath = None\r\n\r\n if not localPath is None : localPython( localPath )\r\n\r\n # writes the python library directly in sys, for next modules\r\n\r\n sys.libraryPath = libraryPath\r\n\r\n # writes the root of python library in sys, for next modules\r\n\r\n rootPath, dummy = os.path.split( libraryPath.rstrip( \"\\\\/\" ) )\r\n\r\n rootPath = rootPath + os.sep\r\n\r\n sys.rootPath = rootPath\r\n\r\n if not rootPath in sys.path : sys.path = [ rootPath ] + sys.path\r\n\r\n # sets the environment variables (session) for GUIs\r\n\r\n if not localPath is None : setEnvironment( localPath )","def _init_posix():\n so_ext = [s[0] for s in imp.get_suffixes() if s[2] == imp.C_EXTENSION][0]\n\n g = {}\n g['CC'] = \"cc -pthread\"\n g['CXX'] = \"c++ -pthread\"\n g['OPT'] = \"-DNDEBUG -O2\"\n g['CFLAGS'] = \"-DNDEBUG -O2\"\n g['CCSHARED'] = \"-fPIC\"\n g['LDSHARED'] = \"cc -pthread -shared\"\n g['EXT_SUFFIX'] = so_ext\n g['SHLIB_SUFFIX'] = \".so\"\n g['SO'] = so_ext # deprecated in Python 3, for backward compatibility\n g['AR'] = \"ar\"\n g['ARFLAGS'] = \"rc\"\n g['EXE'] = \"\"\n g['LIBDIR'] = os.path.join(sys.prefix, 'lib')\n g['VERSION'] = get_python_version()\n\n if sys.platform[:6] == \"darwin\":\n import platform\n if platform.machine() == 'i386':\n if platform.architecture()[0] == '32bit':\n arch = 'i386'\n else:\n arch = 'x86_64'\n else:\n # just a guess\n arch = platform.machine()\n g['LDSHARED'] += ' -undefined dynamic_lookup'\n g['CC'] += ' -arch %s' % (arch,)\n\n global _config_vars\n _config_vars = g","def setup():\n global RBD_POOL, RBD_STORAGE_CLASS, RBD_SECRET, CEPHFS_OBJ, \\\n CEPHFS_STORAGE_CLASS, CEPHFS_SECRET, RBD_PVC, CEPHFS_PVC\n log.info(\"Creating RBD Pool\")\n RBD_POOL = helpers.create_ceph_block_pool()\n\n log.info(\"Creating RBD Secret\")\n RBD_SECRET = helpers.create_secret(constants.CEPHBLOCKPOOL)\n\n log.info(\"Creating RBD StorageClass\")\n RBD_STORAGE_CLASS = helpers.create_storage_class(\n constants.CEPHBLOCKPOOL, RBD_POOL.name, RBD_SECRET.name\n )\n\n log.info(\"Creating CephFilesystem\")\n CEPHFS_OBJ = helpers.create_cephfilesystem()\n\n log.info(\"Creating FS Secret\")\n CEPHFS_SECRET = helpers.create_secret(constants.CEPHFILESYSTEM)\n\n log.info(\"Creating FS StorageClass\")\n CEPHFS_STORAGE_CLASS = helpers.create_storage_class(\n constants.CEPHFILESYSTEM, helpers.get_cephfs_data_pool_name(),\n CEPHFS_SECRET.name\n )\n\n log.info(\"Creating RBC PVC\")\n RBD_PVC = helpers.create_pvc(sc_name=RBD_STORAGE_CLASS.name)\n\n log.info(\"Creating CephFs PVC\")\n CEPHFS_PVC = helpers.create_pvc(sc_name=CEPHFS_STORAGE_CLASS.name)","def _setup(self) -> None:\n\t\treturn","def setup(conf, products, build=False):\n import distutils.sysconfig\n paths = {\n \"CPPPATH\": distutils.sysconfig.get_python_inc().split(),\n \"LIBPATH\": [],\n }\n libs = []\n dir = distutils.sysconfig.get_config_var(\"LIBPL\")\n if not dir in paths[\"LIBPATH\"]:\n paths[\"LIBPATH\"] += [dir]\n pylibrary = distutils.sysconfig.get_config_var(\"LIBRARY\")\n mat = re.search(\"(python.*)\\.(a|so|dylib)$\", pylibrary)\n if mat:\n libs.append(mat.group(1)) \n for w in (\" \".join([distutils.sysconfig.get_config_var(\"MODLIBS\"),\n distutils.sysconfig.get_config_var(\"SHLIBS\")])).split():\n mat = re.search(r\"^-([Ll])(.*)\", w)\n if mat:\n lL = mat.group(1)\n arg = mat.group(2)\n if lL == \"l\":\n if not arg in libs:\n libs.append(arg)\n else:\n if os.path.isdir(arg) and not arg in paths[\"LIBPATH\"]:\n paths[\"LIBPATH\"].append(arg)\n conf.env.PrependUnique(**paths)\n for lib in libs:\n if lib not in conf.env.libs[\"python\"]:\n conf.env.libs[\"python\"].append(lib)\n return {\"paths\": paths, \"libs\": {\"python\": libs}}","def run(self):\n self._make_lib_file_symbolic_links()\n self._copy_each_include_files_to_include_dir()\n self._make_dep_lib_file_sym_links_and_copy_include_files()\n self.setup_py.add_patchs_to_build_without_pkg_config(\n self.rpm.lib_dir, self.rpm.include_dir\n )\n self.setup_py.apply_and_save()\n self._build_and_install()","def initLibPath():\n libHash = {\n 'Framework': 1,\n 'UserControlleLib': 1,\n 'CaseLib': 1\n }\n\n binPath = os.path.split(os.path.realpath(__file__))[0]\n\n for key in libHash:\n sys.path.append(os.path.join(__getLibAbsPath(binPath, libHash[key]), key))","def setup_cross():\n if not os.path.exists(cross_prefix):\n docmd(\"mkdir %s\" % cross_prefix)\n epath = os.environ[\"PATH\"]\n set_evar(\"PATH\", \"%s/bin:%s\" % (cross_prefix, epath))","def bootstrap():\n\n require('environment', provided_by=env.environments)\n sudo('mkdir -p %(root)s' % env, user=env.deploy_user)\n clone_repo()\n setup_dirs()\n link_config_files()\n update_services()\n create_virtualenv()\n update_requirements()\n create_local_settings()","def set_up(dev=False):\n _install_dependencies()","def setup():\n _confirm_branch()\n \n require('settings', provided_by=[production, staging])\n require('branch', provided_by=[stable, master, branch])\n \n setup_directories()\n setup_virtualenv()\n clone_repo()\n checkout_latest()\n install_requirements()\n install_apache_conf()\n deploy_to_s3()","def _swift_saio_setup(self):\n self._swift_storage_setup()\n self._swift_proxy_setup()","def setup():\r\n global venvs\r\n\r\n try:\r\n os.mkdir(basedir)\r\n except OSError, e:\r\n if e.errno != errno.EEXIST:\r\n raise\r\n os.chdir(basedir)\r\n\r\n # Delete virtualenvs and recreate\r\n for venv in glob('venv-*'):\r\n shutil.rmtree(venv)\r\n for py in available_python_versions():\r\n check_call(['virtualenv', '-p', py,\r\n '--system-site-packages', 'venv-%s' % py])\r\n venvs.append((py, 'venv-%s' % py))\r\n\r\n # Check out and update the repository\r\n if not os.path.exists('Theano'):\r\n try:\r\n check_call(['git', 'clone', ipy_repository])\r\n except CalledProcessError:\r\n check_call(['git', 'clone', ipy_http_repository])\r\n os.chdir(repodir)\r\n check_call(['git', 'checkout', 'master'])\r\n try:\r\n check_call(['git', 'pull', ipy_repository, 'master'])\r\n except CalledProcessError:\r\n check_call(['git', 'pull', ipy_http_repository, 'master'])\r\n os.chdir(basedir)","def initialize():\n\n # create plugin locations\n for p in (cache_path, config_path, data_path):\n p.mkdir(parents=False, exist_ok=True)","def __setup(self):\n\n build_environment = []\n\n # The download URL has the format contains vMAJOR.MINOR in the\n # path and the tarball contains MAJOR.MINOR.REVISION, so pull\n # apart the full version to get the MAJOR and MINOR components.\n match = re.match(r'(?P<major>\\d+)\\.(?P<minor>\\d+)', self.version)\n major_minor = 'v{0}.{1}'.format(match.groupdict()['major'],\n match.groupdict()['minor'])\n tarball = 'openmpi-{}.tar.bz2'.format(self.version)\n url = '{0}/{1}/downloads/{2}'.format(self.baseurl, major_minor,\n tarball)\n\n # CUDA\n if self.cuda:\n if self.__toolchain.CUDA_HOME:\n self.configure_opts.append(\n '--with-cuda={}'.format(self.__toolchain.CUDA_HOME))\n else:\n self.configure_opts.append('--with-cuda')\n else:\n self.configure_opts.append('--without-cuda')\n\n # InfiniBand\n if self.infiniband:\n self.configure_opts.append('--with-verbs')\n else:\n self.configure_opts.append('--without-verbs')\n\n # UCX\n if self.__ucx:\n if isinstance(self.__ucx, string_types):\n # Use specified path\n self.configure_opts.append('--with-ucx={}'.format(self.__ucx))\n else:\n self.configure_opts.append('--with-ucx')\n\n # If UCX was built with CUDA support, it is linked with\n # libcuda.so.1, which is not available during the\n # build stage. Assume that if OpenMPI is built with\n # CUDA support, then UCX was as well...\n if self.cuda:\n cuda_home = \"/usr/local/cuda\"\n if self.__toolchain.CUDA_HOME:\n cuda_home = self.__toolchain.CUDA_HOME\n self.__commands.append('ln -s {0} {1}'.format(\n os.path.join(cuda_home, 'lib64', 'stubs', 'libcuda.so'),\n os.path.join(cuda_home, 'lib64', 'stubs', 'libcuda.so.1')))\n if not self.__toolchain.LD_LIBRARY_PATH:\n build_environment.append('LD_LIBRARY_PATH=\"{}:$LD_LIBRARY_PATH\"'.format(os.path.join(cuda_home, 'lib64', 'stubs')))\n\n if self.directory:\n # Use source from local build context\n self.__commands.append(self.configure_step(\n directory=os.path.join(self.__wd, self.directory),\n toolchain=self.__toolchain))\n else:\n # Download source from web\n self.__commands.append(self.download_step(url=url,\n directory=self.__wd))\n self.__commands.append(self.untar_step(\n tarball=os.path.join(self.__wd, tarball), directory=self.__wd))\n self.__commands.append(self.configure_step(\n directory=os.path.join(self.__wd,\n 'openmpi-{}'.format(self.version)),\n environment=build_environment,\n toolchain=self.__toolchain))\n\n self.__commands.append(self.build_step())\n\n if self.__check:\n self.__commands.append(self.check_step())\n\n self.__commands.append(self.install_step())\n\n # Set library path\n libpath = os.path.join(self.prefix, 'lib')\n if self.ldconfig:\n self.__commands.append(self.ldcache_step(directory=libpath))\n else:\n self.__environment_variables['LD_LIBRARY_PATH'] = '{}:$LD_LIBRARY_PATH'.format(libpath)\n\n if self.directory:\n # Using source from local build context, cleanup directory\n self.__commands.append(self.cleanup_step(\n items=[os.path.join(self.__wd, self.directory)]))\n else:\n # Using downloaded source, cleanup tarball and directory\n self.__commands.append(self.cleanup_step(\n items=[os.path.join(self.__wd, tarball),\n os.path.join(self.__wd,\n 'openmpi-{}'.format(self.version))]))","def setup(self):\n\t\tpass","def setup():\n require('hosts', 'project_path', provided_by=envs.ENVS)\n\n if not exists(env.project_path):\n abort(red('Project path ({project_path}) does not exist. '\n 'Create it on the server before continuing.'.format(**env)))\n\n with cd(env.project_path):\n run('mkdir -p api renderer conf markup_renderer')\n run('mkdir -p api/static api/uploads')\n\n make_release_folders('api')\n make_release_folders('renderer')","def bootstrap():\n _require_environment()\n\n adduser()\n install_python()\n install_git()\n install_apache()\n install_mysql()\n setup_project()","def bootstrap():\n sub_install_packages()\n sub_install_virtualenv()\n sub_create_virtualenv()\n sub_install_python_requirements()","def setup():\n find_modules('alerters')\n find_modules('watchers')\n find_modules('auditors')","def setup_binutils():\n # Set up binutils\n global binutils_subdir\n binutils_subdir = \"binutils\"\n if binutils_version:\n binutils_subdir = \"binutils-%s\" % binutils_version\n if not os.path.exists(binutils_subdir):\n docmd(\"wget http://ftpmirror.gnu.org/binutils/\"\n \"%s.tar.bz2\" % binutils_subdir)\n docmd(\"tar jxf %s.tar.bz2\" % binutils_subdir)\n else:\n if not os.path.exists(binutils_subdir):\n doscmd(\"git clone --depth 1 %s binutils\" % binutils_git)\n # Configure binutils\n if not os.path.exists(binutils_build_dir):\n docmd(\"mkdir %s\" % binutils_build_dir)\n dochdir(binutils_build_dir)\n doscmd(\"../%s/configure --prefix=%s --target=%s \"\n \"%s \" % (binutils_subdir,\n cross_prefix,\n flag_target_arch,\n flag_use_multilib))\n doscmd(\"make %s \" % flag_parfactor)\n doscmd(\"make %s install\" % flag_parfactor)\n dochdir(\"..\")","def fake(ctx, clean=False):\n work_dir = join(PROJ_ROOT, \"func\", \"dynlink\")\n build_dir = join(PROJ_ROOT, \"build\", \"libfake\")\n\n clean_dir(build_dir, clean)\n\n build_cmd = [\n \"cmake\",\n \"-GNinja\",\n \"-DFAASM_BUILD_SHARED=ON\",\n \"-DFAASM_BUILD_TYPE=wasm\",\n \"-DCMAKE_TOOLCHAIN_FILE={}\".format(CMAKE_TOOLCHAIN_FILE),\n \"-DCMAKE_BUILD_TYPE=Release\",\n \"-DCMAKE_INSTALL_PREFIX={}\".format(WASM_SYSROOT),\n work_dir,\n ]\n\n run(\" \".join(build_cmd), shell=True, cwd=build_dir, check=True)\n run(\"ninja\", shell=True, cwd=build_dir, check=True)\n run(\"ninja install\", shell=True, cwd=build_dir, check=True)\n\n # Copy shared object into place\n sysroot_files = join(WASM_SYSROOT, \"lib\", \"wasm32-wasi\", \"libfake*.so\")\n\n runtime_lib_dir = join(FAASM_RUNTIME_ROOT, \"lib\")\n if not exists(runtime_lib_dir):\n makedirs(runtime_lib_dir)\n\n run(\n \"cp {} {}\".format(sysroot_files, runtime_lib_dir),\n shell=True,\n check=True,\n )\n\n # Update env\n shell_env = copy(environ)\n shell_env.update(\n {\n \"LD_LIBRARY_PATH\": \"/usr/local/lib/\",\n }\n )\n\n # Run codegen\n shared_objs = [\n join(FAASM_RUNTIME_ROOT, \"lib\", \"libfakeLibA.so\"),\n join(FAASM_RUNTIME_ROOT, \"lib\", \"libfakeLibB.so\"),\n ]\n\n binary = find_codegen_shared_lib()\n\n for so in shared_objs:\n print(\"Running codegen for {}\".format(so))\n run(\"{} {}\".format(binary, so), env=shell_env, shell=True, check=True)","def set_shared_lib_options(self, task):\n pass","def install_step(self):\n # run 'make install' in parallel since it involves more compilation\n self.cfg.update('installopts', \"-j %s\" % self.cfg['parallel'])\n super(EB_GROMACS, self).install_step()\n\n # the GROMACS libraries get installed in different locations (deeper subdirectory), depending on the platform;\n # this is determined by the GNUInstallDirs CMake module;\n # rather than trying to replicate the logic, we just figure out where the library was placed\n\n if self.toolchain.options.get('dynamic', False):\n self.libext = get_shared_lib_ext()\n else:\n self.libext = 'a'\n\n if LooseVersion(self.version) < LooseVersion('5.0'):\n libname = 'libgmx*.%s' % self.libext\n else:\n libname = 'libgromacs*.%s' % self.libext\n\n for libdir in ['lib', 'lib64']:\n if os.path.exists(os.path.join(self.installdir, libdir)):\n for subdir in [libdir, os.path.join(libdir, '*')]:\n libpaths = glob.glob(os.path.join(self.installdir, subdir, libname))\n if libpaths:\n self.lib_subdir = os.path.dirname(libpaths[0])[len(self.installdir)+1:]\n self.log.info(\"Found lib subdirectory that contains %s: %s\", libname, self.lib_subdir)\n break\n if not self.lib_subdir:\n raise EasyBuildError(\"Failed to determine lib subdirectory in %s\", self.installdir)\n\n # Install a version with the MPI suffix\n if self.toolchain.options.get('usempi', None):\n if LooseVersion(self.version) < LooseVersion('4.6'):\n\n cmd = \"make distclean\"\n (out, _) = run_cmd(cmd, log_all=True, simple=False)\n\n self.cfg.update('configopts', \"--enable-mpi --program-suffix={0}\".format(self.cfg['mpisuffix']))\n ConfigureMake.configure_step(self)\n\n super(EB_GROMACS, self).build_step()\n\n super(EB_GROMACS, self).install_step()\n\n else:\n self.cfg['configopts'] = re.sub(r'-DGMX_MPI=OFF', r'', self.cfg['configopts'])\n\n if self.cfg['mpi_numprocs'] == 0:\n self.log.info(\"No number of test MPI tasks specified -- using default: %s\" % self.cfg['parallel'])\n self.cfg['mpi_numprocs'] = self.cfg['parallel']\n\n elif self.cfg['mpi_numprocs'] > self.cfg['parallel']:\n self.log.warning(\"Number of test MPI tasks (%s) is greater than value for 'parallel': %s\",\n self.cfg['mpi_numprocs'], self.cfg['parallel'])\n\n self.cfg.update('configopts', \"-DGMX_MPI=ON -DGMX_THREAD_MPI=OFF\")\n\n mpiexec = which(self.cfg['mpiexec'])\n if mpiexec:\n self.cfg.update('configopts', \"-DMPIEXEC=%s\" % mpiexec)\n self.cfg.update('configopts', \"-DMPIEXEC_NUMPROC_FLAG=%s\" % self.cfg['mpiexec_numproc_flag'])\n self.cfg.update('configopts', \"-DNUMPROC=%s\" % self.cfg['mpi_numprocs'])\n elif self.cfg['runtest']:\n raise EasyBuildError(\"'%s' not found in $PATH\", self.cfg['mpiexec'])\n\n\n self.log.info(\"Using %s as MPI executable when testing, with numprocs flag '%s' and %s tasks\",\n self.cfg['mpiexec'], self.cfg['mpiexec_numproc_flag'], self.cfg['mpi_numprocs'])\n\n # clean up obj dir before reconfiguring\n shutil.rmtree(os.path.join(self.builddir, 'easybuild_obj'))\n\n # rebuild/test/install with MPI options\n super(EB_GROMACS, self).configure_step()\n super(EB_GROMACS, self).build_step()\n super(EB_GROMACS, self).test_step()\n super(EB_GROMACS, self).install_step()\n\n self.log.info(\"A full regression test suite is available from the GROMACS web site\")","def _setup(self):\n self._raw_top_dir = os.path.join(self._snippets_dir,\"raw\",\"dynamic\")\n if not os.path.exists(self._raw_top_dir):\n os.mkdir(self._raw_top_dir)\n\n self._trec_top_dir = os.path.join(self._snippets_dir,\"trec\",\"dynamic\")\n if not os.path.exists(self._trec_top_dir):\n os.mkdir(self._trec_top_dir)\n\n self._temp_top_dir = os.path.join(self._snippets_dir,\"temp\",\"dynamic\")\n if not os.path.exists(self._temp_top_dir):\n os.mkdir(self._temp_top_dir)\n\n self._snippet_result_top_dir = os.path.join(self._snippets_dir,\"result\",\"dynamic\")\n if not os.path.exists(self._snippet_result_top_dir):\n os.mkdir(self._snippet_result_top_dir)\n\n self._snippet_index_top_dir = os.path.join(self._snippets_dir,\"index\",\"dynamic\")\n if not os.path.exists(self._snippet_index_top_dir):\n os.mkdir(self._snippet_index_top_dir)\n\n self._para_top_dir = os.path.join(self._snippets_dir,\"para\",\"dynamic\")\n if not os.path.exists(self._para_top_dir):\n os.mkdir(self._para_top_dir)","def setup():\n\n debs = (\"python-setuptools\", \"apache2\", \"libapache2-mod-wsgi\")\n\n require(\"hosts\", provided_by=[production, staging])\n sudo(\"apt-get install %s\" % \" \".join(debs))\n sudo(\"easy_install virtualenv pip\")\n sudo(\"mkdir -p %(path)s\" % env)\n with cd(\"%(path)s\" % env):\n sudo(\"mkdir -p releases; mkdir -p packages\")\n sudo(\"virtualenv --no-site-packages .\")\n sudo(\"mkdir -p /var/log/twit-demo; chown www-data:www-data /var/log/twit-demo\")","def _setup(app_obj):","def _setup_modules(self):\r\n module_registry = AppModule.module_registry()\r\n for bundle in topological_sort(AppModule.module_dependencies()):\r\n for module_label in bundle:\r\n assert module_label in module_registry\r\n module = module_registry[module_label]\r\n self._debug_log('Initializing: %s (%s)' % (module.label(), module.description()))\r\n try:\r\n module.setup_function()\r\n except AppModule.Unimplemented:\r\n pass\r\n self._init_modules.append(module.label())","def init():\n \n # ensure that required libraries are loaded\n LoadLibrary = ctypes.windll.kernel32.LoadLibraryA\n LoadLibrary(\"kernel32.dll\")\n\n hooks = [ (\"kernel32.dll\", \"LoadLibraryA\", LoadLibraryA_handler),\n (\"kernel32.dll\", \"GetProcAddress\", GetProcAddress_handler),\n (\"kernel32.dll\", \"malloc\", malloc_handler),\n (\"kernel32.dll\", \"memset\", memset_handler),\n (\"kernel32.dll\", \"ReadProcessMemory\", ReadProcessMemory_handler),\n (\"kernel32.dll\", \"VirtualAllocEx\", VirtualAllocEx_handler),\n (\"kernel32.dll\", \"WriteProcessMemory\", \\\n WriteProcessMemory_handler),\n ]\n\n for (dll_name, func_name, handler) in hooks:\n if not pybox.register_hook(dll_name,\n func_name,\n handler):\n logging.error(\"Failed to register hook for %s\" % func_name)\n \n return","def setup(self):\n pass # pragma: no cover","def _init_nt():\n g = {}\n g['EXE'] = \".exe\"\n g['SO'] = \".pyd\"\n g['SOABI'] = g['SO'].rsplit('.')[0] # xxx?\n\n global _config_vars\n _config_vars = g","def setup():\n pass","def __setup(self):\n\n if self.__tarball:\n tarball = posixpath.basename(self.__tarball)\n\n # Figure out the version from the tarbal name\n match = re.match(r'Arm-Compiler-for-HPC_(?P<year>\\d\\d)\\.0?(?P<month>[1-9][0-9]?)',\n tarball)\n if match and match.groupdict()['year'] and match.groupdict()['month']:\n self.__version = '{0}.{1}'.format(match.groupdict()['year'],\n match.groupdict()['month'])\n else:\n # The download URL has the format MAJOR-MINOR in the path\n # and the tarball contains MAJOR.MINOR, so pull apart the\n # full version to get the individual components.\n match = re.match(r'(?P<major>\\d+)\\.(?P<minor>\\d+)', self.__version)\n major_minor = '{0}-{1}'.format(match.groupdict()['major'],\n match.groupdict()['minor'])\n\n tarball = 'Arm-Compiler-for-HPC_{0}_{1}_aarch64.tar'.format(\n self.__version, self.__package_string)\n url = '{0}/{1}/{2}/{3}'.format(self.__baseurl, major_minor,\n self.__url_string, tarball)\n\n # Download source from web\n self.__commands.append(self.download_step(url=url,\n directory=self.__wd))\n\n # Untar package\n self.__commands.append(self.untar_step(\n tarball=posixpath.join(self.__wd, tarball), directory=self.__wd))\n\n # Install\n install_args = ['--install-to {}'.format(self.__prefix)]\n if self.__eula:\n install_args.append('--accept')\n package_directory = 'ARM-Compiler-for-HPC_{0}_AArch64_{1}_aarch64'.format(self.__version, self.__package_string)\n self.__commands.append('cd {0} && ./{1} {2}'.format(\n posixpath.join(self.__wd, package_directory),\n self.__installer_template.format(self.__version),\n ' '.join(install_args)))\n\n # The default install includes the Arm Performance Libraries for\n # multiple Arm variants. The install is not configurable, and\n # the non generic aarch64 bits are very large, so remove them.\n if self.__armpl_generic_aarch64_only:\n self.__commands.append(self.__generic_aarch64_only)\n\n # Cleanup tarball and directory\n self.__commands.append(self.cleanup_step(\n items=[posixpath.join(self.__wd, tarball),\n posixpath.join(self.__wd, package_directory)]))\n\n # Set environment\n gcc_path = posixpath.join(\n self.__prefix,\n 'gcc-{0}_Generic-AArch64_{1}_aarch64-linux'.format(\n self.__gcc_version, self.__directory_string))\n llvm_path = posixpath.join(\n self.__prefix,\n 'arm-hpc-compiler-{0}_Generic-AArch64_{1}_aarch64-linux'.format(self.__version, self.__directory_string))\n self.environment_variables['COMPILER_PATH'] = '{}:$COMPILER_PATH'.format(gcc_path)\n self.environment_variables['CPATH'] = '{0}:{1}:$CPATH'.format(\n posixpath.join(gcc_path, 'include'),\n posixpath.join(llvm_path, 'include'))\n self.environment_variables['LD_LIBRARY_PATH'] = '{0}:{1}:{2}:$LD_LIBRARY_PATH'.format(\n posixpath.join(gcc_path, 'lib'), posixpath.join(gcc_path, 'lib64'),\n posixpath.join(llvm_path, 'lib'))\n self.environment_variables['LIBRARY_PATH'] = '{0}:{1}:{2}:$LIBRARY_PATH'.format(\n posixpath.join(gcc_path, 'lib'), posixpath.join(gcc_path, 'lib64'),\n posixpath.join(llvm_path, 'lib'))\n self.environment_variables['PATH'] = '{0}:{1}:$PATH'.format(\n posixpath.join(gcc_path, 'bin'), posixpath.join(llvm_path, 'bin'))","def test_1_make(self):\n #We can compile all these modules together into a single shared library.\n writer = self.writers.values()[0]\n self.code = writer.make(remake=True, dependencies=self.dependencies)\n self.assertEqual(self.code, 0)","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setUpModule():\n args = [\"bowtie-build\",REF_FILES[\"yeast_fasta\"],_ebwt]\n with open(os.devnull,\"a\") as null:\n try:\n subprocess.check_call(args,stdout=null,stderr=subprocess.STDOUT)\n except CalledProcessError as e:\n print(\"Could not build bowtie index for crossmap test.\")\n raise e","def setup_ctypes():\n lib.createComplex.argtypes = [ctypes.c_double, ctypes.c_double]\n lib.createComplex.restype = ctypes.c_void_p\n\n lib.deleteComplex.argypes = [ctypes.c_void_p]\n lib.deleteComplex.restype = None\n\n lib.getRealPart.argypes = [ctypes.c_void_p]\n lib.getRealPart.restype = ctypes.c_double\n\n lib.getImaginaryPart.argypes = [ctypes.c_void_p]\n lib.getImaginaryPart.restype = ctypes.c_double\n\n lib.add.argypes = [ctypes.c_void_p, ctypes.c_void_p]\n lib.add.restype = ctypes.c_void_p\n\n lib.equals.argtypes = [ctypes.c_void_p, ctypes.c_void_p]\n lib.equals.restype = ctypes.c_bool","async def _setup(self):","def fixLDPath( root, ldpath, directory ):\n\n if os.path.exists( directory ):\n shutil.rmtree( directory )\n\n start = os.getcwd()\n os.mkdir( directory )\n os.chdir( directory )\n uniqueLD = uniquePath( ldpath )\n\n if DEBUG:\n print 'Unique LD LIBRARY PATH is:'\n print uniqueLD\n sys.stdout.flush()\n\n ldlist = string.split( uniqueLD, ':' )\n if DEBUG:\n print ''\n print 'LD List is:'\n print ldlist\n print ''\n sys.stdout.flush()\n\n for path in ldlist:\n if os.path.exists( path ):\n\n if DEBUG:\n print 'Searching for shared libraries in:'\n print path\n print '-----------------------------------------------'\n res = shellCall( 0, 'ls ' + path + '/*.so*' )\n if res['OK']:\n print res['Value']\n else:\n print res\n print '-----------------------------------------------'\n\n output = shellCall( 0, 'ls ' + path + '/*.so*' )\n #must be tidied for Windows (same below)\n\n if DEBUG:\n if not output['OK']:\n print '**************************'\n print 'Warning, problem with ls:'\n print output\n print '**************************'\n\n if not output['Value'][0]:\n ldlibs = output['Value'][1].split( '\\n' )\n for lib in ldlibs:\n if os.path.exists( lib ):\n filename = os.path.basename( lib )\n output = shellCall( 0, 'ln -s ' + str( lib ) + ' ' + str( filename ) )\n #N.B. for Windows this should be a copy...\n if DEBUG:\n if not output['OK']:\n print '********************************'\n print 'Warning, problem creating link:'\n print 'File: ', filename\n print 'Path: ', lib\n print output\n print '********************************'\n\n if DEBUG:\n print 'Searching for rootmap file in:'\n print path\n print '-----------------------------------------------'\n res = shellCall( 0, 'ls ' + path + '/*rootmap*' )\n if res['OK']:\n print res['Value']\n else:\n print res\n print '-----------------------------------------------'\n\n output = shellCall( 0, 'ls ' + path + '/*rootmap*' )\n\n if DEBUG:\n if not output['OK']:\n print '**************************'\n print 'Warning, problem with rootmap:'\n print output\n print '**************************'\n\n if not output['Value'][0]:\n ldlibs = output['Value'][1].split( '\\n' )\n for lib in ldlibs:\n if os.path.exists( lib ):\n if re.search( 'RELAX', lib ) is not None:\n filename = os.path.basename( lib )\n output = shellCall( 0, 'ln -s ' + str( lib ) + ' ' + str( filename ) )\n if DEBUG:\n if not output['OK']:\n print '********************************'\n print 'Warning, problem creating link:'\n print 'File: ', filename\n print 'Path: ', lib\n print output\n print '********************************'\n\n os.chdir( start )\n sys.stdout.flush()","def setup(self):\n pass","def bootstrap_aws():\n sub_install_packages()\n sub_install_virtualenv()\n sub_create_virtualenv()\n sub_install_python_requirements_aws()","def setup():\n\tglobal config_parser, config_file\n\tglobal prefix\n\n\tif os.path.islink(sys.argv[0]):\n\t\tlink = os.readlink(sys.argv[0])\n\n\t\tif not os.path.isabs(link):\n\t\t\tlink = os.path.join(os.path.dirname(sys.argv[0]), link)\n\n\t\tprefix = os.path.dirname(os.path.abspath(link))\n\telse:\n\t\tprefix = os.path.dirname(os.path.abspath(sys.argv[0]))\n\n\tconfig_parser = ConfigParser.ConfigParser()\n\tset_defaults()\n\n\tconfig_file = os.path.join (xdg_config_home, \"sushi\", \"nigiri\")\n\n\tif not check_config_file(config_file):\n\t\tprint \"Config file creation failed. Aborting.\"\n\t\treturn\n\n\tread_config_file()","def set_up_workspace():\n # Avoid Error #15: Initializing libiomp5.dylib, but found libiomp5.dylib already initialized.\n # https://stackoverflow.com/questions/53014306/error-15-initializing-libiomp5-dylib-but-found-libiomp5-dylib-already-initial\n os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'\n\n # Magic command for inline plotting\n # %matplotlib inline\n # %config InlineBackend.figure_format = 'retina'","def init ():\n freeze_support () # for specific uses of the program on Windows","def setup():\n\n with cd(env.homedir):\n\n # clone repository from github\n sudo('git clone https://github.com/starzel/demo.starzel.de.git', user=env.deploy_user) # noqa: E501\n\n with cd(env.directory):\n\n # requirements\n # sudo('python python-dev build-essential zlib1g-dev libssl-dev libxml2-dev libxslt1-dev wv poppler-utils libtiff5-dev libjpeg62-dev zlib1g-dev libfreetype6-dev liblcms1-dev libwebp-dev') # noqa: E501\n\n # prepare buildout\n sudo('ln -s local_production.cfg local.cfg', user=env.deploy_user)\n sudo('echo -e \"[buildout]\\nlogin = admin\\npassword = admin\" > secret.cfg', user=env.deploy_user) # noqa: E501\n\n # bootstrap and run bildout once\n sudo('./bin/pip install -r requirements.txt', user=env.deploy_user)\n sudo('./bin/buildout', user=env.deploy_user)\n\n # start supervisor which starts plone instance also\n sudo('./bin/supervisord', user=env.deploy_user)","def setup(self):\n ...","def setup_prod():\n setup_general()","def _setup(self):\n mkdir_p(self.output_folder)\n if self.symlink_dir:\n mkdir_p(self.symlink_dir)\n try:\n selected_versions = self._resolve_dependencies()\n if selected_versions:\n self._write_lock(selected_versions)\n print('\\n\\nVersions Selected for downloading:\\n')\n print('\\t' + '\\n\\t'.join(['{}: {}'.format(req, ver) for req, ver in selected_versions.items()]) + '\\n')\n for pkg_name, version in selected_versions.items():\n pkg_metadata = self._get_metadata(pkg_name)\n version_metadata = pkg_metadata.get('versions', dict()).get(str(version), dict())\n self._download_package(version_metadata)\n except (RequirementMatchError, DependencyError) as e:\n print(e.message)\n return self.created()","def setup_dirs():\n\n require('environment', provided_by=env.environments)\n sudo('mkdir -p %(log_dir)s' % env, user=env.deploy_user)\n sudo('chmod a+w %(log_dir)s' % env )\n sudo('mkdir -p %(services)s/nginx' % env, user=env.deploy_user)\n sudo('mkdir -p %(services)s/supervisor' % env, user=env.deploy_user)\n sudo('mkdir -p %(services)s/gunicorn' % env, user=env.deploy_user)\n sudo('mkdir -p %(media_root)s' % env)\n sudo('chown %(webserver_user)s %(media_root)s' % env)\n sudo('mkdir -p %(static_root)s' % env)\n sudo('chown %(webserver_user)s %(static_root)s' % env)","def library_dirs(self):","def setup(self):\n self.cwd = os.getcwd()\n self.t = tempfile.mkdtemp()\n dir_path = Path(\"packages\")\n tmp_dir = self.t / dir_path\n src_dir = self.cwd / Path(ROOT_DIR, dir_path)\n shutil.copytree(str(src_dir), str(tmp_dir))\n shutil.copytree(Path(CUR_PATH, \"data\", \"dummy_aea\"), Path(self.t, \"dummy_aea\"))\n os.chdir(Path(self.t, \"dummy_aea\"))\n self.runner = CliRunner()","def perform():\n others = not flag_do_only_gcc_build\n locate_gcc_subdir()\n setup_cross()\n if others:\n setup_kernel_headers()\n setup_binutils()\n setup_prereqs()\n setup_sysroot()\n setup_gcc()\n if others:\n setup_kernel_headers()\n setup_glibc()","def _server_env(load_library, work_path=None):\n if work_path:\n temp = work_path\n else:\n temp = utils.tempdir()\n\n # pylint: disable=unused-variable\n @tvm._ffi.register_func(\"tvm.rpc.server.workpath\", override=True)\n def get_workpath(path):\n return temp.relpath(path)\n\n @tvm._ffi.register_func(\"tvm.rpc.server.load_module\", override=True)\n def load_module(file_name):\n \"\"\"Load module from remote side.\"\"\"\n path = temp.relpath(file_name)\n m = _load_module(path)\n logger.info(\"load_module %s\", path)\n return m\n\n @tvm._ffi.register_func(\"tvm.rpc.server.download_linked_module\", override=True)\n def download_linked_module(file_name):\n \"\"\"Load module from remote side.\"\"\"\n # pylint: disable=import-outside-toplevel\n path = temp.relpath(file_name)\n\n if path.endswith(\".o\"):\n # Extra dependencies during runtime.\n from tvm.contrib import cc as _cc\n\n _cc.create_shared(path + \".so\", path)\n path += \".so\"\n elif path.endswith(\".tar\"):\n # Extra dependencies during runtime.\n from tvm.contrib import cc as _cc, tar as _tar\n\n tar_temp = utils.tempdir(custom_path=path.replace(\".tar\", \"\"))\n _tar.untar(path, tar_temp.temp_dir)\n files = [tar_temp.relpath(x) for x in tar_temp.listdir()]\n _cc.create_shared(path + \".so\", files)\n path += \".so\"\n elif path.endswith(\".dylib\") or path.endswith(\".so\"):\n pass\n else:\n raise RuntimeError(f\"Do not know how to link {file_name}\")\n logger.info(\"Send linked module %s to client\", path)\n return bytearray(open(path, \"rb\").read())\n\n libs = []\n load_library = load_library.split(\":\") if load_library else []\n for file_name in load_library:\n file_name = find_lib_path(file_name)[0]\n libs.append(ctypes.CDLL(file_name, ctypes.RTLD_GLOBAL))\n logger.info(\"Load additional library %s\", file_name)\n temp.libs = libs\n return temp","def setup(verbose=True):\n global _SETUP_DONE\n if _SETUP_DONE:\n return\n _ensure_base_dirs(verbose=False)\n _setup_logging()\n _SETUP_DONE = True","def disk_lib_init():\n global is_64bits\n global use_sidecar_create\n\n # Define arg types for disk lib apis.\n if sys.hexversion >= PYTHON64_VERSION:\n is_64bits = True\n load_disk_lib(DISK_LIB64)\n lib.DiskLib_OpenWithInfo.argtypes = [c_char_p, c_int32,\n POINTER(c_uint32),\n POINTER(c_uint64),\n POINTER(c_uint64)]\n lib.DiskLib_Close.argtypes = [c_uint64]\n\n lib.DiskLib_SidecarOpen.argtypes = [c_uint64, c_char_p, c_int32,\n POINTER(c_uint64)]\n lib.DiskLib_SidecarClose.argtypes = [c_uint64, c_char_p,\n POINTER(c_uint64)]\n lib.DiskLib_DBGet.argtypes = [c_uint64, c_char_p, POINTER(c_char_p)]\n lib.DiskLib_DBSet.argtypes = [c_uint64, c_char_p, c_char_p]\n lib.DiskLib_GetSize.argtypes = [c_uint64, c_uint32,\n c_uint32, POINTER(disk_info)]\n # Check if this library supports create API\n try:\n lib.DiskLib_SidecarCreate.argtypes = [c_uint64, c_char_p, c_uint64,\n c_int32, POINTER(c_uint64)]\n lib.DiskLib_SidecarCreate.restype = int\n use_sidecar_create = True\n except:\n logging.debug(\n \"ESX version doesn't support create API, using open instead.\")\n pass\n else:\n load_disk_lib(DISK_LIB)\n lib.DiskLib_OpenWithInfo.argtypes = [c_char_p, c_int32,\n POINTER(c_uint32),\n POINTER(c_uint32),\n POINTER(c_uint32)]\n lib.DiskLib_Close.argtypes = [c_uint32]\n lib.DiskLib_SidecarOpen.argtypes = [c_uint32, c_char_p, c_int32,\n POINTER(c_uint32)]\n lib.DiskLib_SidecarClose.argtypes = [c_uint32, c_char_p,\n POINTER(c_uint32)]\n lib.DiskLib_DBGet.argtypes = [c_uint32, c_char_p, POINTER(c_char_p)]\n lib.DiskLib_DBSet.argtypes = [c_uint32, c_char_p, c_char_p]\n lib.DiskLib_GetSize.argtypes = [c_uint32, c_uint32,\n c_uint32, POINTER(disk_info)]\n\n # Check if this library supports create API\n try:\n lib.DiskLib_SidecarCreate.argtypes = [c_uint32, c_char_p, c_uint64,\n c_int32, POINTER(c_uint32)]\n lib.DiskLib_SidecarCreate.restype = int\n use_sidecar_create = True\n except:\n logging.debug(\n \"ESX version doesn't support create API, using open instead.\")\n\n lib.DiskLib_SidecarMakeFileName.argtypes = [c_char_p, c_char_p]\n\n # Define result types for disk lib apis.\n lib.DiskLib_OpenWithInfo.restype = int\n lib.DiskLib_Close.restype = int\n lib.DiskLib_SidecarOpen.restype = int\n lib.DiskLib_SidecarClose.restype = int\n lib.DiskLib_SidecarMakeFileName.restype = c_char_p\n lib.DiskLib_DBGet.restype = c_uint32\n lib.DiskLib_DBSet.restype = c_uint32\n lib.DiskLib_GetSize.restype = c_uint32\n\n return","def main():\n setup(**setup_params)","def init(self):\n self.print_log('开始改变工作目录 %s' % self.lib_dir)\n os.chdir(self.lib_dir)\n self.print_log('开始加载libhcnetsdk.so')\n self.hk_so_lib = ctypes.cdll.LoadLibrary(\"./libhcnetsdk.so\")\n ok = self.hk_so_lib.NET_DVR_Init()\n if not ok:\n self.err_code = -1\n raise Exception(\"<<<海康sdk初始化失败\")\n self._login()\n return self","def main():\n\n util.protontricks('mf_install')","def setup(self):\r\n pass","def setup(self):\n self.build_serverkeyhash()\n self.build_agent_pubkey()\n self.load_registration_key()","def setup_machine():\n # Initial setup and package install.\n sudo(\"aptitude update\")\n sudo(\"aptitude -y install git-core python-dev python-setuptools \"\n \"postgresql-dev postgresql-client build-essential \"\n \"libpq-dev subversion mercurial apache2 \"\n \"libapache2-mod-wsgi\")","def prepare_instance():\n sudo(\"apt-get -y update\")\n sudo(\"apt-get -y upgrade\")\n sudo(\"apt-get install -y python-pip python-setuptools\")\n sudo(\"pip install BeautifulSoup\")\n sudo(\"pip install --upgrade boto\")\n sudo(\"mv /usr/lib/pymodules/python2.6/boto /tmp\")","def createFinalLibraries(INTERMEDIATELIBRARIES, DICOLIBRARIES):\n\t#### Parse all the intermediate libraries files\n\tfor file in INTERMEDIATELIBRARIES:\n\t\tfileName = os.path.basename(file).split(\".fasta\")[0]\n\t\t#### Read and store the fasta sequences of the prelibraries\n\t\tsequences=readInput.readFasta(file)\n\t\t#### Save the three finals libraries\n\t\tsave.saveLibraries(sequences, DICOLIBRARIES)","def init(cx):\n\n\n # create the folder structure\n for d in PROJECT_DIRS:\n cx.run(\"mkdir -p {}\".format(d))\n cx.run(\"touch {}/.keep\".format(d))","def _swift_generic_setup(self):\n with settings(hide('running', 'stdout', 'stderr', 'warnings')):\n self._pull_configs('generic')\n self._swift_install()\n self._set_onhold('generic')\n self._final_install_touches()"],"string":"[\n \"def setup_lib(CLIB):\\n # {{ SETUP_LIB }}\",\n \"def setup_module():\\n common_setup_module()\",\n \"def initialize_library():\\n # return the handle to the shared object\\n if os.name == \\\"nt\\\":\\n pass\\n # libc = load_windows_dll()\\n else:\\n libc = load_linux_so()\\n return libc\",\n \"def setup_environment():\\n global _ENV_SETUP_DONE\\n if _ENV_SETUP_DONE:\\n return\\n _ENV_SETUP_DONE = True\\n\\n _configure_libraries()\\n\\n custom_module_path = os.environ.get(\\\"DETECTRON2_ENV_MODULE\\\")\\n\\n if custom_module_path:\\n setup_custom_environment(custom_module_path)\\n else:\\n # The default setup is a no-op\\n pass\",\n \"def test_sharedlibs():\\n mappath = os.path.join(test_location, \\\"../test_data/test_gdb_plugin/info_sharedlibs\\\")\\n p = angr.Project(binpath, load_options={\\\"gdb_map\\\":mappath, \\\"gdb_fix\\\":True})\\n check_addrs(p)\",\n \"def set_up(self):\\n self.path.state = self.path.gen.joinpath(\\\"state\\\")\\n if self.path.state.exists():\\n self.path.state.rmtree(ignore_errors=True)\\n self.path.state.mkdir()\\n\\n for script in self.given.get(\\\"scripts\\\", []):\\n script_path = self.path.state.joinpath(script)\\n\\n if not script_path.dirname().exists():\\n script_path.dirname().makedirs()\\n\\n script_path.write_text(self.given[\\\"scripts\\\"][script])\\n script_path.chmod(\\\"u+x\\\")\\n\\n for filename, contents in self.given.get(\\\"files\\\", {}).items():\\n self.path.state.joinpath(filename).write_text(contents)\\n\\n self.python = hitchpylibrarytoolkit.project_build(\\n \\\"commandlib\\\", self.path, self.given[\\\"python version\\\"]\\n ).bin.python\\n\\n self.example_py_code = (\\n ExamplePythonCode(self.python, self.path.state)\\n .with_code(self.given.get(\\\"code\\\", \\\"\\\"))\\n .with_setup_code(self.given.get(\\\"setup\\\", \\\"\\\"))\\n )\",\n \"def setup_python(self, context: SimpleNamespace) -> None:\\n super().setup_python(context)\\n\\n if os.name == 'nt':\\n return\\n\\n # copy pypy libs\\n for libname in ('libpypy3-c.so', 'libpypy3-c.dylib'):\\n src_library = Path(context.executable).resolve().parent / libname\\n if not src_library.exists():\\n continue\\n\\n dest_library = Path(context.bin_path) / libname\\n if dest_library.exists():\\n continue\\n\\n self.symlink_or_copy(str(src_library), str(dest_library))\\n if not dest_library.is_symlink():\\n dest_library.chmod(0o755)\",\n \"def elinos_init():\\n elinos_env = get_elinos_environment()\\n\\n solib_dirs = []\\n\\n # System libraries\\n if None in (elinos_env[key] for key in (\\\"cdk\\\", \\\"target\\\")):\\n warn(\\\"ELinOS system libraries will not be loaded\\\")\\n else:\\n solib_prefix = \\\"%s/%s\\\" % (elinos_env[\\\"cdk\\\"], elinos_env[\\\"target\\\"])\\n solib_dirs += [\\\"%s/%s\\\" % (solib_prefix, \\\"lib\\\")]\\n gdb.execute(\\\"set solib-absolute-prefix %s\\\" % solib_prefix)\\n\\n # Xenomai libraries. Those are optional, so have a lighter warning\\n # if they cannot be located.\\n if elinos_env[\\\"project\\\"] is None:\\n warn(\\\"Xenomai libraries may not be loaded\\\")\\n else:\\n for dir in elinos_env['xenomai']:\\n solib_dirs += [\\\"%s/%s\\\"\\n % (dir, \\\"xenomai-build/usr/realtime/lib\\\")]\\n\\n if len(solib_dirs) != 0:\\n gdb.execute(\\\"set solib-search-path %s\\\" % \\\":\\\".join(solib_dirs))\",\n \"def init():\\n run('mkdir -p %(releases_dir)s' % env)\\n execute(cleanup)\\n execute(create_directories)\",\n \"def linking_library_dirs(self):\",\n \"def shared_temporal_libraries(self):\\n foo='shared_temporal_libraries () {\\\\n'\\n foo+='#bring or delete necessary temporary libraries\\\\n'\\n foo+=' e=1\\\\n' #initialize exit status as error\\n if self.shared:\\n cmd=sharedexe+' -a \\\"'+self.shared+'\\\" -b $$ -c $1' #$1== _PREPARE_ or _CLEANUP_\\n foo+=' if '+cmd+'; then e=0;fi\\\\n'\\n else:\\n foo+=' echo \\\"no shared temporal libraries to $1\\\" && e=0\\\\n'\\n foo+=' return $e\\\\n'\\n foo+='}'\\n return foo\",\n \"def _setup(self):\",\n \"def _setup(self):\",\n \"def setup():\\n require('hosts', provided_by=[prod])\\n require('code_root')\\n sudo('apt-get update')\\n sudo('apt-get install -y python-setuptools')\\n sudo('easy_install pip')\\n sudo('pip install virtualenv')\\n sudo('aptitude install -y apache2')\\n sudo('aptitude install -y libapache2-mod-wsgi')\\n sudo('apt-get install -y nginx')\\n update_webserver_config()\\n sudo('mkdir -p %s; cd %s; virtualenv .;' % (env.code_root, env.code_root))\\n sudo('cd %s;mkdir releases; mkdir shared; mkdir packages; mkdir shared/media; mkdir shared/media/file;' % (env.code_root))\\n deploy()\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _copy_bins():\\n # STEP 1: If we're performing a build from a copied source tree,\\n # copy the generated python files into the package\\n\\n _clean_bins()\\n\\n py_z3_build_dir = os.path.join(BUILD_DIR, 'python', 'z3')\\n root_z3_dir = os.path.join(ROOT_DIR, 'z3')\\n shutil.copy(os.path.join(py_z3_build_dir, 'z3core.py'), root_z3_dir)\\n shutil.copy(os.path.join(py_z3_build_dir, 'z3consts.py'), root_z3_dir)\\n\\n # STEP 2: Copy the shared library, the executable and the headers\\n\\n os.mkdir(LIBS_DIR)\\n os.mkdir(BINS_DIR)\\n os.mkdir(HEADERS_DIR)\\n shutil.copy(os.path.join(BUILD_DIR, LIBRARY_FILE), LIBS_DIR)\\n shutil.copy(os.path.join(BUILD_DIR, EXECUTABLE_FILE), BINS_DIR)\\n path1 = glob.glob(os.path.join(BUILD_DIR, \\\"msvcp*\\\"))\\n path2 = glob.glob(os.path.join(BUILD_DIR, \\\"vcomp*\\\"))\\n path3 = glob.glob(os.path.join(BUILD_DIR, \\\"vcrun*\\\"))\\n for filepath in path1 + path2 + path3:\\n shutil.copy(filepath, LIBS_DIR)\\n\\n for header_dir in HEADER_DIRS:\\n for fname in os.listdir(header_dir):\\n if not fname.endswith('.h'):\\n continue\\n shutil.copy(os.path.join(header_dir, fname), os.path.join(HEADERS_DIR, fname))\\n\\n # This hack lets z3 installed libs link on M1 macs; it is a hack, not a proper fix\\n # @TODO: Linked issue: https://github.com/Z3Prover/z3/issues/5926\\n major_minor = '.'.join(_z3_version().split('.')[:2])\\n link_name = None\\n if BUILD_PLATFORM in ('win32', 'cygwin', 'win'):\\n pass # TODO: When windows VMs work on M1, fill this in\\n elif BUILD_PLATFORM in ('darwin', 'osx'):\\n split = LIBRARY_FILE.split('.')\\n link_name = split[0] + '.' + major_minor + '.' + split[1]\\n else:\\n link_name = LIBRARY_FILE + '.' + major_minor\\n if link_name:\\n os.symlink(LIBRARY_FILE, os.path.join(LIBS_DIR, link_name), True)\",\n \"def setup_once():\\n # type: () -> None\\n _install_httpx_client()\\n _install_httpx_async_client()\",\n \"def _init_remote():\\r\\n require('path', provided_by = [staging])\\r\\n\\r\\n create_project_dir()\\r\\n deploy_nosyncdb()\\r\\n create_virtualenv()\\r\\n install_requirements()\\r\\n create_db()\\r\\n create_secret_settings()\\r\\n syncdb()\\r\\n createsuperuser()\\r\\n install_site()\\r\\n reload()\",\n \"def bootstrap():\\n validate_configurator_version()\\n\\n # put new mkinitcpio.conf in place\\n run(\\\"mv /etc/mkinitcpio.conf.pacnew /etc/mkinitcpio.conf\\\")\\n sed(\\\"/etc/mkinitcpio.conf\\\",\\n 'MODULES=\\\"\\\"',\\n 'MODULES=\\\"xen-blkfront xen-fbfront xen-kbdfront xen-netfront xen-pcifront xenbus_probe_frontend xenfs\\\"') # nopep8\\n sed(\\\"/etc/mkinitcpio.conf\\\",\\n 'HOOKS=\\\"base udev autodetect modconf block filesystems keyboard fsck',\\n 'HOOKS=\\\"base udev block filesystems shutdown autodetect\\\"')\\n\\n # upgrade pacakges\\n run(\\\"pacman --noconfirm -Syu\\\")\\n\\n # put new pacman.conf in place\\n run(\\\"mv /etc/pacman.conf.pacnew /etc/pacman.conf\\\")\\n\\n # install essential packages\\n run(\\\"pacman --noconfirm -S base-devel\\\")\\n run(\\\"pacman --noconfirm -S curl git rsync\\\")\\n\\n # create a user, named 'aur', to safely install AUR packages under fakeroot\\n # uid and gid values auto increment from 1000\\n # to prevent conficts set the 'aur' user's gid and uid to 902\\n run(\\\"groupadd -g 902 aur && useradd -m -u 902 -g 902 -G wheel aur\\\")\\n\\n # allow users in the wheel group to sudo without a password\\n uncomment(\\\"/etc/sudoers\\\", \\\"wheel.*NOPASSWD\\\")\\n\\n # install yaourt and upgrade non-pacman rackspace installed packages\\n sudo(\\\"rm -rf /home/aur/.builds && mkdir /home/aur/.builds/\\\", user=\\\"aur\\\")\\n with cd(\\\"/home/aur/.builds/\\\"):\\n sudo(\\\"bash <(curl aur.sh) -si --noconfirm package-query yaourt\\\", user=\\\"aur\\\")\\n sudo(\\\"yaourt --noconfirm -S xe-guest-utilities\\\", user=\\\"aur\\\")\\n\\n # allow fabric to sftp with contrib.files.put\\n # http://stackoverflow.com/questions/10221839/cant-use-fabric-put-is-there-any-server-configuration-needed # nopep8\\n # change before reboot because then the sshd config will be reloaded\\n # sed(\\\"/etc/ssh/sshd_config\\\", \\\"Subsystem sftp /usr/lib/openssh/sftp-server\\\",\\n # \\\"Subsystem sftp internal-sftp\\\")\\n\\n # systemd\\n sed(\\\"/boot/grub/menu.lst\\\",\\n \\\"kernel /boot/vmlinuz-linux root=/dev/xvda1 ro console=hvc0\\\",\\n \\\"kernel /boot/vmlinuz-linux root=/dev/xvda1 ro console=hvc0 init=/usr/lib/systemd/systemd\\\")\\n reboot()\\n if not contains(\\\"/proc/1/comm\\\", \\\"systemd\\\"):\\n abort(\\\"systemd is not installed properly\\\")\\n server = [s for s in env.bootmachine_servers if s.public_ip == env.host][0]\\n run(\\\"hostnamectl set-hostname {0}\\\".format(server.name))\\n run(\\\"mv /etc/locale.gen.pacnew /etc/locale.gen.conf\\\")\\n uncomment(\\\"/etc/locale.gen\\\", \\\"en_US.UTF-8 UTF-8\\\")\\n uncomment(\\\"/etc/locale.gen\\\", \\\"en_US ISO-8859-1\\\")\\n run(\\\"locale-gen\\\")\\n run(\\\"localectl set-locale LANG='en_US.utf8'\\\")\\n run(\\\"timedatectl set-timezone US/Central\\\")\",\n \"def setup():\\n op_dir = rootfs.get_working_dir()\\n if not os.path.isdir(op_dir):\\n os.mkdir(op_dir)\",\n \"def main ( ) :\\r\\n\\r\\n # checks the command line\\r\\n\\r\\n libraryPath = checkArguments()\\r\\n\\r\\n # checks whether the library path is defined in a file pythonLibrary.txt\\r\\n\\r\\n if libraryPath is None : libraryPath = readLink()\\r\\n\\r\\n # checks for current directory\\r\\n\\r\\n if libraryPath is None : libraryPath = findDirectory( os.getcwd() )\\r\\n\\r\\n # checks whether the current execution prefix ( the directory where we are running python ) contains libraryPython\\r\\n\\r\\n if libraryPath is None : libraryPath = findDirectory( sys.exec_prefix )\\r\\n\\r\\n # not found\\r\\n\\r\\n if libraryPath is None :\\r\\n\\r\\n raw_input( sys.argv[ 0 ] + \\\" - fatal error : library not found. Press any key\\\" )\\r\\n\\r\\n sys.exit( 1 )\\r\\n\\r\\n # adds final / if required\\r\\n\\r\\n libraryPath = libraryPath.rstrip( \\\"\\\\\\\\/\\\" ) + os.sep\\r\\n\\r\\n # writes the link file (contains library path, speeds up next execution)\\r\\n\\r\\n writeLink( libraryPath )\\r\\n\\r\\n # appends library and root to search path\\r\\n\\r\\n if not libraryPath in sys.path : sys.path = [ libraryPath ] + sys.path\\r\\n\\r\\n # appends library and the local copy of python to the system search path so that local python modules have priority\\r\\n\\r\\n if os.path.exists( libraryPath + os.sep + sys.platform ) : localPath = libraryPath + os.sep + sys.platform + os.sep\\r\\n\\r\\n elif os.path.exists( libraryPath + os.sep + \\\"python\\\" ) : localPath = libraryPath + os.sep + \\\"python\\\" + os.sep\\r\\n\\r\\n else : localPath = None\\r\\n\\r\\n if not localPath is None : localPython( localPath )\\r\\n\\r\\n # writes the python library directly in sys, for next modules\\r\\n\\r\\n sys.libraryPath = libraryPath\\r\\n\\r\\n # writes the root of python library in sys, for next modules\\r\\n\\r\\n rootPath, dummy = os.path.split( libraryPath.rstrip( \\\"\\\\\\\\/\\\" ) )\\r\\n\\r\\n rootPath = rootPath + os.sep\\r\\n\\r\\n sys.rootPath = rootPath\\r\\n\\r\\n if not rootPath in sys.path : sys.path = [ rootPath ] + sys.path\\r\\n\\r\\n # sets the environment variables (session) for GUIs\\r\\n\\r\\n if not localPath is None : setEnvironment( localPath )\",\n \"def _init_posix():\\n so_ext = [s[0] for s in imp.get_suffixes() if s[2] == imp.C_EXTENSION][0]\\n\\n g = {}\\n g['CC'] = \\\"cc -pthread\\\"\\n g['CXX'] = \\\"c++ -pthread\\\"\\n g['OPT'] = \\\"-DNDEBUG -O2\\\"\\n g['CFLAGS'] = \\\"-DNDEBUG -O2\\\"\\n g['CCSHARED'] = \\\"-fPIC\\\"\\n g['LDSHARED'] = \\\"cc -pthread -shared\\\"\\n g['EXT_SUFFIX'] = so_ext\\n g['SHLIB_SUFFIX'] = \\\".so\\\"\\n g['SO'] = so_ext # deprecated in Python 3, for backward compatibility\\n g['AR'] = \\\"ar\\\"\\n g['ARFLAGS'] = \\\"rc\\\"\\n g['EXE'] = \\\"\\\"\\n g['LIBDIR'] = os.path.join(sys.prefix, 'lib')\\n g['VERSION'] = get_python_version()\\n\\n if sys.platform[:6] == \\\"darwin\\\":\\n import platform\\n if platform.machine() == 'i386':\\n if platform.architecture()[0] == '32bit':\\n arch = 'i386'\\n else:\\n arch = 'x86_64'\\n else:\\n # just a guess\\n arch = platform.machine()\\n g['LDSHARED'] += ' -undefined dynamic_lookup'\\n g['CC'] += ' -arch %s' % (arch,)\\n\\n global _config_vars\\n _config_vars = g\",\n \"def setup():\\n global RBD_POOL, RBD_STORAGE_CLASS, RBD_SECRET, CEPHFS_OBJ, \\\\\\n CEPHFS_STORAGE_CLASS, CEPHFS_SECRET, RBD_PVC, CEPHFS_PVC\\n log.info(\\\"Creating RBD Pool\\\")\\n RBD_POOL = helpers.create_ceph_block_pool()\\n\\n log.info(\\\"Creating RBD Secret\\\")\\n RBD_SECRET = helpers.create_secret(constants.CEPHBLOCKPOOL)\\n\\n log.info(\\\"Creating RBD StorageClass\\\")\\n RBD_STORAGE_CLASS = helpers.create_storage_class(\\n constants.CEPHBLOCKPOOL, RBD_POOL.name, RBD_SECRET.name\\n )\\n\\n log.info(\\\"Creating CephFilesystem\\\")\\n CEPHFS_OBJ = helpers.create_cephfilesystem()\\n\\n log.info(\\\"Creating FS Secret\\\")\\n CEPHFS_SECRET = helpers.create_secret(constants.CEPHFILESYSTEM)\\n\\n log.info(\\\"Creating FS StorageClass\\\")\\n CEPHFS_STORAGE_CLASS = helpers.create_storage_class(\\n constants.CEPHFILESYSTEM, helpers.get_cephfs_data_pool_name(),\\n CEPHFS_SECRET.name\\n )\\n\\n log.info(\\\"Creating RBC PVC\\\")\\n RBD_PVC = helpers.create_pvc(sc_name=RBD_STORAGE_CLASS.name)\\n\\n log.info(\\\"Creating CephFs PVC\\\")\\n CEPHFS_PVC = helpers.create_pvc(sc_name=CEPHFS_STORAGE_CLASS.name)\",\n \"def _setup(self) -> None:\\n\\t\\treturn\",\n \"def setup(conf, products, build=False):\\n import distutils.sysconfig\\n paths = {\\n \\\"CPPPATH\\\": distutils.sysconfig.get_python_inc().split(),\\n \\\"LIBPATH\\\": [],\\n }\\n libs = []\\n dir = distutils.sysconfig.get_config_var(\\\"LIBPL\\\")\\n if not dir in paths[\\\"LIBPATH\\\"]:\\n paths[\\\"LIBPATH\\\"] += [dir]\\n pylibrary = distutils.sysconfig.get_config_var(\\\"LIBRARY\\\")\\n mat = re.search(\\\"(python.*)\\\\.(a|so|dylib)$\\\", pylibrary)\\n if mat:\\n libs.append(mat.group(1)) \\n for w in (\\\" \\\".join([distutils.sysconfig.get_config_var(\\\"MODLIBS\\\"),\\n distutils.sysconfig.get_config_var(\\\"SHLIBS\\\")])).split():\\n mat = re.search(r\\\"^-([Ll])(.*)\\\", w)\\n if mat:\\n lL = mat.group(1)\\n arg = mat.group(2)\\n if lL == \\\"l\\\":\\n if not arg in libs:\\n libs.append(arg)\\n else:\\n if os.path.isdir(arg) and not arg in paths[\\\"LIBPATH\\\"]:\\n paths[\\\"LIBPATH\\\"].append(arg)\\n conf.env.PrependUnique(**paths)\\n for lib in libs:\\n if lib not in conf.env.libs[\\\"python\\\"]:\\n conf.env.libs[\\\"python\\\"].append(lib)\\n return {\\\"paths\\\": paths, \\\"libs\\\": {\\\"python\\\": libs}}\",\n \"def run(self):\\n self._make_lib_file_symbolic_links()\\n self._copy_each_include_files_to_include_dir()\\n self._make_dep_lib_file_sym_links_and_copy_include_files()\\n self.setup_py.add_patchs_to_build_without_pkg_config(\\n self.rpm.lib_dir, self.rpm.include_dir\\n )\\n self.setup_py.apply_and_save()\\n self._build_and_install()\",\n \"def initLibPath():\\n libHash = {\\n 'Framework': 1,\\n 'UserControlleLib': 1,\\n 'CaseLib': 1\\n }\\n\\n binPath = os.path.split(os.path.realpath(__file__))[0]\\n\\n for key in libHash:\\n sys.path.append(os.path.join(__getLibAbsPath(binPath, libHash[key]), key))\",\n \"def setup_cross():\\n if not os.path.exists(cross_prefix):\\n docmd(\\\"mkdir %s\\\" % cross_prefix)\\n epath = os.environ[\\\"PATH\\\"]\\n set_evar(\\\"PATH\\\", \\\"%s/bin:%s\\\" % (cross_prefix, epath))\",\n \"def bootstrap():\\n\\n require('environment', provided_by=env.environments)\\n sudo('mkdir -p %(root)s' % env, user=env.deploy_user)\\n clone_repo()\\n setup_dirs()\\n link_config_files()\\n update_services()\\n create_virtualenv()\\n update_requirements()\\n create_local_settings()\",\n \"def set_up(dev=False):\\n _install_dependencies()\",\n \"def setup():\\n _confirm_branch()\\n \\n require('settings', provided_by=[production, staging])\\n require('branch', provided_by=[stable, master, branch])\\n \\n setup_directories()\\n setup_virtualenv()\\n clone_repo()\\n checkout_latest()\\n install_requirements()\\n install_apache_conf()\\n deploy_to_s3()\",\n \"def _swift_saio_setup(self):\\n self._swift_storage_setup()\\n self._swift_proxy_setup()\",\n \"def setup():\\r\\n global venvs\\r\\n\\r\\n try:\\r\\n os.mkdir(basedir)\\r\\n except OSError, e:\\r\\n if e.errno != errno.EEXIST:\\r\\n raise\\r\\n os.chdir(basedir)\\r\\n\\r\\n # Delete virtualenvs and recreate\\r\\n for venv in glob('venv-*'):\\r\\n shutil.rmtree(venv)\\r\\n for py in available_python_versions():\\r\\n check_call(['virtualenv', '-p', py,\\r\\n '--system-site-packages', 'venv-%s' % py])\\r\\n venvs.append((py, 'venv-%s' % py))\\r\\n\\r\\n # Check out and update the repository\\r\\n if not os.path.exists('Theano'):\\r\\n try:\\r\\n check_call(['git', 'clone', ipy_repository])\\r\\n except CalledProcessError:\\r\\n check_call(['git', 'clone', ipy_http_repository])\\r\\n os.chdir(repodir)\\r\\n check_call(['git', 'checkout', 'master'])\\r\\n try:\\r\\n check_call(['git', 'pull', ipy_repository, 'master'])\\r\\n except CalledProcessError:\\r\\n check_call(['git', 'pull', ipy_http_repository, 'master'])\\r\\n os.chdir(basedir)\",\n \"def initialize():\\n\\n # create plugin locations\\n for p in (cache_path, config_path, data_path):\\n p.mkdir(parents=False, exist_ok=True)\",\n \"def __setup(self):\\n\\n build_environment = []\\n\\n # The download URL has the format contains vMAJOR.MINOR in the\\n # path and the tarball contains MAJOR.MINOR.REVISION, so pull\\n # apart the full version to get the MAJOR and MINOR components.\\n match = re.match(r'(?P<major>\\\\d+)\\\\.(?P<minor>\\\\d+)', self.version)\\n major_minor = 'v{0}.{1}'.format(match.groupdict()['major'],\\n match.groupdict()['minor'])\\n tarball = 'openmpi-{}.tar.bz2'.format(self.version)\\n url = '{0}/{1}/downloads/{2}'.format(self.baseurl, major_minor,\\n tarball)\\n\\n # CUDA\\n if self.cuda:\\n if self.__toolchain.CUDA_HOME:\\n self.configure_opts.append(\\n '--with-cuda={}'.format(self.__toolchain.CUDA_HOME))\\n else:\\n self.configure_opts.append('--with-cuda')\\n else:\\n self.configure_opts.append('--without-cuda')\\n\\n # InfiniBand\\n if self.infiniband:\\n self.configure_opts.append('--with-verbs')\\n else:\\n self.configure_opts.append('--without-verbs')\\n\\n # UCX\\n if self.__ucx:\\n if isinstance(self.__ucx, string_types):\\n # Use specified path\\n self.configure_opts.append('--with-ucx={}'.format(self.__ucx))\\n else:\\n self.configure_opts.append('--with-ucx')\\n\\n # If UCX was built with CUDA support, it is linked with\\n # libcuda.so.1, which is not available during the\\n # build stage. Assume that if OpenMPI is built with\\n # CUDA support, then UCX was as well...\\n if self.cuda:\\n cuda_home = \\\"/usr/local/cuda\\\"\\n if self.__toolchain.CUDA_HOME:\\n cuda_home = self.__toolchain.CUDA_HOME\\n self.__commands.append('ln -s {0} {1}'.format(\\n os.path.join(cuda_home, 'lib64', 'stubs', 'libcuda.so'),\\n os.path.join(cuda_home, 'lib64', 'stubs', 'libcuda.so.1')))\\n if not self.__toolchain.LD_LIBRARY_PATH:\\n build_environment.append('LD_LIBRARY_PATH=\\\"{}:$LD_LIBRARY_PATH\\\"'.format(os.path.join(cuda_home, 'lib64', 'stubs')))\\n\\n if self.directory:\\n # Use source from local build context\\n self.__commands.append(self.configure_step(\\n directory=os.path.join(self.__wd, self.directory),\\n toolchain=self.__toolchain))\\n else:\\n # Download source from web\\n self.__commands.append(self.download_step(url=url,\\n directory=self.__wd))\\n self.__commands.append(self.untar_step(\\n tarball=os.path.join(self.__wd, tarball), directory=self.__wd))\\n self.__commands.append(self.configure_step(\\n directory=os.path.join(self.__wd,\\n 'openmpi-{}'.format(self.version)),\\n environment=build_environment,\\n toolchain=self.__toolchain))\\n\\n self.__commands.append(self.build_step())\\n\\n if self.__check:\\n self.__commands.append(self.check_step())\\n\\n self.__commands.append(self.install_step())\\n\\n # Set library path\\n libpath = os.path.join(self.prefix, 'lib')\\n if self.ldconfig:\\n self.__commands.append(self.ldcache_step(directory=libpath))\\n else:\\n self.__environment_variables['LD_LIBRARY_PATH'] = '{}:$LD_LIBRARY_PATH'.format(libpath)\\n\\n if self.directory:\\n # Using source from local build context, cleanup directory\\n self.__commands.append(self.cleanup_step(\\n items=[os.path.join(self.__wd, self.directory)]))\\n else:\\n # Using downloaded source, cleanup tarball and directory\\n self.__commands.append(self.cleanup_step(\\n items=[os.path.join(self.__wd, tarball),\\n os.path.join(self.__wd,\\n 'openmpi-{}'.format(self.version))]))\",\n \"def setup(self):\\n\\t\\tpass\",\n \"def setup():\\n require('hosts', 'project_path', provided_by=envs.ENVS)\\n\\n if not exists(env.project_path):\\n abort(red('Project path ({project_path}) does not exist. '\\n 'Create it on the server before continuing.'.format(**env)))\\n\\n with cd(env.project_path):\\n run('mkdir -p api renderer conf markup_renderer')\\n run('mkdir -p api/static api/uploads')\\n\\n make_release_folders('api')\\n make_release_folders('renderer')\",\n \"def bootstrap():\\n _require_environment()\\n\\n adduser()\\n install_python()\\n install_git()\\n install_apache()\\n install_mysql()\\n setup_project()\",\n \"def bootstrap():\\n sub_install_packages()\\n sub_install_virtualenv()\\n sub_create_virtualenv()\\n sub_install_python_requirements()\",\n \"def setup():\\n find_modules('alerters')\\n find_modules('watchers')\\n find_modules('auditors')\",\n \"def setup_binutils():\\n # Set up binutils\\n global binutils_subdir\\n binutils_subdir = \\\"binutils\\\"\\n if binutils_version:\\n binutils_subdir = \\\"binutils-%s\\\" % binutils_version\\n if not os.path.exists(binutils_subdir):\\n docmd(\\\"wget http://ftpmirror.gnu.org/binutils/\\\"\\n \\\"%s.tar.bz2\\\" % binutils_subdir)\\n docmd(\\\"tar jxf %s.tar.bz2\\\" % binutils_subdir)\\n else:\\n if not os.path.exists(binutils_subdir):\\n doscmd(\\\"git clone --depth 1 %s binutils\\\" % binutils_git)\\n # Configure binutils\\n if not os.path.exists(binutils_build_dir):\\n docmd(\\\"mkdir %s\\\" % binutils_build_dir)\\n dochdir(binutils_build_dir)\\n doscmd(\\\"../%s/configure --prefix=%s --target=%s \\\"\\n \\\"%s \\\" % (binutils_subdir,\\n cross_prefix,\\n flag_target_arch,\\n flag_use_multilib))\\n doscmd(\\\"make %s \\\" % flag_parfactor)\\n doscmd(\\\"make %s install\\\" % flag_parfactor)\\n dochdir(\\\"..\\\")\",\n \"def fake(ctx, clean=False):\\n work_dir = join(PROJ_ROOT, \\\"func\\\", \\\"dynlink\\\")\\n build_dir = join(PROJ_ROOT, \\\"build\\\", \\\"libfake\\\")\\n\\n clean_dir(build_dir, clean)\\n\\n build_cmd = [\\n \\\"cmake\\\",\\n \\\"-GNinja\\\",\\n \\\"-DFAASM_BUILD_SHARED=ON\\\",\\n \\\"-DFAASM_BUILD_TYPE=wasm\\\",\\n \\\"-DCMAKE_TOOLCHAIN_FILE={}\\\".format(CMAKE_TOOLCHAIN_FILE),\\n \\\"-DCMAKE_BUILD_TYPE=Release\\\",\\n \\\"-DCMAKE_INSTALL_PREFIX={}\\\".format(WASM_SYSROOT),\\n work_dir,\\n ]\\n\\n run(\\\" \\\".join(build_cmd), shell=True, cwd=build_dir, check=True)\\n run(\\\"ninja\\\", shell=True, cwd=build_dir, check=True)\\n run(\\\"ninja install\\\", shell=True, cwd=build_dir, check=True)\\n\\n # Copy shared object into place\\n sysroot_files = join(WASM_SYSROOT, \\\"lib\\\", \\\"wasm32-wasi\\\", \\\"libfake*.so\\\")\\n\\n runtime_lib_dir = join(FAASM_RUNTIME_ROOT, \\\"lib\\\")\\n if not exists(runtime_lib_dir):\\n makedirs(runtime_lib_dir)\\n\\n run(\\n \\\"cp {} {}\\\".format(sysroot_files, runtime_lib_dir),\\n shell=True,\\n check=True,\\n )\\n\\n # Update env\\n shell_env = copy(environ)\\n shell_env.update(\\n {\\n \\\"LD_LIBRARY_PATH\\\": \\\"/usr/local/lib/\\\",\\n }\\n )\\n\\n # Run codegen\\n shared_objs = [\\n join(FAASM_RUNTIME_ROOT, \\\"lib\\\", \\\"libfakeLibA.so\\\"),\\n join(FAASM_RUNTIME_ROOT, \\\"lib\\\", \\\"libfakeLibB.so\\\"),\\n ]\\n\\n binary = find_codegen_shared_lib()\\n\\n for so in shared_objs:\\n print(\\\"Running codegen for {}\\\".format(so))\\n run(\\\"{} {}\\\".format(binary, so), env=shell_env, shell=True, check=True)\",\n \"def set_shared_lib_options(self, task):\\n pass\",\n \"def install_step(self):\\n # run 'make install' in parallel since it involves more compilation\\n self.cfg.update('installopts', \\\"-j %s\\\" % self.cfg['parallel'])\\n super(EB_GROMACS, self).install_step()\\n\\n # the GROMACS libraries get installed in different locations (deeper subdirectory), depending on the platform;\\n # this is determined by the GNUInstallDirs CMake module;\\n # rather than trying to replicate the logic, we just figure out where the library was placed\\n\\n if self.toolchain.options.get('dynamic', False):\\n self.libext = get_shared_lib_ext()\\n else:\\n self.libext = 'a'\\n\\n if LooseVersion(self.version) < LooseVersion('5.0'):\\n libname = 'libgmx*.%s' % self.libext\\n else:\\n libname = 'libgromacs*.%s' % self.libext\\n\\n for libdir in ['lib', 'lib64']:\\n if os.path.exists(os.path.join(self.installdir, libdir)):\\n for subdir in [libdir, os.path.join(libdir, '*')]:\\n libpaths = glob.glob(os.path.join(self.installdir, subdir, libname))\\n if libpaths:\\n self.lib_subdir = os.path.dirname(libpaths[0])[len(self.installdir)+1:]\\n self.log.info(\\\"Found lib subdirectory that contains %s: %s\\\", libname, self.lib_subdir)\\n break\\n if not self.lib_subdir:\\n raise EasyBuildError(\\\"Failed to determine lib subdirectory in %s\\\", self.installdir)\\n\\n # Install a version with the MPI suffix\\n if self.toolchain.options.get('usempi', None):\\n if LooseVersion(self.version) < LooseVersion('4.6'):\\n\\n cmd = \\\"make distclean\\\"\\n (out, _) = run_cmd(cmd, log_all=True, simple=False)\\n\\n self.cfg.update('configopts', \\\"--enable-mpi --program-suffix={0}\\\".format(self.cfg['mpisuffix']))\\n ConfigureMake.configure_step(self)\\n\\n super(EB_GROMACS, self).build_step()\\n\\n super(EB_GROMACS, self).install_step()\\n\\n else:\\n self.cfg['configopts'] = re.sub(r'-DGMX_MPI=OFF', r'', self.cfg['configopts'])\\n\\n if self.cfg['mpi_numprocs'] == 0:\\n self.log.info(\\\"No number of test MPI tasks specified -- using default: %s\\\" % self.cfg['parallel'])\\n self.cfg['mpi_numprocs'] = self.cfg['parallel']\\n\\n elif self.cfg['mpi_numprocs'] > self.cfg['parallel']:\\n self.log.warning(\\\"Number of test MPI tasks (%s) is greater than value for 'parallel': %s\\\",\\n self.cfg['mpi_numprocs'], self.cfg['parallel'])\\n\\n self.cfg.update('configopts', \\\"-DGMX_MPI=ON -DGMX_THREAD_MPI=OFF\\\")\\n\\n mpiexec = which(self.cfg['mpiexec'])\\n if mpiexec:\\n self.cfg.update('configopts', \\\"-DMPIEXEC=%s\\\" % mpiexec)\\n self.cfg.update('configopts', \\\"-DMPIEXEC_NUMPROC_FLAG=%s\\\" % self.cfg['mpiexec_numproc_flag'])\\n self.cfg.update('configopts', \\\"-DNUMPROC=%s\\\" % self.cfg['mpi_numprocs'])\\n elif self.cfg['runtest']:\\n raise EasyBuildError(\\\"'%s' not found in $PATH\\\", self.cfg['mpiexec'])\\n\\n\\n self.log.info(\\\"Using %s as MPI executable when testing, with numprocs flag '%s' and %s tasks\\\",\\n self.cfg['mpiexec'], self.cfg['mpiexec_numproc_flag'], self.cfg['mpi_numprocs'])\\n\\n # clean up obj dir before reconfiguring\\n shutil.rmtree(os.path.join(self.builddir, 'easybuild_obj'))\\n\\n # rebuild/test/install with MPI options\\n super(EB_GROMACS, self).configure_step()\\n super(EB_GROMACS, self).build_step()\\n super(EB_GROMACS, self).test_step()\\n super(EB_GROMACS, self).install_step()\\n\\n self.log.info(\\\"A full regression test suite is available from the GROMACS web site\\\")\",\n \"def _setup(self):\\n self._raw_top_dir = os.path.join(self._snippets_dir,\\\"raw\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._raw_top_dir):\\n os.mkdir(self._raw_top_dir)\\n\\n self._trec_top_dir = os.path.join(self._snippets_dir,\\\"trec\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._trec_top_dir):\\n os.mkdir(self._trec_top_dir)\\n\\n self._temp_top_dir = os.path.join(self._snippets_dir,\\\"temp\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._temp_top_dir):\\n os.mkdir(self._temp_top_dir)\\n\\n self._snippet_result_top_dir = os.path.join(self._snippets_dir,\\\"result\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._snippet_result_top_dir):\\n os.mkdir(self._snippet_result_top_dir)\\n\\n self._snippet_index_top_dir = os.path.join(self._snippets_dir,\\\"index\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._snippet_index_top_dir):\\n os.mkdir(self._snippet_index_top_dir)\\n\\n self._para_top_dir = os.path.join(self._snippets_dir,\\\"para\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._para_top_dir):\\n os.mkdir(self._para_top_dir)\",\n \"def setup():\\n\\n debs = (\\\"python-setuptools\\\", \\\"apache2\\\", \\\"libapache2-mod-wsgi\\\")\\n\\n require(\\\"hosts\\\", provided_by=[production, staging])\\n sudo(\\\"apt-get install %s\\\" % \\\" \\\".join(debs))\\n sudo(\\\"easy_install virtualenv pip\\\")\\n sudo(\\\"mkdir -p %(path)s\\\" % env)\\n with cd(\\\"%(path)s\\\" % env):\\n sudo(\\\"mkdir -p releases; mkdir -p packages\\\")\\n sudo(\\\"virtualenv --no-site-packages .\\\")\\n sudo(\\\"mkdir -p /var/log/twit-demo; chown www-data:www-data /var/log/twit-demo\\\")\",\n \"def _setup(app_obj):\",\n \"def _setup_modules(self):\\r\\n module_registry = AppModule.module_registry()\\r\\n for bundle in topological_sort(AppModule.module_dependencies()):\\r\\n for module_label in bundle:\\r\\n assert module_label in module_registry\\r\\n module = module_registry[module_label]\\r\\n self._debug_log('Initializing: %s (%s)' % (module.label(), module.description()))\\r\\n try:\\r\\n module.setup_function()\\r\\n except AppModule.Unimplemented:\\r\\n pass\\r\\n self._init_modules.append(module.label())\",\n \"def init():\\n \\n # ensure that required libraries are loaded\\n LoadLibrary = ctypes.windll.kernel32.LoadLibraryA\\n LoadLibrary(\\\"kernel32.dll\\\")\\n\\n hooks = [ (\\\"kernel32.dll\\\", \\\"LoadLibraryA\\\", LoadLibraryA_handler),\\n (\\\"kernel32.dll\\\", \\\"GetProcAddress\\\", GetProcAddress_handler),\\n (\\\"kernel32.dll\\\", \\\"malloc\\\", malloc_handler),\\n (\\\"kernel32.dll\\\", \\\"memset\\\", memset_handler),\\n (\\\"kernel32.dll\\\", \\\"ReadProcessMemory\\\", ReadProcessMemory_handler),\\n (\\\"kernel32.dll\\\", \\\"VirtualAllocEx\\\", VirtualAllocEx_handler),\\n (\\\"kernel32.dll\\\", \\\"WriteProcessMemory\\\", \\\\\\n WriteProcessMemory_handler),\\n ]\\n\\n for (dll_name, func_name, handler) in hooks:\\n if not pybox.register_hook(dll_name,\\n func_name,\\n handler):\\n logging.error(\\\"Failed to register hook for %s\\\" % func_name)\\n \\n return\",\n \"def setup(self):\\n pass # pragma: no cover\",\n \"def _init_nt():\\n g = {}\\n g['EXE'] = \\\".exe\\\"\\n g['SO'] = \\\".pyd\\\"\\n g['SOABI'] = g['SO'].rsplit('.')[0] # xxx?\\n\\n global _config_vars\\n _config_vars = g\",\n \"def setup():\\n pass\",\n \"def __setup(self):\\n\\n if self.__tarball:\\n tarball = posixpath.basename(self.__tarball)\\n\\n # Figure out the version from the tarbal name\\n match = re.match(r'Arm-Compiler-for-HPC_(?P<year>\\\\d\\\\d)\\\\.0?(?P<month>[1-9][0-9]?)',\\n tarball)\\n if match and match.groupdict()['year'] and match.groupdict()['month']:\\n self.__version = '{0}.{1}'.format(match.groupdict()['year'],\\n match.groupdict()['month'])\\n else:\\n # The download URL has the format MAJOR-MINOR in the path\\n # and the tarball contains MAJOR.MINOR, so pull apart the\\n # full version to get the individual components.\\n match = re.match(r'(?P<major>\\\\d+)\\\\.(?P<minor>\\\\d+)', self.__version)\\n major_minor = '{0}-{1}'.format(match.groupdict()['major'],\\n match.groupdict()['minor'])\\n\\n tarball = 'Arm-Compiler-for-HPC_{0}_{1}_aarch64.tar'.format(\\n self.__version, self.__package_string)\\n url = '{0}/{1}/{2}/{3}'.format(self.__baseurl, major_minor,\\n self.__url_string, tarball)\\n\\n # Download source from web\\n self.__commands.append(self.download_step(url=url,\\n directory=self.__wd))\\n\\n # Untar package\\n self.__commands.append(self.untar_step(\\n tarball=posixpath.join(self.__wd, tarball), directory=self.__wd))\\n\\n # Install\\n install_args = ['--install-to {}'.format(self.__prefix)]\\n if self.__eula:\\n install_args.append('--accept')\\n package_directory = 'ARM-Compiler-for-HPC_{0}_AArch64_{1}_aarch64'.format(self.__version, self.__package_string)\\n self.__commands.append('cd {0} && ./{1} {2}'.format(\\n posixpath.join(self.__wd, package_directory),\\n self.__installer_template.format(self.__version),\\n ' '.join(install_args)))\\n\\n # The default install includes the Arm Performance Libraries for\\n # multiple Arm variants. The install is not configurable, and\\n # the non generic aarch64 bits are very large, so remove them.\\n if self.__armpl_generic_aarch64_only:\\n self.__commands.append(self.__generic_aarch64_only)\\n\\n # Cleanup tarball and directory\\n self.__commands.append(self.cleanup_step(\\n items=[posixpath.join(self.__wd, tarball),\\n posixpath.join(self.__wd, package_directory)]))\\n\\n # Set environment\\n gcc_path = posixpath.join(\\n self.__prefix,\\n 'gcc-{0}_Generic-AArch64_{1}_aarch64-linux'.format(\\n self.__gcc_version, self.__directory_string))\\n llvm_path = posixpath.join(\\n self.__prefix,\\n 'arm-hpc-compiler-{0}_Generic-AArch64_{1}_aarch64-linux'.format(self.__version, self.__directory_string))\\n self.environment_variables['COMPILER_PATH'] = '{}:$COMPILER_PATH'.format(gcc_path)\\n self.environment_variables['CPATH'] = '{0}:{1}:$CPATH'.format(\\n posixpath.join(gcc_path, 'include'),\\n posixpath.join(llvm_path, 'include'))\\n self.environment_variables['LD_LIBRARY_PATH'] = '{0}:{1}:{2}:$LD_LIBRARY_PATH'.format(\\n posixpath.join(gcc_path, 'lib'), posixpath.join(gcc_path, 'lib64'),\\n posixpath.join(llvm_path, 'lib'))\\n self.environment_variables['LIBRARY_PATH'] = '{0}:{1}:{2}:$LIBRARY_PATH'.format(\\n posixpath.join(gcc_path, 'lib'), posixpath.join(gcc_path, 'lib64'),\\n posixpath.join(llvm_path, 'lib'))\\n self.environment_variables['PATH'] = '{0}:{1}:$PATH'.format(\\n posixpath.join(gcc_path, 'bin'), posixpath.join(llvm_path, 'bin'))\",\n \"def test_1_make(self):\\n #We can compile all these modules together into a single shared library.\\n writer = self.writers.values()[0]\\n self.code = writer.make(remake=True, dependencies=self.dependencies)\\n self.assertEqual(self.code, 0)\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setUpModule():\\n args = [\\\"bowtie-build\\\",REF_FILES[\\\"yeast_fasta\\\"],_ebwt]\\n with open(os.devnull,\\\"a\\\") as null:\\n try:\\n subprocess.check_call(args,stdout=null,stderr=subprocess.STDOUT)\\n except CalledProcessError as e:\\n print(\\\"Could not build bowtie index for crossmap test.\\\")\\n raise e\",\n \"def setup_ctypes():\\n lib.createComplex.argtypes = [ctypes.c_double, ctypes.c_double]\\n lib.createComplex.restype = ctypes.c_void_p\\n\\n lib.deleteComplex.argypes = [ctypes.c_void_p]\\n lib.deleteComplex.restype = None\\n\\n lib.getRealPart.argypes = [ctypes.c_void_p]\\n lib.getRealPart.restype = ctypes.c_double\\n\\n lib.getImaginaryPart.argypes = [ctypes.c_void_p]\\n lib.getImaginaryPart.restype = ctypes.c_double\\n\\n lib.add.argypes = [ctypes.c_void_p, ctypes.c_void_p]\\n lib.add.restype = ctypes.c_void_p\\n\\n lib.equals.argtypes = [ctypes.c_void_p, ctypes.c_void_p]\\n lib.equals.restype = ctypes.c_bool\",\n \"async def _setup(self):\",\n \"def fixLDPath( root, ldpath, directory ):\\n\\n if os.path.exists( directory ):\\n shutil.rmtree( directory )\\n\\n start = os.getcwd()\\n os.mkdir( directory )\\n os.chdir( directory )\\n uniqueLD = uniquePath( ldpath )\\n\\n if DEBUG:\\n print 'Unique LD LIBRARY PATH is:'\\n print uniqueLD\\n sys.stdout.flush()\\n\\n ldlist = string.split( uniqueLD, ':' )\\n if DEBUG:\\n print ''\\n print 'LD List is:'\\n print ldlist\\n print ''\\n sys.stdout.flush()\\n\\n for path in ldlist:\\n if os.path.exists( path ):\\n\\n if DEBUG:\\n print 'Searching for shared libraries in:'\\n print path\\n print '-----------------------------------------------'\\n res = shellCall( 0, 'ls ' + path + '/*.so*' )\\n if res['OK']:\\n print res['Value']\\n else:\\n print res\\n print '-----------------------------------------------'\\n\\n output = shellCall( 0, 'ls ' + path + '/*.so*' )\\n #must be tidied for Windows (same below)\\n\\n if DEBUG:\\n if not output['OK']:\\n print '**************************'\\n print 'Warning, problem with ls:'\\n print output\\n print '**************************'\\n\\n if not output['Value'][0]:\\n ldlibs = output['Value'][1].split( '\\\\n' )\\n for lib in ldlibs:\\n if os.path.exists( lib ):\\n filename = os.path.basename( lib )\\n output = shellCall( 0, 'ln -s ' + str( lib ) + ' ' + str( filename ) )\\n #N.B. for Windows this should be a copy...\\n if DEBUG:\\n if not output['OK']:\\n print '********************************'\\n print 'Warning, problem creating link:'\\n print 'File: ', filename\\n print 'Path: ', lib\\n print output\\n print '********************************'\\n\\n if DEBUG:\\n print 'Searching for rootmap file in:'\\n print path\\n print '-----------------------------------------------'\\n res = shellCall( 0, 'ls ' + path + '/*rootmap*' )\\n if res['OK']:\\n print res['Value']\\n else:\\n print res\\n print '-----------------------------------------------'\\n\\n output = shellCall( 0, 'ls ' + path + '/*rootmap*' )\\n\\n if DEBUG:\\n if not output['OK']:\\n print '**************************'\\n print 'Warning, problem with rootmap:'\\n print output\\n print '**************************'\\n\\n if not output['Value'][0]:\\n ldlibs = output['Value'][1].split( '\\\\n' )\\n for lib in ldlibs:\\n if os.path.exists( lib ):\\n if re.search( 'RELAX', lib ) is not None:\\n filename = os.path.basename( lib )\\n output = shellCall( 0, 'ln -s ' + str( lib ) + ' ' + str( filename ) )\\n if DEBUG:\\n if not output['OK']:\\n print '********************************'\\n print 'Warning, problem creating link:'\\n print 'File: ', filename\\n print 'Path: ', lib\\n print output\\n print '********************************'\\n\\n os.chdir( start )\\n sys.stdout.flush()\",\n \"def setup(self):\\n pass\",\n \"def bootstrap_aws():\\n sub_install_packages()\\n sub_install_virtualenv()\\n sub_create_virtualenv()\\n sub_install_python_requirements_aws()\",\n \"def setup():\\n\\tglobal config_parser, config_file\\n\\tglobal prefix\\n\\n\\tif os.path.islink(sys.argv[0]):\\n\\t\\tlink = os.readlink(sys.argv[0])\\n\\n\\t\\tif not os.path.isabs(link):\\n\\t\\t\\tlink = os.path.join(os.path.dirname(sys.argv[0]), link)\\n\\n\\t\\tprefix = os.path.dirname(os.path.abspath(link))\\n\\telse:\\n\\t\\tprefix = os.path.dirname(os.path.abspath(sys.argv[0]))\\n\\n\\tconfig_parser = ConfigParser.ConfigParser()\\n\\tset_defaults()\\n\\n\\tconfig_file = os.path.join (xdg_config_home, \\\"sushi\\\", \\\"nigiri\\\")\\n\\n\\tif not check_config_file(config_file):\\n\\t\\tprint \\\"Config file creation failed. Aborting.\\\"\\n\\t\\treturn\\n\\n\\tread_config_file()\",\n \"def set_up_workspace():\\n # Avoid Error #15: Initializing libiomp5.dylib, but found libiomp5.dylib already initialized.\\n # https://stackoverflow.com/questions/53014306/error-15-initializing-libiomp5-dylib-but-found-libiomp5-dylib-already-initial\\n os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'\\n\\n # Magic command for inline plotting\\n # %matplotlib inline\\n # %config InlineBackend.figure_format = 'retina'\",\n \"def init ():\\n freeze_support () # for specific uses of the program on Windows\",\n \"def setup():\\n\\n with cd(env.homedir):\\n\\n # clone repository from github\\n sudo('git clone https://github.com/starzel/demo.starzel.de.git', user=env.deploy_user) # noqa: E501\\n\\n with cd(env.directory):\\n\\n # requirements\\n # sudo('python python-dev build-essential zlib1g-dev libssl-dev libxml2-dev libxslt1-dev wv poppler-utils libtiff5-dev libjpeg62-dev zlib1g-dev libfreetype6-dev liblcms1-dev libwebp-dev') # noqa: E501\\n\\n # prepare buildout\\n sudo('ln -s local_production.cfg local.cfg', user=env.deploy_user)\\n sudo('echo -e \\\"[buildout]\\\\nlogin = admin\\\\npassword = admin\\\" > secret.cfg', user=env.deploy_user) # noqa: E501\\n\\n # bootstrap and run bildout once\\n sudo('./bin/pip install -r requirements.txt', user=env.deploy_user)\\n sudo('./bin/buildout', user=env.deploy_user)\\n\\n # start supervisor which starts plone instance also\\n sudo('./bin/supervisord', user=env.deploy_user)\",\n \"def setup(self):\\n ...\",\n \"def setup_prod():\\n setup_general()\",\n \"def _setup(self):\\n mkdir_p(self.output_folder)\\n if self.symlink_dir:\\n mkdir_p(self.symlink_dir)\\n try:\\n selected_versions = self._resolve_dependencies()\\n if selected_versions:\\n self._write_lock(selected_versions)\\n print('\\\\n\\\\nVersions Selected for downloading:\\\\n')\\n print('\\\\t' + '\\\\n\\\\t'.join(['{}: {}'.format(req, ver) for req, ver in selected_versions.items()]) + '\\\\n')\\n for pkg_name, version in selected_versions.items():\\n pkg_metadata = self._get_metadata(pkg_name)\\n version_metadata = pkg_metadata.get('versions', dict()).get(str(version), dict())\\n self._download_package(version_metadata)\\n except (RequirementMatchError, DependencyError) as e:\\n print(e.message)\\n return self.created()\",\n \"def setup_dirs():\\n\\n require('environment', provided_by=env.environments)\\n sudo('mkdir -p %(log_dir)s' % env, user=env.deploy_user)\\n sudo('chmod a+w %(log_dir)s' % env )\\n sudo('mkdir -p %(services)s/nginx' % env, user=env.deploy_user)\\n sudo('mkdir -p %(services)s/supervisor' % env, user=env.deploy_user)\\n sudo('mkdir -p %(services)s/gunicorn' % env, user=env.deploy_user)\\n sudo('mkdir -p %(media_root)s' % env)\\n sudo('chown %(webserver_user)s %(media_root)s' % env)\\n sudo('mkdir -p %(static_root)s' % env)\\n sudo('chown %(webserver_user)s %(static_root)s' % env)\",\n \"def library_dirs(self):\",\n \"def setup(self):\\n self.cwd = os.getcwd()\\n self.t = tempfile.mkdtemp()\\n dir_path = Path(\\\"packages\\\")\\n tmp_dir = self.t / dir_path\\n src_dir = self.cwd / Path(ROOT_DIR, dir_path)\\n shutil.copytree(str(src_dir), str(tmp_dir))\\n shutil.copytree(Path(CUR_PATH, \\\"data\\\", \\\"dummy_aea\\\"), Path(self.t, \\\"dummy_aea\\\"))\\n os.chdir(Path(self.t, \\\"dummy_aea\\\"))\\n self.runner = CliRunner()\",\n \"def perform():\\n others = not flag_do_only_gcc_build\\n locate_gcc_subdir()\\n setup_cross()\\n if others:\\n setup_kernel_headers()\\n setup_binutils()\\n setup_prereqs()\\n setup_sysroot()\\n setup_gcc()\\n if others:\\n setup_kernel_headers()\\n setup_glibc()\",\n \"def _server_env(load_library, work_path=None):\\n if work_path:\\n temp = work_path\\n else:\\n temp = utils.tempdir()\\n\\n # pylint: disable=unused-variable\\n @tvm._ffi.register_func(\\\"tvm.rpc.server.workpath\\\", override=True)\\n def get_workpath(path):\\n return temp.relpath(path)\\n\\n @tvm._ffi.register_func(\\\"tvm.rpc.server.load_module\\\", override=True)\\n def load_module(file_name):\\n \\\"\\\"\\\"Load module from remote side.\\\"\\\"\\\"\\n path = temp.relpath(file_name)\\n m = _load_module(path)\\n logger.info(\\\"load_module %s\\\", path)\\n return m\\n\\n @tvm._ffi.register_func(\\\"tvm.rpc.server.download_linked_module\\\", override=True)\\n def download_linked_module(file_name):\\n \\\"\\\"\\\"Load module from remote side.\\\"\\\"\\\"\\n # pylint: disable=import-outside-toplevel\\n path = temp.relpath(file_name)\\n\\n if path.endswith(\\\".o\\\"):\\n # Extra dependencies during runtime.\\n from tvm.contrib import cc as _cc\\n\\n _cc.create_shared(path + \\\".so\\\", path)\\n path += \\\".so\\\"\\n elif path.endswith(\\\".tar\\\"):\\n # Extra dependencies during runtime.\\n from tvm.contrib import cc as _cc, tar as _tar\\n\\n tar_temp = utils.tempdir(custom_path=path.replace(\\\".tar\\\", \\\"\\\"))\\n _tar.untar(path, tar_temp.temp_dir)\\n files = [tar_temp.relpath(x) for x in tar_temp.listdir()]\\n _cc.create_shared(path + \\\".so\\\", files)\\n path += \\\".so\\\"\\n elif path.endswith(\\\".dylib\\\") or path.endswith(\\\".so\\\"):\\n pass\\n else:\\n raise RuntimeError(f\\\"Do not know how to link {file_name}\\\")\\n logger.info(\\\"Send linked module %s to client\\\", path)\\n return bytearray(open(path, \\\"rb\\\").read())\\n\\n libs = []\\n load_library = load_library.split(\\\":\\\") if load_library else []\\n for file_name in load_library:\\n file_name = find_lib_path(file_name)[0]\\n libs.append(ctypes.CDLL(file_name, ctypes.RTLD_GLOBAL))\\n logger.info(\\\"Load additional library %s\\\", file_name)\\n temp.libs = libs\\n return temp\",\n \"def setup(verbose=True):\\n global _SETUP_DONE\\n if _SETUP_DONE:\\n return\\n _ensure_base_dirs(verbose=False)\\n _setup_logging()\\n _SETUP_DONE = True\",\n \"def disk_lib_init():\\n global is_64bits\\n global use_sidecar_create\\n\\n # Define arg types for disk lib apis.\\n if sys.hexversion >= PYTHON64_VERSION:\\n is_64bits = True\\n load_disk_lib(DISK_LIB64)\\n lib.DiskLib_OpenWithInfo.argtypes = [c_char_p, c_int32,\\n POINTER(c_uint32),\\n POINTER(c_uint64),\\n POINTER(c_uint64)]\\n lib.DiskLib_Close.argtypes = [c_uint64]\\n\\n lib.DiskLib_SidecarOpen.argtypes = [c_uint64, c_char_p, c_int32,\\n POINTER(c_uint64)]\\n lib.DiskLib_SidecarClose.argtypes = [c_uint64, c_char_p,\\n POINTER(c_uint64)]\\n lib.DiskLib_DBGet.argtypes = [c_uint64, c_char_p, POINTER(c_char_p)]\\n lib.DiskLib_DBSet.argtypes = [c_uint64, c_char_p, c_char_p]\\n lib.DiskLib_GetSize.argtypes = [c_uint64, c_uint32,\\n c_uint32, POINTER(disk_info)]\\n # Check if this library supports create API\\n try:\\n lib.DiskLib_SidecarCreate.argtypes = [c_uint64, c_char_p, c_uint64,\\n c_int32, POINTER(c_uint64)]\\n lib.DiskLib_SidecarCreate.restype = int\\n use_sidecar_create = True\\n except:\\n logging.debug(\\n \\\"ESX version doesn't support create API, using open instead.\\\")\\n pass\\n else:\\n load_disk_lib(DISK_LIB)\\n lib.DiskLib_OpenWithInfo.argtypes = [c_char_p, c_int32,\\n POINTER(c_uint32),\\n POINTER(c_uint32),\\n POINTER(c_uint32)]\\n lib.DiskLib_Close.argtypes = [c_uint32]\\n lib.DiskLib_SidecarOpen.argtypes = [c_uint32, c_char_p, c_int32,\\n POINTER(c_uint32)]\\n lib.DiskLib_SidecarClose.argtypes = [c_uint32, c_char_p,\\n POINTER(c_uint32)]\\n lib.DiskLib_DBGet.argtypes = [c_uint32, c_char_p, POINTER(c_char_p)]\\n lib.DiskLib_DBSet.argtypes = [c_uint32, c_char_p, c_char_p]\\n lib.DiskLib_GetSize.argtypes = [c_uint32, c_uint32,\\n c_uint32, POINTER(disk_info)]\\n\\n # Check if this library supports create API\\n try:\\n lib.DiskLib_SidecarCreate.argtypes = [c_uint32, c_char_p, c_uint64,\\n c_int32, POINTER(c_uint32)]\\n lib.DiskLib_SidecarCreate.restype = int\\n use_sidecar_create = True\\n except:\\n logging.debug(\\n \\\"ESX version doesn't support create API, using open instead.\\\")\\n\\n lib.DiskLib_SidecarMakeFileName.argtypes = [c_char_p, c_char_p]\\n\\n # Define result types for disk lib apis.\\n lib.DiskLib_OpenWithInfo.restype = int\\n lib.DiskLib_Close.restype = int\\n lib.DiskLib_SidecarOpen.restype = int\\n lib.DiskLib_SidecarClose.restype = int\\n lib.DiskLib_SidecarMakeFileName.restype = c_char_p\\n lib.DiskLib_DBGet.restype = c_uint32\\n lib.DiskLib_DBSet.restype = c_uint32\\n lib.DiskLib_GetSize.restype = c_uint32\\n\\n return\",\n \"def main():\\n setup(**setup_params)\",\n \"def init(self):\\n self.print_log('开始改变工作目录 %s' % self.lib_dir)\\n os.chdir(self.lib_dir)\\n self.print_log('开始加载libhcnetsdk.so')\\n self.hk_so_lib = ctypes.cdll.LoadLibrary(\\\"./libhcnetsdk.so\\\")\\n ok = self.hk_so_lib.NET_DVR_Init()\\n if not ok:\\n self.err_code = -1\\n raise Exception(\\\"<<<海康sdk初始化失败\\\")\\n self._login()\\n return self\",\n \"def main():\\n\\n util.protontricks('mf_install')\",\n \"def setup(self):\\r\\n pass\",\n \"def setup(self):\\n self.build_serverkeyhash()\\n self.build_agent_pubkey()\\n self.load_registration_key()\",\n \"def setup_machine():\\n # Initial setup and package install.\\n sudo(\\\"aptitude update\\\")\\n sudo(\\\"aptitude -y install git-core python-dev python-setuptools \\\"\\n \\\"postgresql-dev postgresql-client build-essential \\\"\\n \\\"libpq-dev subversion mercurial apache2 \\\"\\n \\\"libapache2-mod-wsgi\\\")\",\n \"def prepare_instance():\\n sudo(\\\"apt-get -y update\\\")\\n sudo(\\\"apt-get -y upgrade\\\")\\n sudo(\\\"apt-get install -y python-pip python-setuptools\\\")\\n sudo(\\\"pip install BeautifulSoup\\\")\\n sudo(\\\"pip install --upgrade boto\\\")\\n sudo(\\\"mv /usr/lib/pymodules/python2.6/boto /tmp\\\")\",\n \"def createFinalLibraries(INTERMEDIATELIBRARIES, DICOLIBRARIES):\\n\\t#### Parse all the intermediate libraries files\\n\\tfor file in INTERMEDIATELIBRARIES:\\n\\t\\tfileName = os.path.basename(file).split(\\\".fasta\\\")[0]\\n\\t\\t#### Read and store the fasta sequences of the prelibraries\\n\\t\\tsequences=readInput.readFasta(file)\\n\\t\\t#### Save the three finals libraries\\n\\t\\tsave.saveLibraries(sequences, DICOLIBRARIES)\",\n \"def init(cx):\\n\\n\\n # create the folder structure\\n for d in PROJECT_DIRS:\\n cx.run(\\\"mkdir -p {}\\\".format(d))\\n cx.run(\\\"touch {}/.keep\\\".format(d))\",\n \"def _swift_generic_setup(self):\\n with settings(hide('running', 'stdout', 'stderr', 'warnings')):\\n self._pull_configs('generic')\\n self._swift_install()\\n self._set_onhold('generic')\\n self._final_install_touches()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69693637","0.6318507","0.62593526","0.61885273","0.6175638","0.61054045","0.6081299","0.60247236","0.6005774","0.59742194","0.59631056","0.59508246","0.59508246","0.59334606","0.5921951","0.5921951","0.5921951","0.5921951","0.5921951","0.5915148","0.59063196","0.58937216","0.58779556","0.58715284","0.5849659","0.58495253","0.58478016","0.5839096","0.58301955","0.58272445","0.57932454","0.57706714","0.57523674","0.5749057","0.5746117","0.5733115","0.57320046","0.57283044","0.5728171","0.57281685","0.57249177","0.57182825","0.57156515","0.5709785","0.57031864","0.5701705","0.56851","0.566401","0.5655637","0.56444544","0.5624802","0.56175905","0.56108975","0.5604346","0.5600178","0.5559658","0.5558398","0.5536909","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55340666","0.55314815","0.55303264","0.5529866","0.55286694","0.5528467","0.5525136","0.5515989","0.55124724","0.5511455","0.5505968","0.5504291","0.5501021","0.54956394","0.54912555","0.54878813","0.5485523","0.5485293","0.5484676","0.54760987","0.5472818","0.5470047","0.5467595","0.5465879","0.54644436","0.546143","0.5457741","0.54574156","0.54569566","0.5441266","0.5440156"],"string":"[\n \"0.69693637\",\n \"0.6318507\",\n \"0.62593526\",\n \"0.61885273\",\n \"0.6175638\",\n \"0.61054045\",\n \"0.6081299\",\n \"0.60247236\",\n \"0.6005774\",\n \"0.59742194\",\n \"0.59631056\",\n \"0.59508246\",\n \"0.59508246\",\n \"0.59334606\",\n \"0.5921951\",\n \"0.5921951\",\n \"0.5921951\",\n \"0.5921951\",\n \"0.5921951\",\n \"0.5915148\",\n \"0.59063196\",\n \"0.58937216\",\n \"0.58779556\",\n \"0.58715284\",\n \"0.5849659\",\n \"0.58495253\",\n \"0.58478016\",\n \"0.5839096\",\n \"0.58301955\",\n \"0.58272445\",\n \"0.57932454\",\n \"0.57706714\",\n \"0.57523674\",\n \"0.5749057\",\n \"0.5746117\",\n \"0.5733115\",\n \"0.57320046\",\n \"0.57283044\",\n \"0.5728171\",\n \"0.57281685\",\n \"0.57249177\",\n \"0.57182825\",\n \"0.57156515\",\n \"0.5709785\",\n \"0.57031864\",\n \"0.5701705\",\n \"0.56851\",\n \"0.566401\",\n \"0.5655637\",\n \"0.56444544\",\n \"0.5624802\",\n \"0.56175905\",\n \"0.56108975\",\n \"0.5604346\",\n \"0.5600178\",\n \"0.5559658\",\n \"0.5558398\",\n \"0.5536909\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55340666\",\n \"0.55314815\",\n \"0.55303264\",\n \"0.5529866\",\n \"0.55286694\",\n \"0.5528467\",\n \"0.5525136\",\n \"0.5515989\",\n \"0.55124724\",\n \"0.5511455\",\n \"0.5505968\",\n \"0.5504291\",\n \"0.5501021\",\n \"0.54956394\",\n \"0.54912555\",\n \"0.54878813\",\n \"0.5485523\",\n \"0.5485293\",\n \"0.5484676\",\n \"0.54760987\",\n \"0.5472818\",\n \"0.5470047\",\n \"0.5467595\",\n \"0.5465879\",\n \"0.54644436\",\n \"0.546143\",\n \"0.5457741\",\n \"0.54574156\",\n \"0.54569566\",\n \"0.5441266\",\n \"0.5440156\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.761938"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93499,"cells":{"query":{"kind":"string","value":"Convert `url` into a hashed filename in a repeatable way. If `etag` is specified, append its hash to the url's, delimited by a period."},"document":{"kind":"string","value":"def url_to_filename(url, etag=None):\n url_bytes = url.encode(\"utf-8\")\n url_hash = sha256(url_bytes)\n filename = url_hash.hexdigest()\n\n if etag:\n etag_bytes = etag.encode(\"utf-8\")\n etag_hash = sha256(etag_bytes)\n filename += \".\" + etag_hash.hexdigest()\n\n return filename"},"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 url_to_filename(url, etag=None):\n\turl_bytes = url.encode ('utf-8')\n\turl_hash = sha256 (url_bytes)\n\tfilename = url_hash.hexdigest ()\n\n\tif etag:\n\t\tetag_bytes = etag.encode ('utf-8')\n\t\tetag_hash = sha256 (etag_bytes)\n\t\tfilename += '.' + etag_hash.hexdigest ()\n\n\treturn filename","def url_to_filename(url, etag=None):\n url_bytes = url.encode('utf-8')\n url_hash = sha256(url_bytes)\n filename = url_hash.hexdigest()\n\n if etag:\n etag_bytes = etag.encode('utf-8')\n etag_hash = sha256(etag_bytes)\n filename += '.' + etag_hash.hexdigest()\n\n return filename","def endpoint_to_filename(endpoint):\n filename = _md5sum(endpoint)\n return filename","def url_to_file_guid(url_id):\r\n\r\n return \"{}-{}-{}-{}-{}\".format(url_id[0:8], url_id[8:12], url_id[12:16], url_id[16:20], url_id[20:])","def get_hash(file_url):\n file_extension = os.path.splitext(file_url)[1]\n return str(HASHES.get(file_extension))","def uri_to_file(uri):\n if not uri:\n return\n\n header, data = uri.split(',')\n md5_hash = hashlib.md5(data).hexdigest()\n with open(\"static/images/%s.jpg\" % md5_hash, 'wb') as f:\n f.write(data.decode('base64'))\n return md5_hash","def compute_etag(filename: str, chunksize: int) -> str:\n with open(filename, \"rb\") as fh:\n buf = fh.read(chunksize)\n dgst_part = hashlib.md5(buf)\n buf = fh.read(chunksize)\n if len(buf) < 1:\n return dgst_part.hexdigest()\n\n count = 1\n dgst_whole = hashlib.md5(dgst_part.digest())\n while len(buf) > 0:\n count += 1\n dgst_part = hashlib.md5(buf)\n dgst_whole.update(dgst_part.digest())\n buf = fh.read(chunksize)\n return \"{}-{}\".format(dgst_whole.hexdigest(), count)","def url_file_name(url):\r\n return url[url.rfind('/') + 1:]","def _HashFilename(filename):\n if isinstance(filename, unicode):\n filename = filename.encode(UTF8)\n else:\n filename = unicode(filename, UTF8).encode(UTF8)\n m = hashlib.sha1(filename)\n return 'TRACKER_' + m.hexdigest() + '.' + filename[-16:]","def url_filename(url):\n return os.path.basename(urlparse.urlparse(url).path)","def get_url_filename(url, headers=None, strip=[]):\n filename = get_url_disposition_filename(url, headers)\n if filename:\n return filename\n return get_url_straight_filename(url, strip=[])","def webfilename(url):\n headers = _get_headers_from_url(url)\n\n if _content_disposition(headers):\n result = filename_from_content_disposition(_content_disposition(headers))\n else:\n result = url.split(\"/\")[-1]\n\n return result.translate(REMOVE_PUNCTUATION)","def get_url_data(url):\n\n # Return data while saving the data in a file \n # which is a hash of the URL\n data = requests.get(url).content\n # Save it in a filename\n filename = hashlib.md5(url.encode(\"utf8\")).hexdigest()\n# open(filename, 'w').write(data)\n with open(filename, \"w\") as fileObj:\n fileObj.write(data.decode(\"utf8\"))\n return data","def save_image(url):\n ext = url.split('.')[-1]\n filename = IMAGEDIR+os.sep+hashlib.md5(url.encode('utf-8')).hexdigest()+'.'+ext\n if os.path.exists(filename):\n return filename\n try:\n content = urlopen(url).read()\n f = open(filename,'wb') \n f.write(content)\n f.close()\n except:\n return None\n return filename","def clean_filename(url):\n valid_chars = \"-_() %s%s\" % (string.ascii_letters, string.digits)\n nodot = url.replace('.','_').replace(':','_')\n filename = ''.join([c for c in nodot if c in valid_chars])\n return filename","def give_filename( url_rel ):\n filename = basename( url_rel )\n\t# Add time information\n now_datetime = datetime.datetime.now( )\n now_string = now_datetime.strftime( \"%Y-%m-%d-%H-%M-%S\" )\n if filename.endswith( '.pdf' ):\n\t\tfileno, ext_pdf = splitext( filename )\n\t\tpdf_filename = fileno + '-' + now_string + ext_pdf\n\t\treturn pdf_filename","def filename_to_url(filename, cache_dir=None):\n if cache_dir is None:\n cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE\n if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n cache_dir = str(cache_dir)\n\n cache_path = os.path.join(cache_dir, filename)\n if not os.path.exists(cache_path):\n raise EnvironmentError(\"file {} not found\".format(cache_path))\n\n meta_path = cache_path + '.json'\n if not os.path.exists(meta_path):\n raise EnvironmentError(\"file {} not found\".format(meta_path))\n\n with open(meta_path, encoding=\"utf-8\") as meta_file:\n metadata = json.load(meta_file)\n url = metadata['url']\n etag = metadata['etag']\n\n return url, etag","def fileId_from_url(url):\r\n raw_fileId = re.findall(\"~[0-z.]+/[0-9]+\", url)[0][1: ]\r\n return raw_fileId.replace('/', ':')","def fileId_from_url(url):\r\n raw_fileId = re.findall(\"~[A-z.]+/[0-9]+\", url)[0][1:]\r\n return raw_fileId.replace('/', ':')","def filename_from(url):\n filename = url.split('/')[-1]\n return filename","def get_filename_from_url(url: str) -> str:\n return os.path.basename(urllib.parse.urlparse(urllib.parse.unquote_plus(url)).path)","def standardized_filename(self, url, fname):\n #TODO:apply filename standardization logic\n # non-result pages/files use default urllib name conventions\n # result files need standardization logic (TBD)\n if fname:\n filename = join(self.cache_dir, fname)\n else:\n filename = self.filename_from_url(url)\n return filename","def cached_file_name(self,\n keyword,\n search_engine,\n scrape_mode,\n page_number):\n unique = [keyword, search_engine, scrape_mode, page_number]\n sha = hashlib.sha256()\n sha.update(b''.join(str(s).encode() for s in unique))\n\n return '{file_name}.{extension}'.format(\n file_name=sha.hexdigest(),\n extension='cache'\n )","def filename_to_url(filename, cache_dir=None):\n\tif cache_dir is None:\n\t\tcache_dir = PYTORCH_TRANSFORMERS_CACHE\n\tif sys.version_info[0] == 3 and isinstance (cache_dir, Path):\n\t\tcache_dir = str (cache_dir)\n\n\tcache_path = os.path.join (cache_dir, filename)\n\tif not os.path.exists (cache_path):\n\t\traise EnvironmentError (\"file {} not found\".format (cache_path))\n\n\tmeta_path = cache_path + '.json'\n\tif not os.path.exists (meta_path):\n\t\traise EnvironmentError (\"file {} not found\".format (meta_path))\n\n\twith open (meta_path, encoding=\"utf-8\") as meta_file:\n\t\tmetadata = json.load (meta_file)\n\turl = metadata['url']\n\tetag = metadata['etag']\n\n\treturn url, etag","def _filename_from_url(url):\n file_name = url.split(\"/\")[-1]\n return file_name","def filename_to_url(filename, cache_dir=None):\n if cache_dir is None:\n cache_dir = PYTORCH_PRETRAINED_BERT_CACHE\n if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n cache_dir = str(cache_dir)\n\n cache_path = os.path.join(cache_dir, filename)\n if not os.path.exists(cache_path):\n raise EnvironmentError(\"file {} not found\".format(cache_path))\n\n meta_path = cache_path + \".json\"\n if not os.path.exists(meta_path):\n raise EnvironmentError(\"file {} not found\".format(meta_path))\n\n with open(meta_path, encoding=\"utf-8\") as meta_file:\n metadata = json.load(meta_file)\n url = metadata[\"url\"]\n etag = metadata[\"etag\"]\n\n return url, etag","def _get_file_url (url, path) :\n path = path + \"/\" + url.replace (\"/\", \"!\").replace (\":\",\"\").replace (\".\",\"-\")\n spl = path.split (\"-\")\n if len (spl) >= 2 :\n ext = spl [len (spl)-1].lower ()\n if 2 <= len (ext) <= 3 and ext in [\"png\", \"jpg\", \"zip\", \"txt\", \"gif\", \"py\", \"cpp\", \"gz\", \"pdf\", \"tif\", \"py\", \"html\", \"h\"] :\n spl = path.split (\"-\")\n spl = spl [:len(spl)-1]\n path = \"-\".join (spl) + \".\" + ext\n return path","def concat_url(endpoint, url):\n u = \"%s/%s\" % (endpoint.rstrip(\"/\"), url.strip(\"/\"))\n return u.rstrip('/')","def shorten_duplicate_content_url(url):\n if '#' in url:\n url = url.split('#', 1)[0]\n if url.endswith('index.html'):\n return url[:-10]\n if url.endswith('index.htm'):\n return url[:-9]\n return url","def add_string_to_image_url(url, addition):\n filename, ext = splitext(url)\n return ''.join([filename, '-', addition, ext])","def _generate_filename(instance, filename, prefix):\n md5 = hashlib.md5()\n md5.update(struct.pack('f', time.time()))\n for chunk in instance.file.chunks():\n md5.update(chunk)\n extension = os.path.splitext(filename)[1]\n return os.path.join(prefix, md5.hexdigest() + extension)","def get_file_name(url: str):\n filename = os.path.basename(url)\n fname, extension = os.path.splitext(filename)\n if extension:\n if \"=\" in filename:\n return filename.split(\"=\")[-1]\n return filename\n header = requests.head(url).headers\n if \"Location\" in header:\n return os.path.basename(header[\"Location\"])\n return filename","def unique_filename(data):\n file = data\n get_ext = file.filename.split(\".\")[-1]\n new_name = \"%s.%s\" % (uuid.uuid4().hex, get_ext)\n return new_name","def urlgrab(self, url, filename=None, **kwargs):\n blob_location = \"%s/%s\" % (self.base_path, url)\n self.verbose_logger.info(\"downloading gs://%s/%s to %s\" % (self.bucket.name, blob_location, filename))\n url = url.lstrip('/')\n if not filename:\n filename = url\n\n blob = storage.blob.Blob(name=blob_location,bucket = self.bucket)\n blob.download_to_filename(filename)\n return filename","def url_to_filename(base_url: str):\n\n # Cuts fluff like 'http://' ~and 'www'~\n base_url = prune_url(base_url, cut_chars=[\"https://\", \"http://\", \"www.\"])\n\n # Covers both Windows and Unix\n forbidden_ascii = [\"/\", \"\\\\\", \"\\|\", \":\", \"?\", \"'\", '\"', \"?\", \"*\", \">\", \"<\"]\n\n for ascii_char in forbidden_ascii:\n base_url = base_url.replace(ascii_char, \"-\")\n\n # Replaces '.' with '_' just in case there are file extension issues\n filename_url = base_url.replace(\".\", \"_\")\n\n return filename_url","def hashLink(link):\n\n return str(md5.new(link).hexdigest())[:5]","def _anonymize_url(url: str, ip_dict: Dict[str, int]) -> str:\n regex_match = re.match(r\"(?i)(^https?://)(.*?)([/:].*$)\", url)\n ip = regex_match.group(2)\n\n try:\n num = ip_dict[ip]\n except KeyError:\n ip_dict[ip] = len(ip_dict.values()) + 1\n num = ip_dict[ip]\n\n return f\"{regex_match.group(1)}ip-{num:05d}{regex_match.group(3)}\"","def get_filename(url: str) ->str:\n if 'drive.google.com' in url:\n return _extract_google_drive_file_id(url)\n url, filename = os.path.split(url)\n return filename or os.path.basename(url)","def _encode(self, url):\n\n\t\ttiny_url = ''\n\n\t\tstring_id = self.get_string_id(url)\n\n\t\twhile string_id > 0:\n\t\t\tstring_id, mod = divmod(string_id, len(ALPHABET))\n\t\t\ttiny_url = tiny_url + ALPHABET[mod]\n\n\t\treturn tiny_url","def create_key_from_url(raw_url):\n org_url = urllib2.urlparse.urlparse(raw_url)\n new_key = ''\n net_location = org_url.netloc\n netloc_list = net_location.split(\".\")\n netloc_list.reverse()\n for part in netloc_list:\n new_key += '%s.' % part\n new_key = new_key[:-1] # Removes trailing period\n new_key = new_key + org_url.path \n return new_key","def s3_etag(url):\n s3_resource = boto3.resource(\"s3\")\n bucket_name, s3_path = split_s3_path(url)\n s3_object = s3_resource.Object(bucket_name, s3_path)\n return s3_object.e_tag","def s3_etag(url):\n s3_resource = boto3.resource(\"s3\")\n bucket_name, s3_path = split_s3_path(url)\n s3_object = s3_resource.Object(bucket_name, s3_path)\n return s3_object.e_tag","def _local_path_from_url(url):\n filename = '{}.epub'.format(hashlib.sha224(url).hexdigest())\n return os.path.join(books_settings.LOCAL_BOOKS_PATH, filename)","def get_urifilename(uri):\n up=urlparse.urlparse(uri)\n return split(up[2],\"/\")[-1]","def url_for(**options):\n\n url_parts = get_url_parts(**options)\n image_hash = hashlib.md5(b(options[\"image_url\"])).hexdigest()\n url_parts.append(image_hash)\n\n return \"/\".join(url_parts)","def test_hash_url(self):\r\n url = u'http://google.com'\r\n hashed = generate_hash(url)\r\n self.assertEqual('aa2239c17609b2', hashed)","def normalize_filename(url):\n fname = url.replace('file://', '')\n if os.sep != '/' and not os.path.exists(fname):\n fname = fname.lstrip('/')\n return fname","def _write_cache(url, j):\n\n m = hashlib.md5()\n m.update(url)\n with open('.cache.%s' % m.hexdigest(), 'wb') as outfile:\n json.dump(j, outfile)","def generate_uri(uri):\n return uri[:-5] + uuid.uuid4().hex","def htid_to_filename(htid):\n\n path = htid.replace(':', '+').replace('/', '=')\n if '.' in path:\n lib_code, rec_id = path.split('.', maxsplit=1)\n path = '.'.join((lib_code, rec_id.replace('.', ',')))\n return path","def hash_file(path: str) -> str:\n return _hash_file(path, hashlib.md5()).hexdigest()","def make_filename(key, extension):\n key = unicode(key.strip())\n return '{}.{}'.format(slugify(key), extension)","def _get_etag():\n now = datetime.utcnow().isoformat()\n etag_src = \"%s--%s-%s\" % (request.script_root, request.path, now,)\n etag = hashlib.sha1(etag_src.encode('utf8', 'replace')).hexdigest()\n return etag","def hash(self) -> str:\n return md5(bytes(self.url, encoding=\"utf8\")).hexdigest()","def prettify_url(url):\n\n if not isinstance(url, urllib.parse.ParseResult):\n url = urllib.parse.urlparse(url)\n urlstr = url.hostname + url.path\n return urlstr","def format_ha_url(self, url):\n is_relative = not url.startswith(\"http\")\n if not is_relative:\n return url\n elif is_relative and self.ha_url is None:\n raise ValueError(\"ha_url must be specified when using relative url for photo_attribute.\") \n else:\n return urljoin(self.ha_url, url)","def generate_avatar_name(email, ext):\n hashed_email = hashlib.sha256(f'{email}{settings.SECRET_KEY}'.encode('utf-8')).hexdigest()\n return hashed_email[:10] + ext","def renameTempGrab(self, url, tag):\n hsh = self.hashOfTempFile()\n ext = url.split(\".\")[-1]\n fname = \"%s.%s.%s.%s\" % (tag, self.timeCode(), hsh[:10], ext)\n if os.path.exists(\"temp.dat\"):\n self.log(\"renaming temp file to: \"+fname)\n os.rename(\"temp.dat\", \"data/\"+fname)\n return fname, hsh, ext","def unique_shortened_url_string(has_url, generate_url, length=5):\n shortened = generate_url(length)\n while has_url(shortened):\n # Try again until we get a unique one.\n shortened = generate_url(length)\n return shortened","def filename(self,imgurl):\n if imgurl.find('/'):\n return imgurl.rsplit('/', 1)[1]","def get_cachebusting_name(file_str):\n\n return fu.lcompose([hash, abs, num_to_base36])(file_str)","def encode_url(url):\n\treturn url.replace(' ', '_')","def make_hash(self, long_url: str, hash_length: int):\n hasher = hashlib.md5(long_url.encode())\n bytes_hash = base64.urlsafe_b64encode(hasher.digest())[:hash_length]\n str_hash = bytes_hash.decode()\n return str_hash","def save_file(url, *, out_dir='sha_tmp/', out_name=None):\n exten_types = {'image/fits': '.fits',\n 'text/plain; charset=UTF-8': '.tbl',\n 'application/zip': '.zip',\n }\n # Make request\n response = requests.get(url, stream=True)\n response.raise_for_status()\n # Name file using ID at end\n if out_name is None:\n out_name = 'shaID_' + id_parse.findall(url)[0]\n # Determine extension\n exten = exten_types[response.headers['Content-Type']]\n # Check if path exists\n if not os.path.exists(out_dir):\n os.makedirs(out_dir)\n # Write file\n with open(out_dir + out_name + exten, 'wb') as f:\n for block in response.iter_content(1024):\n f.write(block)","def image_upload_filename(instance, filename):\n prefix = 'photos'\n uhash = abs(hash(u'%s%s' % (datetime.now(), filename)))\n user = instance.album.user.username\n return u'%s/%s/%s_%s' % (prefix, user, uhash, filename)","def hostify_url(url):\n\tif url[0] == '/':\n\t\treturn HOST + url\n\telse:\n\t\treturn url","def filename_encode(name):\n result = re.sub(r'[^\\w\\.]', lambda match: '-%04x' % ord(match.group(0)), name)\n if len(result) > 150:\n result = result[:150] + '--%s' % hashlib.md5(result[150:]).hexdigest()\n return result","def get_file_id(username, filename) -> str:\r\n unique_name = username + \"/#/\" + filename\r\n return hashlib.sha224(unique_name.encode(\"utf-8\")).hexdigest()","def namer(self, image_url, page_url):\n title = page_url.rsplit('/', 2)[1]\n image_ext = image_url.rsplit('.', 1)[1]\n return '%s.%s' % (title, image_ext)","def _file_name(size):\n timestamp = str(int(time.time()))\n return '%s_%dx%d.%s' % (timestamp, size, size, 'jpg')","def encode(self, longUrl):\n self.hash = {}\n if longUrl not in self.hash:\n idx = hash(longUrl)\n self.hash[idx] = longUrl\n final_string = 'https://tinyurl.com/' + str(idx)\n return (final_string)","def encode(self, longUrl: str) -> str:\n while True:\n result = hashlib.sha256(longUrl.encode()).hexdigest()\n shortUrl = result[:7]\n if longUrl not in self.bucket.get(shortUrl):\n self.bucket.put(shortUrl, longUrl)\n break \n return shortUrl","def hash_time(self):\n self.__log('Hashing time to create a unique filename.')\n filename = f'QR-{time.strftime(\"%Y%m%d-%H%M%S\")}'\n self.__log(f'The file name is {filename}.')\n\n return filename","def s3_etag(url, proxies=None):\n\ts3_resource = boto3.resource (\"s3\", config=Config (proxies=proxies))\n\tbucket_name, s3_path = split_s3_path (url)\n\ts3_object = s3_resource.Object (bucket_name, s3_path)\n\treturn s3_object.e_tag","def get_track_filename(self, url = None):\n track_file = urllib.urlopen(url)\n headers = track_file.info()\n track_file.close()\n return wget.filename_from_headers(headers)","def format_url(url: str) -> str:\n return urljoin(url.replace('https://app', 'https://api'), '')","def get_md5_from_str(src: str) -> str:\n res: str = \"\"\n if not isinstance(src, str) or str == \"\":\n return res\n m: hashlib._hashlib.HASH = hashlib.md5()\n m.update(src.encode('utf-8'))\n res = m.hexdigest()\n return res","def prepare_url_to_request(url):\n return url\n # get server url from database\n cursor = Database.cursor()\n cursor.execute(\"SELECT url, id FROM servers ORDER BY used_at ASC LIMIT 1\")\n row = cursor.fetchone()\n server_url = row[0]\n identity = row[1]\n # update server usage time in database\n cursor.execute(\n \"UPDATE servers SET used_at='\" +\n datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S') +\n \"' where id = '\" + str(identity) + \"'\"\n )\n Database.get_connection().commit()\n return re.sub('^.*?\\.com', server_url, url)","def static_file_hash(filepath):\n hasher = hashlib.md5() # nosec: B303\n\n with contextlib.closing(open(filepath, 'rb')) as file:\n hasher.update(file.read())\n return hasher.hexdigest()","def get_filename(self) -> str:\n fname = self.url.split(\"/\")[-1]\n if \",\" in fname:\n _fname, _i = fname.split(\",\")\n _split_fname = _fname.split(\".\")\n _name = _split_fname[0]\n _extension = _split_fname[-1]\n return _name + _i + \".\" + _extension\n else:\n return fname","def _get_file_name(url: str) -> str:\n url = url.strip('/')\n result = findall(r'/(\\w+\\.\\w+)[?|$]', url)\n if result:\n return result[-1]\n return url.split('/')[-1]","def hash_file(fname):\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def find_and_modify_url_info_md5(url, md5_hash):\n\n update_map = {\"md5\" : md5_hash}\n inc_map = None\n fields = [\"md5\"]\n\n url_info = UrlCacheClient.find_and_modify_url_info_by_not_md5(url, md5_hash, update_map, inc_map, fields)\n\n cond = default_cond(url)\n cond[\"md5\"] = {\"$ne\" : md5_hash}\n\n if url_info is None:\n url_info = _cond_update_url_info(cond, update_map, inc_map, fields)\n elif url_info == False:\n url_info = None\n else:\n _async_update_url_info(cond, update_map, inc_map)\n\n if url_info is None:\n return 0 #duplicate md5\n elif url_info[\"md5\"] is not None:\n return 1 #md5 changed\n else:\n return 2 #first md5","def parse_filename(url):\n # extract the URL path\n url_path = urlparse.urlparse(url).path\n filename = url_path.split('/')[-1]\n\n # make loose assumption the file name is for an HTML page\n if len(filename) < 1:\n filename = 'index.html'\n\n return filename","def get_md5(bucket, path):\n return bucket.get_key(path).etag[1:-1]","def record_to_file(url, filename):\n\tcontents = []\n\tif os.path.exists(filename):\n\t\tcontents = open(filename, \"r\").readlines()\n\ts = set(contents)\n\ts.add(\"%s\\n\" % url)\n\topen(filename, \"w\").writelines(s)","def get_url(url: str) -> Optional[str]:\n try:\n parsed = urlparse(url)\n except ValueError:\n return None\n\n if parsed.scheme in (\"file\", \"\"):\n return unquote(parsed.path)\n elif parsed.scheme in (\"http\", \"https\"):\n if url.startswith(\"https://open.spotify.com/image/\"):\n url = \"https://i.scdn.co/image/\" + url[len(\"https://open.spotify.com/image/\") :]\n\n name = hashlib.sha1(url.encode(\"utf-8\")).hexdigest()\n path = os.path.join(CACHE_PATH, name) + Path(parsed.path).suffix\n\n if os.path.isfile(path):\n info(f\"Already downloaded at {path}\")\n return path\n\n # Download the file to our cache. We should probably do this asynchronously,\n # but rely on the fact that the remote server is _probably_ fast enough.\n warning(f\"Downloading {url} -> {path}\")\n try:\n os.makedirs(CACHE_PATH, exist_ok=True)\n with urlopen(url) as read:\n with open(path, \"wb\") as write:\n while chunk := read.read(2048):\n write.write(chunk)\n\n return path\n except Exception as e:\n critical(\"Error getting image \" + str(e))\n\n try:\n os.remove(path)\n except:\n pass\n\n return None\n else:\n return None","def _get_cached_filepath(prefix, url):\n filename = '{prefix}_{hash_string}.cache'.format(\n prefix=prefix,\n hash_string=_hash_value(url),\n )\n logger.debug('Cached filepath: ' + os.path.join(CACHE_DIRECTORY, filename))\n return os.path.join(CACHE_DIRECTORY, filename)","def url_for(filename):\n return \"{}{}\".format(S3_LOCATION, filename)","def save_latest_url(self, url):\n with open(self.HTTPD_LATEST_URL_FILE, 'w') as fp:\n fp.write(url + '\\n')\n logger.debug('wrote URL %s to latest URL file %s' % (url, self.HTTPD_LATEST_URL_FILE))","def _get_cache_filename(self, processor, source):\n return '%s%s' % (str(hashlib.md5(str(processor.quality) + source\\\n + str(os.path.getsize(source)) \\\n + make_filters_hash(processor.filters) \\\n + source.encode('utf-8')).hexdigest()),\n os.path.splitext(source)[1])","def _GetUrl(self, url, cache, database):\n if not url:\n return ''\n\n url_cache_results = cache.GetResults('url')\n if not url_cache_results:\n result_set = database.Query(self._URL_CACHE_QUERY)\n\n cache.CacheQueryResults(result_set, 'url', 'id', ('url', 'title'))\n url_cache_results = cache.GetResults('url')\n\n reference_url, reference_title = url_cache_results.get(url, ['', ''])\n\n if not reference_url:\n return ''\n\n return '{0:s} ({1:s})'.format(reference_url, reference_title)","def s3_md5(s3key, blocksize=65536):\n return s3key.etag.strip('\"').strip(\"'\")","def hashfile(fname, blocksize=65536):\n hasher = hashlib.md5()\n afile = open(fname, 'rb')\n buf = afile.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n buf = afile.read(blocksize)\n return hasher.hexdigest()","def compose_url(base_url, anno, chimico):\n \n return base_url + chimico + '_' + anno + '.txt'","def obfuscate_url(url: str) -> str:\n return re.sub(r\"\\/\\/.*:.*@\", \"//***:***@\", url)","def _UrlBaseName(url):\n return url.rstrip('/').rpartition('/')[-1]","def mk_filename(pattern, queryresponserow, resp, url):\n name = None\n if resp:\n cdheader = resp.headers.get(\"Content-Disposition\", None)\n if cdheader:\n _, params = parse_header(cdheader)\n name = params.get('filename', \"\")\n # Work around https://github.com/sunpy/sunpy/issues/3372\n if name.count('\"') >= 2:\n name = name.split('\"')[1]\n\n # This is a hack to to prevent IRIS data from being labelled as XML files\n if name is None and \"VOEvent_IRIS\" not in queryresponserow['fileid']:\n # Advice from the VSO is to fallback to providerid + fileid for a filename\n # As it's possible multiple providers give the same fileid.\n # However, I haven't implemented this yet as it would be a breaking\n # change to the filenames we expect.\n fileid = queryresponserow['fileid']\n\n # Some providers make fileid a path\n # Some also don't specify a file extension, but not a lot we can do\n # about that.\n name = fileid.split(\"/\")[-1]\n\n # If somehow we have got this far with an empty string, fallback to url segment\n if not name:\n name = url.split('/')[-1]\n\n # Remove any not-filename appropriate characters\n name = slugify(name)\n\n # If absolutely everything else fails make a filename based on download time\n if not name:\n name = f\"vso_file_{datetime.datetime.now().strftime('%Y%m%d%H%M%S%f')}\"\n\n fname = pattern.format(file=name,\n **queryresponserow.response_block_map)\n\n return fname","def create_filename(value):\n return '%s.mp3' % slugify(value, u'_')","def generate_file_filename(instance, filename):\n return _generate_filename(instance, filename, 'photos')"],"string":"[\n \"def url_to_filename(url, etag=None):\\n\\turl_bytes = url.encode ('utf-8')\\n\\turl_hash = sha256 (url_bytes)\\n\\tfilename = url_hash.hexdigest ()\\n\\n\\tif etag:\\n\\t\\tetag_bytes = etag.encode ('utf-8')\\n\\t\\tetag_hash = sha256 (etag_bytes)\\n\\t\\tfilename += '.' + etag_hash.hexdigest ()\\n\\n\\treturn filename\",\n \"def url_to_filename(url, etag=None):\\n url_bytes = url.encode('utf-8')\\n url_hash = sha256(url_bytes)\\n filename = url_hash.hexdigest()\\n\\n if etag:\\n etag_bytes = etag.encode('utf-8')\\n etag_hash = sha256(etag_bytes)\\n filename += '.' + etag_hash.hexdigest()\\n\\n return filename\",\n \"def endpoint_to_filename(endpoint):\\n filename = _md5sum(endpoint)\\n return filename\",\n \"def url_to_file_guid(url_id):\\r\\n\\r\\n return \\\"{}-{}-{}-{}-{}\\\".format(url_id[0:8], url_id[8:12], url_id[12:16], url_id[16:20], url_id[20:])\",\n \"def get_hash(file_url):\\n file_extension = os.path.splitext(file_url)[1]\\n return str(HASHES.get(file_extension))\",\n \"def uri_to_file(uri):\\n if not uri:\\n return\\n\\n header, data = uri.split(',')\\n md5_hash = hashlib.md5(data).hexdigest()\\n with open(\\\"static/images/%s.jpg\\\" % md5_hash, 'wb') as f:\\n f.write(data.decode('base64'))\\n return md5_hash\",\n \"def compute_etag(filename: str, chunksize: int) -> str:\\n with open(filename, \\\"rb\\\") as fh:\\n buf = fh.read(chunksize)\\n dgst_part = hashlib.md5(buf)\\n buf = fh.read(chunksize)\\n if len(buf) < 1:\\n return dgst_part.hexdigest()\\n\\n count = 1\\n dgst_whole = hashlib.md5(dgst_part.digest())\\n while len(buf) > 0:\\n count += 1\\n dgst_part = hashlib.md5(buf)\\n dgst_whole.update(dgst_part.digest())\\n buf = fh.read(chunksize)\\n return \\\"{}-{}\\\".format(dgst_whole.hexdigest(), count)\",\n \"def url_file_name(url):\\r\\n return url[url.rfind('/') + 1:]\",\n \"def _HashFilename(filename):\\n if isinstance(filename, unicode):\\n filename = filename.encode(UTF8)\\n else:\\n filename = unicode(filename, UTF8).encode(UTF8)\\n m = hashlib.sha1(filename)\\n return 'TRACKER_' + m.hexdigest() + '.' + filename[-16:]\",\n \"def url_filename(url):\\n return os.path.basename(urlparse.urlparse(url).path)\",\n \"def get_url_filename(url, headers=None, strip=[]):\\n filename = get_url_disposition_filename(url, headers)\\n if filename:\\n return filename\\n return get_url_straight_filename(url, strip=[])\",\n \"def webfilename(url):\\n headers = _get_headers_from_url(url)\\n\\n if _content_disposition(headers):\\n result = filename_from_content_disposition(_content_disposition(headers))\\n else:\\n result = url.split(\\\"/\\\")[-1]\\n\\n return result.translate(REMOVE_PUNCTUATION)\",\n \"def get_url_data(url):\\n\\n # Return data while saving the data in a file \\n # which is a hash of the URL\\n data = requests.get(url).content\\n # Save it in a filename\\n filename = hashlib.md5(url.encode(\\\"utf8\\\")).hexdigest()\\n# open(filename, 'w').write(data)\\n with open(filename, \\\"w\\\") as fileObj:\\n fileObj.write(data.decode(\\\"utf8\\\"))\\n return data\",\n \"def save_image(url):\\n ext = url.split('.')[-1]\\n filename = IMAGEDIR+os.sep+hashlib.md5(url.encode('utf-8')).hexdigest()+'.'+ext\\n if os.path.exists(filename):\\n return filename\\n try:\\n content = urlopen(url).read()\\n f = open(filename,'wb') \\n f.write(content)\\n f.close()\\n except:\\n return None\\n return filename\",\n \"def clean_filename(url):\\n valid_chars = \\\"-_() %s%s\\\" % (string.ascii_letters, string.digits)\\n nodot = url.replace('.','_').replace(':','_')\\n filename = ''.join([c for c in nodot if c in valid_chars])\\n return filename\",\n \"def give_filename( url_rel ):\\n filename = basename( url_rel )\\n\\t# Add time information\\n now_datetime = datetime.datetime.now( )\\n now_string = now_datetime.strftime( \\\"%Y-%m-%d-%H-%M-%S\\\" )\\n if filename.endswith( '.pdf' ):\\n\\t\\tfileno, ext_pdf = splitext( filename )\\n\\t\\tpdf_filename = fileno + '-' + now_string + ext_pdf\\n\\t\\treturn pdf_filename\",\n \"def filename_to_url(filename, cache_dir=None):\\n if cache_dir is None:\\n cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE\\n if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\\n cache_dir = str(cache_dir)\\n\\n cache_path = os.path.join(cache_dir, filename)\\n if not os.path.exists(cache_path):\\n raise EnvironmentError(\\\"file {} not found\\\".format(cache_path))\\n\\n meta_path = cache_path + '.json'\\n if not os.path.exists(meta_path):\\n raise EnvironmentError(\\\"file {} not found\\\".format(meta_path))\\n\\n with open(meta_path, encoding=\\\"utf-8\\\") as meta_file:\\n metadata = json.load(meta_file)\\n url = metadata['url']\\n etag = metadata['etag']\\n\\n return url, etag\",\n \"def fileId_from_url(url):\\r\\n raw_fileId = re.findall(\\\"~[0-z.]+/[0-9]+\\\", url)[0][1: ]\\r\\n return raw_fileId.replace('/', ':')\",\n \"def fileId_from_url(url):\\r\\n raw_fileId = re.findall(\\\"~[A-z.]+/[0-9]+\\\", url)[0][1:]\\r\\n return raw_fileId.replace('/', ':')\",\n \"def filename_from(url):\\n filename = url.split('/')[-1]\\n return filename\",\n \"def get_filename_from_url(url: str) -> str:\\n return os.path.basename(urllib.parse.urlparse(urllib.parse.unquote_plus(url)).path)\",\n \"def standardized_filename(self, url, fname):\\n #TODO:apply filename standardization logic\\n # non-result pages/files use default urllib name conventions\\n # result files need standardization logic (TBD)\\n if fname:\\n filename = join(self.cache_dir, fname)\\n else:\\n filename = self.filename_from_url(url)\\n return filename\",\n \"def cached_file_name(self,\\n keyword,\\n search_engine,\\n scrape_mode,\\n page_number):\\n unique = [keyword, search_engine, scrape_mode, page_number]\\n sha = hashlib.sha256()\\n sha.update(b''.join(str(s).encode() for s in unique))\\n\\n return '{file_name}.{extension}'.format(\\n file_name=sha.hexdigest(),\\n extension='cache'\\n )\",\n \"def filename_to_url(filename, cache_dir=None):\\n\\tif cache_dir is None:\\n\\t\\tcache_dir = PYTORCH_TRANSFORMERS_CACHE\\n\\tif sys.version_info[0] == 3 and isinstance (cache_dir, Path):\\n\\t\\tcache_dir = str (cache_dir)\\n\\n\\tcache_path = os.path.join (cache_dir, filename)\\n\\tif not os.path.exists (cache_path):\\n\\t\\traise EnvironmentError (\\\"file {} not found\\\".format (cache_path))\\n\\n\\tmeta_path = cache_path + '.json'\\n\\tif not os.path.exists (meta_path):\\n\\t\\traise EnvironmentError (\\\"file {} not found\\\".format (meta_path))\\n\\n\\twith open (meta_path, encoding=\\\"utf-8\\\") as meta_file:\\n\\t\\tmetadata = json.load (meta_file)\\n\\turl = metadata['url']\\n\\tetag = metadata['etag']\\n\\n\\treturn url, etag\",\n \"def _filename_from_url(url):\\n file_name = url.split(\\\"/\\\")[-1]\\n return file_name\",\n \"def filename_to_url(filename, cache_dir=None):\\n if cache_dir is None:\\n cache_dir = PYTORCH_PRETRAINED_BERT_CACHE\\n if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\\n cache_dir = str(cache_dir)\\n\\n cache_path = os.path.join(cache_dir, filename)\\n if not os.path.exists(cache_path):\\n raise EnvironmentError(\\\"file {} not found\\\".format(cache_path))\\n\\n meta_path = cache_path + \\\".json\\\"\\n if not os.path.exists(meta_path):\\n raise EnvironmentError(\\\"file {} not found\\\".format(meta_path))\\n\\n with open(meta_path, encoding=\\\"utf-8\\\") as meta_file:\\n metadata = json.load(meta_file)\\n url = metadata[\\\"url\\\"]\\n etag = metadata[\\\"etag\\\"]\\n\\n return url, etag\",\n \"def _get_file_url (url, path) :\\n path = path + \\\"/\\\" + url.replace (\\\"/\\\", \\\"!\\\").replace (\\\":\\\",\\\"\\\").replace (\\\".\\\",\\\"-\\\")\\n spl = path.split (\\\"-\\\")\\n if len (spl) >= 2 :\\n ext = spl [len (spl)-1].lower ()\\n if 2 <= len (ext) <= 3 and ext in [\\\"png\\\", \\\"jpg\\\", \\\"zip\\\", \\\"txt\\\", \\\"gif\\\", \\\"py\\\", \\\"cpp\\\", \\\"gz\\\", \\\"pdf\\\", \\\"tif\\\", \\\"py\\\", \\\"html\\\", \\\"h\\\"] :\\n spl = path.split (\\\"-\\\")\\n spl = spl [:len(spl)-1]\\n path = \\\"-\\\".join (spl) + \\\".\\\" + ext\\n return path\",\n \"def concat_url(endpoint, url):\\n u = \\\"%s/%s\\\" % (endpoint.rstrip(\\\"/\\\"), url.strip(\\\"/\\\"))\\n return u.rstrip('/')\",\n \"def shorten_duplicate_content_url(url):\\n if '#' in url:\\n url = url.split('#', 1)[0]\\n if url.endswith('index.html'):\\n return url[:-10]\\n if url.endswith('index.htm'):\\n return url[:-9]\\n return url\",\n \"def add_string_to_image_url(url, addition):\\n filename, ext = splitext(url)\\n return ''.join([filename, '-', addition, ext])\",\n \"def _generate_filename(instance, filename, prefix):\\n md5 = hashlib.md5()\\n md5.update(struct.pack('f', time.time()))\\n for chunk in instance.file.chunks():\\n md5.update(chunk)\\n extension = os.path.splitext(filename)[1]\\n return os.path.join(prefix, md5.hexdigest() + extension)\",\n \"def get_file_name(url: str):\\n filename = os.path.basename(url)\\n fname, extension = os.path.splitext(filename)\\n if extension:\\n if \\\"=\\\" in filename:\\n return filename.split(\\\"=\\\")[-1]\\n return filename\\n header = requests.head(url).headers\\n if \\\"Location\\\" in header:\\n return os.path.basename(header[\\\"Location\\\"])\\n return filename\",\n \"def unique_filename(data):\\n file = data\\n get_ext = file.filename.split(\\\".\\\")[-1]\\n new_name = \\\"%s.%s\\\" % (uuid.uuid4().hex, get_ext)\\n return new_name\",\n \"def urlgrab(self, url, filename=None, **kwargs):\\n blob_location = \\\"%s/%s\\\" % (self.base_path, url)\\n self.verbose_logger.info(\\\"downloading gs://%s/%s to %s\\\" % (self.bucket.name, blob_location, filename))\\n url = url.lstrip('/')\\n if not filename:\\n filename = url\\n\\n blob = storage.blob.Blob(name=blob_location,bucket = self.bucket)\\n blob.download_to_filename(filename)\\n return filename\",\n \"def url_to_filename(base_url: str):\\n\\n # Cuts fluff like 'http://' ~and 'www'~\\n base_url = prune_url(base_url, cut_chars=[\\\"https://\\\", \\\"http://\\\", \\\"www.\\\"])\\n\\n # Covers both Windows and Unix\\n forbidden_ascii = [\\\"/\\\", \\\"\\\\\\\\\\\", \\\"\\\\|\\\", \\\":\\\", \\\"?\\\", \\\"'\\\", '\\\"', \\\"?\\\", \\\"*\\\", \\\">\\\", \\\"<\\\"]\\n\\n for ascii_char in forbidden_ascii:\\n base_url = base_url.replace(ascii_char, \\\"-\\\")\\n\\n # Replaces '.' with '_' just in case there are file extension issues\\n filename_url = base_url.replace(\\\".\\\", \\\"_\\\")\\n\\n return filename_url\",\n \"def hashLink(link):\\n\\n return str(md5.new(link).hexdigest())[:5]\",\n \"def _anonymize_url(url: str, ip_dict: Dict[str, int]) -> str:\\n regex_match = re.match(r\\\"(?i)(^https?://)(.*?)([/:].*$)\\\", url)\\n ip = regex_match.group(2)\\n\\n try:\\n num = ip_dict[ip]\\n except KeyError:\\n ip_dict[ip] = len(ip_dict.values()) + 1\\n num = ip_dict[ip]\\n\\n return f\\\"{regex_match.group(1)}ip-{num:05d}{regex_match.group(3)}\\\"\",\n \"def get_filename(url: str) ->str:\\n if 'drive.google.com' in url:\\n return _extract_google_drive_file_id(url)\\n url, filename = os.path.split(url)\\n return filename or os.path.basename(url)\",\n \"def _encode(self, url):\\n\\n\\t\\ttiny_url = ''\\n\\n\\t\\tstring_id = self.get_string_id(url)\\n\\n\\t\\twhile string_id > 0:\\n\\t\\t\\tstring_id, mod = divmod(string_id, len(ALPHABET))\\n\\t\\t\\ttiny_url = tiny_url + ALPHABET[mod]\\n\\n\\t\\treturn tiny_url\",\n \"def create_key_from_url(raw_url):\\n org_url = urllib2.urlparse.urlparse(raw_url)\\n new_key = ''\\n net_location = org_url.netloc\\n netloc_list = net_location.split(\\\".\\\")\\n netloc_list.reverse()\\n for part in netloc_list:\\n new_key += '%s.' % part\\n new_key = new_key[:-1] # Removes trailing period\\n new_key = new_key + org_url.path \\n return new_key\",\n \"def s3_etag(url):\\n s3_resource = boto3.resource(\\\"s3\\\")\\n bucket_name, s3_path = split_s3_path(url)\\n s3_object = s3_resource.Object(bucket_name, s3_path)\\n return s3_object.e_tag\",\n \"def s3_etag(url):\\n s3_resource = boto3.resource(\\\"s3\\\")\\n bucket_name, s3_path = split_s3_path(url)\\n s3_object = s3_resource.Object(bucket_name, s3_path)\\n return s3_object.e_tag\",\n \"def _local_path_from_url(url):\\n filename = '{}.epub'.format(hashlib.sha224(url).hexdigest())\\n return os.path.join(books_settings.LOCAL_BOOKS_PATH, filename)\",\n \"def get_urifilename(uri):\\n up=urlparse.urlparse(uri)\\n return split(up[2],\\\"/\\\")[-1]\",\n \"def url_for(**options):\\n\\n url_parts = get_url_parts(**options)\\n image_hash = hashlib.md5(b(options[\\\"image_url\\\"])).hexdigest()\\n url_parts.append(image_hash)\\n\\n return \\\"/\\\".join(url_parts)\",\n \"def test_hash_url(self):\\r\\n url = u'http://google.com'\\r\\n hashed = generate_hash(url)\\r\\n self.assertEqual('aa2239c17609b2', hashed)\",\n \"def normalize_filename(url):\\n fname = url.replace('file://', '')\\n if os.sep != '/' and not os.path.exists(fname):\\n fname = fname.lstrip('/')\\n return fname\",\n \"def _write_cache(url, j):\\n\\n m = hashlib.md5()\\n m.update(url)\\n with open('.cache.%s' % m.hexdigest(), 'wb') as outfile:\\n json.dump(j, outfile)\",\n \"def generate_uri(uri):\\n return uri[:-5] + uuid.uuid4().hex\",\n \"def htid_to_filename(htid):\\n\\n path = htid.replace(':', '+').replace('/', '=')\\n if '.' in path:\\n lib_code, rec_id = path.split('.', maxsplit=1)\\n path = '.'.join((lib_code, rec_id.replace('.', ',')))\\n return path\",\n \"def hash_file(path: str) -> str:\\n return _hash_file(path, hashlib.md5()).hexdigest()\",\n \"def make_filename(key, extension):\\n key = unicode(key.strip())\\n return '{}.{}'.format(slugify(key), extension)\",\n \"def _get_etag():\\n now = datetime.utcnow().isoformat()\\n etag_src = \\\"%s--%s-%s\\\" % (request.script_root, request.path, now,)\\n etag = hashlib.sha1(etag_src.encode('utf8', 'replace')).hexdigest()\\n return etag\",\n \"def hash(self) -> str:\\n return md5(bytes(self.url, encoding=\\\"utf8\\\")).hexdigest()\",\n \"def prettify_url(url):\\n\\n if not isinstance(url, urllib.parse.ParseResult):\\n url = urllib.parse.urlparse(url)\\n urlstr = url.hostname + url.path\\n return urlstr\",\n \"def format_ha_url(self, url):\\n is_relative = not url.startswith(\\\"http\\\")\\n if not is_relative:\\n return url\\n elif is_relative and self.ha_url is None:\\n raise ValueError(\\\"ha_url must be specified when using relative url for photo_attribute.\\\") \\n else:\\n return urljoin(self.ha_url, url)\",\n \"def generate_avatar_name(email, ext):\\n hashed_email = hashlib.sha256(f'{email}{settings.SECRET_KEY}'.encode('utf-8')).hexdigest()\\n return hashed_email[:10] + ext\",\n \"def renameTempGrab(self, url, tag):\\n hsh = self.hashOfTempFile()\\n ext = url.split(\\\".\\\")[-1]\\n fname = \\\"%s.%s.%s.%s\\\" % (tag, self.timeCode(), hsh[:10], ext)\\n if os.path.exists(\\\"temp.dat\\\"):\\n self.log(\\\"renaming temp file to: \\\"+fname)\\n os.rename(\\\"temp.dat\\\", \\\"data/\\\"+fname)\\n return fname, hsh, ext\",\n \"def unique_shortened_url_string(has_url, generate_url, length=5):\\n shortened = generate_url(length)\\n while has_url(shortened):\\n # Try again until we get a unique one.\\n shortened = generate_url(length)\\n return shortened\",\n \"def filename(self,imgurl):\\n if imgurl.find('/'):\\n return imgurl.rsplit('/', 1)[1]\",\n \"def get_cachebusting_name(file_str):\\n\\n return fu.lcompose([hash, abs, num_to_base36])(file_str)\",\n \"def encode_url(url):\\n\\treturn url.replace(' ', '_')\",\n \"def make_hash(self, long_url: str, hash_length: int):\\n hasher = hashlib.md5(long_url.encode())\\n bytes_hash = base64.urlsafe_b64encode(hasher.digest())[:hash_length]\\n str_hash = bytes_hash.decode()\\n return str_hash\",\n \"def save_file(url, *, out_dir='sha_tmp/', out_name=None):\\n exten_types = {'image/fits': '.fits',\\n 'text/plain; charset=UTF-8': '.tbl',\\n 'application/zip': '.zip',\\n }\\n # Make request\\n response = requests.get(url, stream=True)\\n response.raise_for_status()\\n # Name file using ID at end\\n if out_name is None:\\n out_name = 'shaID_' + id_parse.findall(url)[0]\\n # Determine extension\\n exten = exten_types[response.headers['Content-Type']]\\n # Check if path exists\\n if not os.path.exists(out_dir):\\n os.makedirs(out_dir)\\n # Write file\\n with open(out_dir + out_name + exten, 'wb') as f:\\n for block in response.iter_content(1024):\\n f.write(block)\",\n \"def image_upload_filename(instance, filename):\\n prefix = 'photos'\\n uhash = abs(hash(u'%s%s' % (datetime.now(), filename)))\\n user = instance.album.user.username\\n return u'%s/%s/%s_%s' % (prefix, user, uhash, filename)\",\n \"def hostify_url(url):\\n\\tif url[0] == '/':\\n\\t\\treturn HOST + url\\n\\telse:\\n\\t\\treturn url\",\n \"def filename_encode(name):\\n result = re.sub(r'[^\\\\w\\\\.]', lambda match: '-%04x' % ord(match.group(0)), name)\\n if len(result) > 150:\\n result = result[:150] + '--%s' % hashlib.md5(result[150:]).hexdigest()\\n return result\",\n \"def get_file_id(username, filename) -> str:\\r\\n unique_name = username + \\\"/#/\\\" + filename\\r\\n return hashlib.sha224(unique_name.encode(\\\"utf-8\\\")).hexdigest()\",\n \"def namer(self, image_url, page_url):\\n title = page_url.rsplit('/', 2)[1]\\n image_ext = image_url.rsplit('.', 1)[1]\\n return '%s.%s' % (title, image_ext)\",\n \"def _file_name(size):\\n timestamp = str(int(time.time()))\\n return '%s_%dx%d.%s' % (timestamp, size, size, 'jpg')\",\n \"def encode(self, longUrl):\\n self.hash = {}\\n if longUrl not in self.hash:\\n idx = hash(longUrl)\\n self.hash[idx] = longUrl\\n final_string = 'https://tinyurl.com/' + str(idx)\\n return (final_string)\",\n \"def encode(self, longUrl: str) -> str:\\n while True:\\n result = hashlib.sha256(longUrl.encode()).hexdigest()\\n shortUrl = result[:7]\\n if longUrl not in self.bucket.get(shortUrl):\\n self.bucket.put(shortUrl, longUrl)\\n break \\n return shortUrl\",\n \"def hash_time(self):\\n self.__log('Hashing time to create a unique filename.')\\n filename = f'QR-{time.strftime(\\\"%Y%m%d-%H%M%S\\\")}'\\n self.__log(f'The file name is {filename}.')\\n\\n return filename\",\n \"def s3_etag(url, proxies=None):\\n\\ts3_resource = boto3.resource (\\\"s3\\\", config=Config (proxies=proxies))\\n\\tbucket_name, s3_path = split_s3_path (url)\\n\\ts3_object = s3_resource.Object (bucket_name, s3_path)\\n\\treturn s3_object.e_tag\",\n \"def get_track_filename(self, url = None):\\n track_file = urllib.urlopen(url)\\n headers = track_file.info()\\n track_file.close()\\n return wget.filename_from_headers(headers)\",\n \"def format_url(url: str) -> str:\\n return urljoin(url.replace('https://app', 'https://api'), '')\",\n \"def get_md5_from_str(src: str) -> str:\\n res: str = \\\"\\\"\\n if not isinstance(src, str) or str == \\\"\\\":\\n return res\\n m: hashlib._hashlib.HASH = hashlib.md5()\\n m.update(src.encode('utf-8'))\\n res = m.hexdigest()\\n return res\",\n \"def prepare_url_to_request(url):\\n return url\\n # get server url from database\\n cursor = Database.cursor()\\n cursor.execute(\\\"SELECT url, id FROM servers ORDER BY used_at ASC LIMIT 1\\\")\\n row = cursor.fetchone()\\n server_url = row[0]\\n identity = row[1]\\n # update server usage time in database\\n cursor.execute(\\n \\\"UPDATE servers SET used_at='\\\" +\\n datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S') +\\n \\\"' where id = '\\\" + str(identity) + \\\"'\\\"\\n )\\n Database.get_connection().commit()\\n return re.sub('^.*?\\\\.com', server_url, url)\",\n \"def static_file_hash(filepath):\\n hasher = hashlib.md5() # nosec: B303\\n\\n with contextlib.closing(open(filepath, 'rb')) as file:\\n hasher.update(file.read())\\n return hasher.hexdigest()\",\n \"def get_filename(self) -> str:\\n fname = self.url.split(\\\"/\\\")[-1]\\n if \\\",\\\" in fname:\\n _fname, _i = fname.split(\\\",\\\")\\n _split_fname = _fname.split(\\\".\\\")\\n _name = _split_fname[0]\\n _extension = _split_fname[-1]\\n return _name + _i + \\\".\\\" + _extension\\n else:\\n return fname\",\n \"def _get_file_name(url: str) -> str:\\n url = url.strip('/')\\n result = findall(r'/(\\\\w+\\\\.\\\\w+)[?|$]', url)\\n if result:\\n return result[-1]\\n return url.split('/')[-1]\",\n \"def hash_file(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def find_and_modify_url_info_md5(url, md5_hash):\\n\\n update_map = {\\\"md5\\\" : md5_hash}\\n inc_map = None\\n fields = [\\\"md5\\\"]\\n\\n url_info = UrlCacheClient.find_and_modify_url_info_by_not_md5(url, md5_hash, update_map, inc_map, fields)\\n\\n cond = default_cond(url)\\n cond[\\\"md5\\\"] = {\\\"$ne\\\" : md5_hash}\\n\\n if url_info is None:\\n url_info = _cond_update_url_info(cond, update_map, inc_map, fields)\\n elif url_info == False:\\n url_info = None\\n else:\\n _async_update_url_info(cond, update_map, inc_map)\\n\\n if url_info is None:\\n return 0 #duplicate md5\\n elif url_info[\\\"md5\\\"] is not None:\\n return 1 #md5 changed\\n else:\\n return 2 #first md5\",\n \"def parse_filename(url):\\n # extract the URL path\\n url_path = urlparse.urlparse(url).path\\n filename = url_path.split('/')[-1]\\n\\n # make loose assumption the file name is for an HTML page\\n if len(filename) < 1:\\n filename = 'index.html'\\n\\n return filename\",\n \"def get_md5(bucket, path):\\n return bucket.get_key(path).etag[1:-1]\",\n \"def record_to_file(url, filename):\\n\\tcontents = []\\n\\tif os.path.exists(filename):\\n\\t\\tcontents = open(filename, \\\"r\\\").readlines()\\n\\ts = set(contents)\\n\\ts.add(\\\"%s\\\\n\\\" % url)\\n\\topen(filename, \\\"w\\\").writelines(s)\",\n \"def get_url(url: str) -> Optional[str]:\\n try:\\n parsed = urlparse(url)\\n except ValueError:\\n return None\\n\\n if parsed.scheme in (\\\"file\\\", \\\"\\\"):\\n return unquote(parsed.path)\\n elif parsed.scheme in (\\\"http\\\", \\\"https\\\"):\\n if url.startswith(\\\"https://open.spotify.com/image/\\\"):\\n url = \\\"https://i.scdn.co/image/\\\" + url[len(\\\"https://open.spotify.com/image/\\\") :]\\n\\n name = hashlib.sha1(url.encode(\\\"utf-8\\\")).hexdigest()\\n path = os.path.join(CACHE_PATH, name) + Path(parsed.path).suffix\\n\\n if os.path.isfile(path):\\n info(f\\\"Already downloaded at {path}\\\")\\n return path\\n\\n # Download the file to our cache. We should probably do this asynchronously,\\n # but rely on the fact that the remote server is _probably_ fast enough.\\n warning(f\\\"Downloading {url} -> {path}\\\")\\n try:\\n os.makedirs(CACHE_PATH, exist_ok=True)\\n with urlopen(url) as read:\\n with open(path, \\\"wb\\\") as write:\\n while chunk := read.read(2048):\\n write.write(chunk)\\n\\n return path\\n except Exception as e:\\n critical(\\\"Error getting image \\\" + str(e))\\n\\n try:\\n os.remove(path)\\n except:\\n pass\\n\\n return None\\n else:\\n return None\",\n \"def _get_cached_filepath(prefix, url):\\n filename = '{prefix}_{hash_string}.cache'.format(\\n prefix=prefix,\\n hash_string=_hash_value(url),\\n )\\n logger.debug('Cached filepath: ' + os.path.join(CACHE_DIRECTORY, filename))\\n return os.path.join(CACHE_DIRECTORY, filename)\",\n \"def url_for(filename):\\n return \\\"{}{}\\\".format(S3_LOCATION, filename)\",\n \"def save_latest_url(self, url):\\n with open(self.HTTPD_LATEST_URL_FILE, 'w') as fp:\\n fp.write(url + '\\\\n')\\n logger.debug('wrote URL %s to latest URL file %s' % (url, self.HTTPD_LATEST_URL_FILE))\",\n \"def _get_cache_filename(self, processor, source):\\n return '%s%s' % (str(hashlib.md5(str(processor.quality) + source\\\\\\n + str(os.path.getsize(source)) \\\\\\n + make_filters_hash(processor.filters) \\\\\\n + source.encode('utf-8')).hexdigest()),\\n os.path.splitext(source)[1])\",\n \"def _GetUrl(self, url, cache, database):\\n if not url:\\n return ''\\n\\n url_cache_results = cache.GetResults('url')\\n if not url_cache_results:\\n result_set = database.Query(self._URL_CACHE_QUERY)\\n\\n cache.CacheQueryResults(result_set, 'url', 'id', ('url', 'title'))\\n url_cache_results = cache.GetResults('url')\\n\\n reference_url, reference_title = url_cache_results.get(url, ['', ''])\\n\\n if not reference_url:\\n return ''\\n\\n return '{0:s} ({1:s})'.format(reference_url, reference_title)\",\n \"def s3_md5(s3key, blocksize=65536):\\n return s3key.etag.strip('\\\"').strip(\\\"'\\\")\",\n \"def hashfile(fname, blocksize=65536):\\n hasher = hashlib.md5()\\n afile = open(fname, 'rb')\\n buf = afile.read(blocksize)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = afile.read(blocksize)\\n return hasher.hexdigest()\",\n \"def compose_url(base_url, anno, chimico):\\n \\n return base_url + chimico + '_' + anno + '.txt'\",\n \"def obfuscate_url(url: str) -> str:\\n return re.sub(r\\\"\\\\/\\\\/.*:.*@\\\", \\\"//***:***@\\\", url)\",\n \"def _UrlBaseName(url):\\n return url.rstrip('/').rpartition('/')[-1]\",\n \"def mk_filename(pattern, queryresponserow, resp, url):\\n name = None\\n if resp:\\n cdheader = resp.headers.get(\\\"Content-Disposition\\\", None)\\n if cdheader:\\n _, params = parse_header(cdheader)\\n name = params.get('filename', \\\"\\\")\\n # Work around https://github.com/sunpy/sunpy/issues/3372\\n if name.count('\\\"') >= 2:\\n name = name.split('\\\"')[1]\\n\\n # This is a hack to to prevent IRIS data from being labelled as XML files\\n if name is None and \\\"VOEvent_IRIS\\\" not in queryresponserow['fileid']:\\n # Advice from the VSO is to fallback to providerid + fileid for a filename\\n # As it's possible multiple providers give the same fileid.\\n # However, I haven't implemented this yet as it would be a breaking\\n # change to the filenames we expect.\\n fileid = queryresponserow['fileid']\\n\\n # Some providers make fileid a path\\n # Some also don't specify a file extension, but not a lot we can do\\n # about that.\\n name = fileid.split(\\\"/\\\")[-1]\\n\\n # If somehow we have got this far with an empty string, fallback to url segment\\n if not name:\\n name = url.split('/')[-1]\\n\\n # Remove any not-filename appropriate characters\\n name = slugify(name)\\n\\n # If absolutely everything else fails make a filename based on download time\\n if not name:\\n name = f\\\"vso_file_{datetime.datetime.now().strftime('%Y%m%d%H%M%S%f')}\\\"\\n\\n fname = pattern.format(file=name,\\n **queryresponserow.response_block_map)\\n\\n return fname\",\n \"def create_filename(value):\\n return '%s.mp3' % slugify(value, u'_')\",\n \"def generate_file_filename(instance, filename):\\n return _generate_filename(instance, filename, 'photos')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84432817","0.84120035","0.672716","0.64712","0.62056106","0.61464995","0.6029297","0.59602135","0.59466934","0.59007996","0.58756745","0.5849285","0.57746124","0.57643247","0.57582027","0.57522213","0.574183","0.5723955","0.5720462","0.57145333","0.5713547","0.5709072","0.56945527","0.56916726","0.5680909","0.5617689","0.5572105","0.55684114","0.55570775","0.55438966","0.5510199","0.5491453","0.5482878","0.5471305","0.5469679","0.5437064","0.5417425","0.5406354","0.5395743","0.539463","0.53688186","0.53688186","0.53616524","0.5361404","0.5355088","0.5316395","0.5313433","0.5296518","0.5279115","0.5277979","0.527517","0.52659714","0.52466476","0.5237094","0.52334636","0.52329975","0.52250516","0.5215487","0.5199774","0.51824313","0.51752335","0.5169463","0.5166031","0.51636237","0.5154699","0.51505023","0.5147756","0.51462007","0.5141731","0.5132953","0.51159036","0.51139224","0.5111546","0.51066613","0.50965035","0.5070026","0.5065327","0.50635254","0.5061261","0.50578636","0.5056537","0.5046676","0.50365555","0.50359493","0.5030268","0.5027232","0.5015221","0.50144154","0.5011749","0.50079864","0.5007843","0.50063694","0.5000678","0.49962953","0.49906418","0.49847123","0.4984231","0.49825382","0.49813715","0.49813595"],"string":"[\n \"0.84432817\",\n \"0.84120035\",\n \"0.672716\",\n \"0.64712\",\n \"0.62056106\",\n \"0.61464995\",\n \"0.6029297\",\n \"0.59602135\",\n \"0.59466934\",\n \"0.59007996\",\n \"0.58756745\",\n \"0.5849285\",\n \"0.57746124\",\n \"0.57643247\",\n \"0.57582027\",\n \"0.57522213\",\n \"0.574183\",\n \"0.5723955\",\n \"0.5720462\",\n \"0.57145333\",\n \"0.5713547\",\n \"0.5709072\",\n \"0.56945527\",\n \"0.56916726\",\n \"0.5680909\",\n \"0.5617689\",\n \"0.5572105\",\n \"0.55684114\",\n \"0.55570775\",\n \"0.55438966\",\n \"0.5510199\",\n \"0.5491453\",\n \"0.5482878\",\n \"0.5471305\",\n \"0.5469679\",\n \"0.5437064\",\n \"0.5417425\",\n \"0.5406354\",\n \"0.5395743\",\n \"0.539463\",\n \"0.53688186\",\n \"0.53688186\",\n \"0.53616524\",\n \"0.5361404\",\n \"0.5355088\",\n \"0.5316395\",\n \"0.5313433\",\n \"0.5296518\",\n \"0.5279115\",\n \"0.5277979\",\n \"0.527517\",\n \"0.52659714\",\n \"0.52466476\",\n \"0.5237094\",\n \"0.52334636\",\n \"0.52329975\",\n \"0.52250516\",\n \"0.5215487\",\n \"0.5199774\",\n \"0.51824313\",\n \"0.51752335\",\n \"0.5169463\",\n \"0.5166031\",\n \"0.51636237\",\n \"0.5154699\",\n \"0.51505023\",\n \"0.5147756\",\n \"0.51462007\",\n \"0.5141731\",\n \"0.5132953\",\n \"0.51159036\",\n \"0.51139224\",\n \"0.5111546\",\n \"0.51066613\",\n \"0.50965035\",\n \"0.5070026\",\n \"0.5065327\",\n \"0.50635254\",\n \"0.5061261\",\n \"0.50578636\",\n \"0.5056537\",\n \"0.5046676\",\n \"0.50365555\",\n \"0.50359493\",\n \"0.5030268\",\n \"0.5027232\",\n \"0.5015221\",\n \"0.50144154\",\n \"0.5011749\",\n \"0.50079864\",\n \"0.5007843\",\n \"0.50063694\",\n \"0.5000678\",\n \"0.49962953\",\n \"0.49906418\",\n \"0.49847123\",\n \"0.4984231\",\n \"0.49825382\",\n \"0.49813715\",\n \"0.49813595\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8393963"},"document_rank":{"kind":"string","value":"2"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":934,"numItemsPerPage":100,"numTotalItems":95772,"offset":93400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTUzNTI4OCwianRpIjoiMWI3MzQxYjItOTI5Mi00NzUzLWFhNDQtMzY2ZDRjOWM0MTk2Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU1Mzg4ODgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.zp2W9o-foQa8M-7wCjyJtwP5i6c5_4jOScyyLu_emtx7xImKY0FslH-HInVrIrzH0DfttQ7wFz1-4wqYHhSACg","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 |
|---|---|---|---|---|---|---|
Load the data and calculate heights. | def _initialise_data(self):
data_graph = self._load_data()
data_graph.calculate_max_heights()
return data_graph | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getHeights(self):\n if self.heights: return self.heights\n reader = self.getReader()\n subData = reader.findSubRecord('VHGT','LAND')\n if not subData: return None\n height0 = struct.unpack('f',subData[:4])[0]\n import array\n deltas = array.array('b',subData[4:4... | [
"0.64111936",
"0.6029936",
"0.5960766",
"0.59529585",
"0.5880706",
"0.5839389",
"0.5756515",
"0.5741466",
"0.5675853",
"0.5659828",
"0.5659828",
"0.5659828",
"0.563116",
"0.563116",
"0.56030744",
"0.5593001",
"0.55927116",
"0.5567349",
"0.5567349",
"0.552846",
"0.5522765",
... | 0.6433362 | 1 |
Create a list of pairs (input edge count, node) that is sorted from highest count. | def _select_sources(self, nodes):
node_sources = []
for node in nodes:
if len(node.edges_in) == 0:
node_sources.append(node)
node_sources.sort(reverse=True, key=lambda n: (len(n.edges_out), n.height, n.name))
return node_sources | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def walk_sort(edges):\n g = nx.Graph()\n g.add_edges_from(edges)\n connected = set()\n degree = nx.degree(g)\n ordering = []\n while degree:\n next = max_degree_node(g, degree, connected)\n if next is not None:\n ordering.append(next)\n else:\n break\n ... | [
"0.64853567",
"0.6266425",
"0.6056536",
"0.59029275",
"0.5899401",
"0.5843856",
"0.5779872",
"0.57611424",
"0.5738577",
"0.5725267",
"0.57128936",
"0.57043004",
"0.5701572",
"0.5685223",
"0.56579274",
"0.5656229",
"0.5655609",
"0.5655609",
"0.56483656",
"0.5597191",
"0.558169... | 0.0 | -1 |
Post a question and wait for the user's response. | def _post_question(self, question):
self.messages_sent.append(question)
if self.user_input:
return input(question)
else:
ans = self.lines.pop(0)
print(question + ans)
return ans | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_question(self):\n self.post_meetup()\n return self.client.post(\"api/v2/questions\", headers={\"Authorization\": \"{}\".format(self.token())}, data=json.dumps(self.question), content_type='application/json')",
"def Wait(p_question: str):\n input(p_question)\n return",
"def _post_qu... | [
"0.6669837",
"0.6633832",
"0.66121936",
"0.6588372",
"0.64548445",
"0.6415149",
"0.640862",
"0.63962865",
"0.63914204",
"0.63729346",
"0.63199115",
"0.63199115",
"0.6252762",
"0.62428695",
"0.61925095",
"0.60855335",
"0.6048211",
"0.60243255",
"0.60222024",
"0.5988716",
"0.59... | 0.6390715 | 9 |
Post an answer to the user and save it for analysis. | def _post_answer(self, answer):
print(answer)
self.messages_received.append(answer) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_answer():\n try:\n answer = request.args.get('answer')\n poll_id = request.args.get('poll_id')\n user_name = request.args.get('user_name')\n if user_service.check_user(user_name):\n service.insert_answer(answer, poll_id, user_name)\n ... | [
"0.70205164",
"0.6791866",
"0.67722994",
"0.6704242",
"0.6661546",
"0.65924793",
"0.65407985",
"0.6536091",
"0.65116584",
"0.65081704",
"0.64944977",
"0.64931846",
"0.6489533",
"0.64617085",
"0.634831",
"0.6341989",
"0.63410234",
"0.63369197",
"0.63127434",
"0.630318",
"0.628... | 0.6829947 | 2 |
Tell the user why I'm asking him this question. | def _why(self, current_data):
if len(self.answered_true) > 0:
print("*Uživatel odpověděl pravdivě na následující otázky: ")
for i in self.answered_true:
print("---", i.name)
if len(self.implied_true) > 0:
print("*Z nich vyplývá, že: ")
for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def asking(self):\n return 'Sure.'",
"async def nwhy(self, ctx):\n question = nekos.why()\n await ctx.send(question)",
"def hey(self, msg):\n if issilence(msg):\n return \"Fine. Be that way.\"\n elif isshouting(msg):\n return \"Woah, chill out!\"\n ... | [
"0.6908813",
"0.6718016",
"0.6626582",
"0.6435212",
"0.6357683",
"0.63420093",
"0.6309488",
"0.6275732",
"0.6197925",
"0.607799",
"0.5996539",
"0.5977487",
"0.59511226",
"0.5944695",
"0.58894676",
"0.5879362",
"0.58693576",
"0.5799273",
"0.5794895",
"0.5786102",
"0.5763241",
... | 0.0 | -1 |
Explain how i got to the current solution. | def _explain(self, solution):
# Get the whole data
whole_graph = ChatBot()
# all nodes that were marked as true either by user or implied
all_true = self.implied_true.union(self.answered_true).union(self.current_subgraph)
# get the nodes that were not used
unused = all_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_solution():\n pass",
"def explain(self):",
"def _explain(self, solution):\n all_true = self.implied_true.union(self.answered_true).union(self.current_subgraph)\n\n # recalculate all data\n self.data_graph = self._initialise_data()\n\n # get the nodes that were not used\... | [
"0.7156278",
"0.7037696",
"0.70189935",
"0.6772505",
"0.66031325",
"0.6583985",
"0.655581",
"0.655581",
"0.6534624",
"0.6422485",
"0.63931155",
"0.63874745",
"0.63836277",
"0.6379449",
"0.6364412",
"0.6364363",
"0.61915267",
"0.6169752",
"0.61190975",
"0.6086019",
"0.60786486... | 0.62415946 | 16 |
On step of the knowledge bot. Ask the user and then parse the answer | def ask(self):
# update the sources
if len(self.current_subgraph) == 0:
current_data = self._select_sources(self.data_graph.nodes)
else:
current_data = self._select_sources(self.current_subgraph)
# ask for the node with the highest priority .. sorted by (height, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def next_step(\n self, step_context: WaterfallStepContext\n ) -> DialogTurnResult:\n step_context.values[\"input\"] = step_context.result\n user_input = step_context.values[\"input\"]\n\n # TODO: remove this notification, it is for demo purposes only.\n await step_contex... | [
"0.6661836",
"0.6623523",
"0.6185823",
"0.6169001",
"0.6127652",
"0.61216295",
"0.60287195",
"0.5947787",
"0.59054744",
"0.5882209",
"0.5847624",
"0.5803464",
"0.575814",
"0.57570684",
"0.5730973",
"0.5725769",
"0.57204896",
"0.56983685",
"0.5662998",
"0.56618017",
"0.5654815... | 0.0 | -1 |
Test for foreign key constraints that don't have a corresponding index. | def test_missing_foreign_key_indices(db_session):
from sqlalchemy_utils.functions import non_indexed_foreign_keys
from kotti import metadata
assert non_indexed_foreign_keys(metadata) == {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_indexed_foreign_key(constraint):\n for index in constraint.table.indexes:\n index_column_names = set([\n column.name for column in index.columns\n ])\n if index_column_names == set(constraint.columns):\n return True\n return False",
"def collect_drop_fk(sel... | [
"0.748976",
"0.704024",
"0.68740153",
"0.6803409",
"0.6442127",
"0.63733286",
"0.6137904",
"0.6083083",
"0.6067429",
"0.59864193",
"0.5934889",
"0.57362586",
"0.56498003",
"0.56025785",
"0.5596647",
"0.5577209",
"0.5565569",
"0.5537458",
"0.552599",
"0.5427226",
"0.5406838",
... | 0.7493482 | 0 |
Syntactic sugar for synchronously grabbing an item by id, description id or name. | def __getitem__(self, key: Union[int, str]):
loop = asyncio.get_event_loop()
future = loop.create_future()
async def getitem():
if isinstance(key, int):
# Most desc_ids are 9 digits but there are 14 that aren't.
# At time of writing this is good for 1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_item(\n request: Request,\n response: Response,\n item_id: int,\n db: SAConnection = Depends(get_postgresql_connection)\n):\n cached_item = await request.app.extra['cache'].get_cache_item(item_id=item_id)\n if cached_item:\n return cached_item\n if db is No... | [
"0.6691297",
"0.6671622",
"0.66482127",
"0.66345274",
"0.6607628",
"0.6532821",
"0.65211505",
"0.6369041",
"0.6343377",
"0.632963",
"0.6251882",
"0.62229437",
"0.6185694",
"0.61646783",
"0.60775787",
"0.60709995",
"0.60169435",
"0.5998554",
"0.5959487",
"0.59420747",
"0.59297... | 0.66012645 | 5 |
Discover this item using its id or description id. The description id is preferred as it provides more information, so if only an id is provided, libkol will first determine the desc_id. Note that this Returns an Item object but it is not automatically committed to the database. It is not sufficient to run `await item.... | async def discover(cls, id: int = None, desc_id: int = None):
if id is not None:
desc_id = (await request.item_information(cls.kol, id).parse()).descid
if desc_id is None:
raise ItemNotFoundError(
"Cannot discover an item without either an id or a desc_id"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_item_detail(item_id):\n pass",
"def get_item_description(item_slug):\n return session.query(\n Items.description).filter_by(\n slug=item_slug).first()[0]",
"def get_item(self, item_id): # pragma: no cover\n raise NotImplementedError",
"def get_item(item_id):\n return It... | [
"0.5958962",
"0.5945608",
"0.58951426",
"0.5857073",
"0.5793325",
"0.5768699",
"0.57304674",
"0.5702956",
"0.5690138",
"0.5687487",
"0.56168866",
"0.5571609",
"0.5569454",
"0.55473393",
"0.5527266",
"0.5521872",
"0.54873824",
"0.54755473",
"0.541963",
"0.54195684",
"0.5334919... | 0.80740875 | 0 |
Get the lowest price for this item in the mall | async def get_mall_price(self, limited: bool = False) -> int:
prices = await request.mall_price(self.kol, self).parse()
if limited:
return prices.limited[0].price
return prices.unlimited[0].price | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_lowest_price_item_id(table):\n\n prices = [(line[ID], line[TITLE], int(line[PRICE])) for line in table]\n min_price = min(prices, key=common.get_item(2))[2]\n min_price_items = [(item[ID], item[TITLE], item[PRICE]) for item in prices if item[2] == min_price]\n\n return common.srt(min_price_item... | [
"0.7255369",
"0.7116045",
"0.7108892",
"0.6947185",
"0.6841582",
"0.675164",
"0.6612951",
"0.66056067",
"0.6539328",
"0.6539328",
"0.64958763",
"0.6480108",
"0.64767087",
"0.6460087",
"0.6364029",
"0.6355585",
"0.63383627",
"0.6330016",
"0.62961346",
"0.6272824",
"0.6271888",... | 0.62092066 | 24 |
Table print repeat info | def cli(context, repeats_file):
repeat_information = {}
with open(repeats_file, 'r') as file_handle:
repeat_information = parse_repeat_file(file_handle, repeats_file_type='json')
if not repeat_information:
LOG.warning("Could not find any repeat info")
context.abort()
header = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_table(self):\n print(\"%-12s%-12s%-12s%-12s%-12s\" % (\"index\",\"balance\",\"payment\",\"interest\",\"amortization\"))\n print(\"-------------------------------------------------------------\")\n for i in self.table[\"index\"]:\n print(\"%-12i%-12i%-12i%-12i%-12i\" % (sel... | [
"0.7371803",
"0.71344876",
"0.6969507",
"0.6963204",
"0.692555",
"0.6835418",
"0.67638135",
"0.6760846",
"0.6750816",
"0.66937345",
"0.6680997",
"0.6655735",
"0.6651745",
"0.6644229",
"0.6636536",
"0.6633744",
"0.6621832",
"0.6618156",
"0.6618156",
"0.66038305",
"0.6592382",
... | 0.0 | -1 |
Factory function to create a new currency from its ISO code | def create_currency_from_ISO(isocode):
from .commodity import Commodity
# if self.get_session().query(Commodity).filter_by(isocode=isocode).first():
# raise GncCommodityError("Currency '{}' already exists".format(isocode))
from .currency_ISO import ISO_currencies
cur = ISO_currencies.get(isoc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCurrencyIsoCode(id=None):",
"def fromisoformat(cls, *args, **kwargs): # real signature unknown\r\n pass",
"def from_code_and_minor(cls, currency_code, value):\n from .currency import currencies\n try:\n return cls(currencies[currency_code.upper()], value)\n except ... | [
"0.66242546",
"0.63548607",
"0.62624526",
"0.6172577",
"0.6047738",
"0.5967506",
"0.594702",
"0.59417343",
"0.5927033",
"0.5797854",
"0.5797854",
"0.57801336",
"0.5746309",
"0.57142186",
"0.56475854",
"0.5633694",
"0.563085",
"0.56046224",
"0.56037885",
"0.5591195",
"0.557395... | 0.7708666 | 0 |
Factory function to create a new stock from its symbol. The ISO code of the quoted currency of the stock is stored in the slot "quoted_currency". | def create_stock_from_symbol(symbol, book=None):
from .commodity import Commodity
share = get_latest_quote(symbol)
stock = Commodity(
mnemonic=symbol,
fullname=share.name,
fraction=10000,
namespace=share.exchange,
quote_flag=1,
quote_source="yahoo",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_symbol(symbol):\n st = Stock(symbol)\n return st.get_quote()",
"def FromYfinance(symbol):\n stock = Stock(symbol)\n stock.Update()\n return stock",
"def create(symbol, number_of_shares, purchase_price):\n stock = Stock(symbol, number_of_shares, purchase_price)\n databas... | [
"0.658607",
"0.655007",
"0.64967674",
"0.6324575",
"0.61781764",
"0.61781764",
"0.61742914",
"0.61241645",
"0.6066685",
"0.6028303",
"0.5916321",
"0.58823574",
"0.5855334",
"0.58455604",
"0.5823851",
"0.58002996",
"0.5796427",
"0.5793406",
"0.575277",
"0.57361037",
"0.5734318... | 0.7477825 | 0 |
Creates a new textmessage SpamFilter trained on the given text messages and their associated labels. Performs any necessary preprocessing before training the SpamFilter's Naive Bayes Classifier. As part of this process, trains and stores the CountVectorizer used in the feature extraction process. | def __init__(self, text_train, labels_train):
self.vectorizer = CountVectorizer(stop_words='english')
self.features = self.vectorizer.fit_transform(text_train)
self.nbc = MultinomialNB().fit(self.features, labels_train) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_model(self, text, labels):\n clf = svm.SVR()\n count_vect = CountVectorizer()\n tfidf_transformer = TfidfTransformer()\n counts = count_vect.fit_transform(text)\n tfidf = tfidf_transformer.fit_transform(counts)\n clf.fit(tfidf, labels)\n\n return clf, coun... | [
"0.59928596",
"0.5991479",
"0.58972853",
"0.5896386",
"0.5881257",
"0.58270174",
"0.5791569",
"0.57531697",
"0.56607693",
"0.5642098",
"0.56038517",
"0.55683374",
"0.5556388",
"0.5550796",
"0.5503383",
"0.54590356",
"0.53853714",
"0.53828907",
"0.5378921",
"0.5342874",
"0.534... | 0.624333 | 0 |
Takes as input a list of raw textmessages, uses the SpamFilter's vectorizer to convert these into the known bag of words, and then returns a list of classifications, one for each input text | def classify (self, text_test):
test_features = self.vectorizer.transform(text_test)
return self.nbc.predict(test_features) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vectorize_text(text):\n\n def remove_punctuation(text):\n \"\"\"Removes special characters from text.\"\"\"\n return re.sub('[,.?\";:\\-!@#$%^&*()]', '', text)\n\n def remove_common_words(text_vector):\n \"\"\"Removes 50 most common words in the uk english.\n\n source: http://... | [
"0.6773912",
"0.6709329",
"0.66575223",
"0.66177416",
"0.65822107",
"0.6579251",
"0.64948726",
"0.64688814",
"0.6454887",
"0.6437127",
"0.64282006",
"0.6301154",
"0.6277714",
"0.6274535",
"0.6252408",
"0.62520164",
"0.6225644",
"0.61832404",
"0.6182126",
"0.61709464",
"0.6170... | 0.0 | -1 |
Takes the testset as input (2 DataFrames consisting of test texts and their associated labels), classifies each text, and then prints the classification_report on the expected vs. given labels. | def test_model (self, text_test, labels_test):
print(classification_report(labels_test, self.classify(text_test))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_classification_report(y_train,y_test,y_train_preds,y_test_preds): \n try:\n for i in range(y_train.shape[-1]):\n test = (y_test.iloc[:,i].values, y_test_preds[:,i])\n train = (y_train.iloc[:,i].values, y_train_preds[:,i])\n print(f\"---------------{y_train.co... | [
"0.70495254",
"0.6905331",
"0.68044335",
"0.67821795",
"0.67230874",
"0.6670411",
"0.6623034",
"0.6588332",
"0.6568425",
"0.652718",
"0.64948666",
"0.6488643",
"0.6487697",
"0.64806813",
"0.64704436",
"0.6383303",
"0.6340591",
"0.63397235",
"0.6333492",
"0.63176745",
"0.63121... | 0.75366956 | 0 |
Takes a path to the raw data file (a csv spreadsheet) and creates a new Pandas DataFrame from it with only the message texts and labels as the remaining columns. | def load_and_sanitize (data_file):
data = pd.read_csv(data_file, encoding="latin-1")
data = data.drop(columns=['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'])
data = data.rename(columns={"v1": "class", "v2": "text"})
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(txt_path: str = RAW_TXT) -> pd.DataFrame:\n df = pd.read_csv(txt_path)[INDICES]\n return df",
"def load_raw_data(path: str) -> pd.DataFrame:\n data = []\n with open(path) as file:\n for line in file:\n data.append(line)\n data_df = pd.DataFrame(data, columns = {'twe... | [
"0.71791464",
"0.70036703",
"0.69079787",
"0.66350573",
"0.6587034",
"0.6573408",
"0.65146476",
"0.6495639",
"0.649103",
"0.6491012",
"0.6479905",
"0.6461631",
"0.6417438",
"0.63850695",
"0.63770866",
"0.6361787",
"0.6361787",
"0.6361787",
"0.63617593",
"0.6361643",
"0.630978... | 0.5878654 | 76 |
method parses csv file and loads images into structure Image | def parse_data(filename, data_path, ground_truths_path):
with open(filename) as f:
content = f.readlines()
content = [x.strip() for x in content]
data = []
for i, item in enumerate(content):
if i == 0:
continue
parametres = item.split(',')
image = cv2.imrea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_or_new(cls, csv_path, image_files):\n if os.path.exists(csv_path):\n return cls.from_csv(csv_path)\n else:\n return cls.graphical(image_files)",
"def _read_labels_csv_file(self, csv_file_path, image_file_paths):\n\n self.__logger.debug('[Get Labels]')\n ... | [
"0.71182513",
"0.70285696",
"0.69939166",
"0.6939744",
"0.67621666",
"0.6727584",
"0.6722772",
"0.66315526",
"0.6631409",
"0.6559266",
"0.6529502",
"0.6486764",
"0.64602864",
"0.6403504",
"0.63981724",
"0.63912535",
"0.63322",
"0.63251",
"0.6303752",
"0.62977785",
"0.6280485"... | 0.0 | -1 |
function returns TP, FP, TN, FN metrics score | def perf_measure(y_actual, y_hat):
TP = 0
FP = 0
TN = 0
FN = 0
for i in range(len(y_hat)):
if y_actual[i]==y_hat[i]==1:
TP += 1
if y_hat[i]==1 and y_actual[i]!=y_hat[i]:
FP += 1
if y_actual[i]==y_hat[i]==0:
TN += 1
if y_hat[i]==0 and... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_metrics(self):\n sensitivity = TP + FN\n sensitivity = TP / sensitivity\n\n specificity = TN + FP\n specificity = TN / specificity\n\n accuracy = TP + FP + TN + FN\n divisor = TP + TN\n accuracy = divisor / accuracy\n\n positive_predictive = TP ... | [
"0.7501237",
"0.6926722",
"0.6862839",
"0.6861548",
"0.68331003",
"0.68244755",
"0.68199164",
"0.681663",
"0.6799322",
"0.67838806",
"0.67769575",
"0.6709428",
"0.67028385",
"0.66891694",
"0.668129",
"0.6674142",
"0.66389775",
"0.66237277",
"0.6617541",
"0.66001135",
"0.65845... | 0.6616394 | 19 |
Convert (year,month,day) to day of the year (out of 366) January 1 = 0 | def find_day_of_year(year, month, day):
leap_flag = year % 4 == 0
feb_days = np.where(leap_flag, 29, 28)
days_per_month = np.array([31, feb_days, 31, 30, 31, 30, 31, 31,
30, 31, 30, 31])
return np.sum(days_per_month[0:month-1]) + day - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def day_of_year(month, day):\n try:\n # 2003 is an arbitrary non-leap year.\n return date(2003, month, day).timetuple().tm_yday\n except ValueError:\n if month == 2 and day == 29:\n return 60\n else:\n raise",
"def date_to_day_of_year(year, month, day):\n ... | [
"0.74115866",
"0.7353909",
"0.718122",
"0.71607465",
"0.7069977",
"0.7047048",
"0.68796897",
"0.68069255",
"0.673768",
"0.67354643",
"0.6649406",
"0.65735936",
"0.6567866",
"0.65617204",
"0.6547489",
"0.653711",
"0.65096027",
"0.6506358",
"0.6505979",
"0.64983153",
"0.6476086... | 0.7057415 | 5 |
Calculate the unconditional mean vector of a multivariate normal DAG. This function calculates the mean vector of a multivariate normal DAG. It only calculates the vector and stores the values in the dag. Use the function 'mean_vector' to get to the vector. | def to_dagauss(G):
V = list(networkx.topological_sort(G))
""" Populates a directed graph G with attributes. """
for node in G.nodes:
G.nodes[node]["beta"] = sp.Symbol("beta_" + node, real = True )
G.nodes[node]["sigma"] = sp.Symbol("sigma_" + node, positive = True)
for edge in G.edges:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vector_mean(vectors: List[Vector]) -> Vector:\n n = len(vectors)\n return scalar_multiply(1/n, vector_sum(vectors))",
"def vector_mean(vectors: List[Vector]) -> Vector:\n n = len(vectors)\n return scalar_multiply(1/n, vector_sum(vectors))",
"def vector_mean(vectors: List[Vector]) -> Vector:\n ... | [
"0.65818983",
"0.65818983",
"0.65590894",
"0.65404785",
"0.65404785",
"0.65404785",
"0.6522068",
"0.6522068",
"0.62767",
"0.6115197",
"0.6051941",
"0.5798251",
"0.5677843",
"0.56523216",
"0.5638601",
"0.55734503",
"0.55333024",
"0.5528915",
"0.5496608",
"0.54678524",
"0.54666... | 0.0 | -1 |
Calculate the conditional mean vector and covariance matrix | def parameters(G, variables = [], conditionants = []):
if(not variables):
variables = get_order(G, conditionants)
H = G.graph["dependency_graph"]
order = get_order(G)
mean_ = sp.Matrix([H.nodes[value]["mu"] for value in order])
cov = sp.zeros(len(order), len(order))
for (i, j) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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... | [
"0.64783967",
"0.64311194",
"0.6394623",
"0.636508",
"0.63498867",
"0.6311388",
"0.6303238",
"0.6297135",
"0.6278319",
"0.62237257",
"0.62198985",
"0.62144303",
"0.61656857",
"0.6094996",
"0.60383916",
"0.6037372",
"0.6010727",
"0.5990731",
"0.59747386",
"0.59711796",
"0.5951... | 0.0 | -1 |
Calculate the conditional mean vector | def mean(G, variables = [], conditionants = []):
return parameters(G, variables = variables,
conditionants = conditionants)["mean"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conditional_mean(self, F):\n raise NotImplementedError",
"def conditional_mean(self, gp):\n raise NotImplementedError",
"def mean(self):\n return self.cond_proba.mean",
"def _get_mean(self):\n mu = self._get_conditional_negative_energy()\n return sigmoid(mu)",
"def co... | [
"0.75884086",
"0.7420518",
"0.7326542",
"0.72048956",
"0.7168534",
"0.696724",
"0.69614416",
"0.68689317",
"0.68494517",
"0.6848806",
"0.6841679",
"0.6841358",
"0.68342346",
"0.68115646",
"0.68115646",
"0.68115646",
"0.6789283",
"0.6777226",
"0.6777226",
"0.6732227",
"0.67221... | 0.61112547 | 90 |
Calculate the conditional covariance matrix | def covariance(G, variables = [], conditionants = []):
return parameters(G, variables = variables,
conditionants = conditionants )["cov"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conditional_component_covs(self):\n return np.array([d.conditional_cov() for d in self.conditionalMVNs])",
"def covariance(data_matrix):\n return np.asmatrix(np.cov(data_matrix, rowvar=0))",
"def covariance_matrix(self):\n\n self._order_observations()\n self.cov_matrix = self._compu... | [
"0.73899573",
"0.7329456",
"0.7226545",
"0.70018446",
"0.69857293",
"0.69405174",
"0.68893206",
"0.681819",
"0.67607033",
"0.67339945",
"0.6721007",
"0.66540647",
"0.6635569",
"0.66328156",
"0.6599933",
"0.659521",
"0.6584683",
"0.6575936",
"0.6550229",
"0.65470797",
"0.65456... | 0.6713619 | 11 |
Calculate the conditional covariance matrix | def variance(G, variables = [], conditionants = []):
cov = covariance(G, variables = variables,
conditionants = conditionants)
if len(variables) == 1:
return cov[0]
else:
return cov | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conditional_component_covs(self):\n return np.array([d.conditional_cov() for d in self.conditionalMVNs])",
"def covariance(data_matrix):\n return np.asmatrix(np.cov(data_matrix, rowvar=0))",
"def covariance_matrix(self):\n\n self._order_observations()\n self.cov_matrix = self._compu... | [
"0.73899573",
"0.7329456",
"0.7226545",
"0.70018446",
"0.69857293",
"0.69405174",
"0.68893206",
"0.681819",
"0.67607033",
"0.67339945",
"0.6721007",
"0.6713619",
"0.66540647",
"0.6635569",
"0.66328156",
"0.6599933",
"0.659521",
"0.6584683",
"0.6575936",
"0.6550229",
"0.654707... | 0.0 | -1 |
Calculate the theoretical beta coefficient of a regression | def beta(G, responses = [], covariates = [], conditionants = []):
variables = covariates + conditionants
means = mean(G, responses, variables)
def collect(index):
return sp.collect(expr = sp.expand(means[index]),
syms = variables)
collections = [... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def beta_coef_(self):\n return pcr_beta_coef(self.regression, self.prcomp)",
"def beta(self):\n eTheta = self.eTheta()\n cosOmg = np.cos(self.omega())\n return self.a1()/c.c*(1-eTheta**2)**0.5*cosOmg",
"def _beta(self):\n return _handle_ab(self.solution, self.use_const)[1]",
... | [
"0.7797716",
"0.7335511",
"0.7307658",
"0.7068588",
"0.69392455",
"0.68964314",
"0.6882692",
"0.6854041",
"0.6854041",
"0.68456256",
"0.68385607",
"0.6826287",
"0.681263",
"0.681263",
"0.6769854",
"0.6761017",
"0.67435676",
"0.6736225",
"0.66807735",
"0.6674472",
"0.66708785"... | 0.59473324 | 92 |
Calculates the theoretical R squared. This function calculates R squared, also known as the coefficient of determination. | def rsquared(G, responses, covariates, conditionants = [], norm = "trace"):
betas = beta(G, responses = responses,
covariates = covariates,
conditionants = conditionants)
cov_covariates = variance(G, variables = covariates,
conditionan... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _rsq(self):\n return self._ss_reg / self._ss_tot",
"def R_squared(self):\n return 1 - ((self.y - self.y_hat(self.x))**2).sum() / ((self.y - self.y.mean())**2).sum()",
"def R_square(self,parameterValues=None):\n sst = self.SST(parameterValues)\n cost = self.Cost(parameterValues)\... | [
"0.7470857",
"0.7435628",
"0.6879839",
"0.6857282",
"0.6828465",
"0.6814315",
"0.6789556",
"0.66813314",
"0.65971434",
"0.6531645",
"0.64626896",
"0.64340127",
"0.64333946",
"0.64192575",
"0.6368554",
"0.6368314",
"0.63613373",
"0.6360666",
"0.6342186",
"0.6327854",
"0.624074... | 0.59219635 | 44 |
Calculates the conditional correlation. | def correlation(G, variables = [], conditionants = []):
cov = covariance(G, variables = variables,
conditionants = conditionants)
k = cov.shape[0]
sds = sp.Matrix([1/sp.sqrt(cov[i, i]) for i
in range(0, k)]*k).reshape(k, k)
cor = cov.multiply_e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mp_corr(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = p1 + q1\n\n if n == 0:\n return np.nan\n elif a == n or d == n:\n # only one (diagonal) cell is non-zero\n return 0.5\n elif b == n... | [
"0.6608739",
"0.6533732",
"0.6441438",
"0.63805926",
"0.62961954",
"0.6242456",
"0.62402856",
"0.6196539",
"0.61814976",
"0.6175767",
"0.6171645",
"0.6156763",
"0.6144202",
"0.61440504",
"0.6108581",
"0.6100552",
"0.6100552",
"0.60683787",
"0.6066992",
"0.60644835",
"0.602987... | 0.63287646 | 4 |
thin the edges and delete the values below the low threshold so that it doesn't need to happen in hysteresis anymore (or don't delete the low ones, doesn't really matter when it happens) | def thin_edges(magnitude, angle, low):
# define footprints for the angle cases (1, 2, 3 and 4)
t1 = time.time()
f1 = np.array([[1, 0, 1]])
f2 = np.array([[1, 0, 0], [0, 0, 0], [0, 0, 1]]) # hier had ik f4 verwacht, ma de hoeken kloppen niet
f3 = np.array([[1], [0], [1]])
f4 = np.array([[0, 0, 1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fix_straight_lines(self):\r\n\r\n # Creates a vertical 1x5 kernel and applies binary closing based on that kernel\r\n vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 5))\r\n self.thresh_invert = cv2.morphologyEx(self.thresh_invert, cv2.MORPH_CLOSE, vertical_kernel, iteratio... | [
"0.6336831",
"0.6080223",
"0.6076756",
"0.6074127",
"0.6065923",
"0.60143733",
"0.59788924",
"0.590821",
"0.58946663",
"0.5881717",
"0.58767915",
"0.58761054",
"0.58173144",
"0.5753505",
"0.5737722",
"0.5726844",
"0.57266",
"0.5726238",
"0.5722348",
"0.5721435",
"0.56907165",... | 0.58781993 | 10 |
Parses the Gaussian log file for the QM energy. Returns | def ReadGaussian():
# LICHEM calculates this as the optimization energy - self energy.
# Self energy of the charges = {f} a.u.
self_line = " Self energy of the charges"
# SCF Done: E({s}) = {f} A.U. after {d} cycles
SCF_line = " SCF Done:"
with open('LICHM_GaussEnergy_0.log') as f:
for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_fermi_energy_from_log(log_file):\n with open(log_file, \"r\") as f:\n content = f.readlines()\n ferimiValues = EFermi_Pattern.findall(\"\".join(content))\n return list([float(item.split()[1]) for item in ferimiValues])",
"def read_data_test_MLOG(self):\n self.na.set_query_timeout(... | [
"0.60903597",
"0.575791",
"0.5489557",
"0.54672337",
"0.5395261",
"0.5361491",
"0.5357795",
"0.53484565",
"0.53275615",
"0.5284829",
"0.5283435",
"0.52671564",
"0.5243411",
"0.5235176",
"0.5217604",
"0.5205431",
"0.51733214",
"0.5166768",
"0.515823",
"0.51553243",
"0.5126141"... | 0.6854024 | 0 |
Parses the TINKER log file for the MM energy. Currently does not support AMOEBA polarization terms! Returns | def ReadTinker():
# Total Potential Energy : {f} Kcal/mole
total_line = " Total Potential Energy :"
with open('LICHM_TINKEREnergy_0.log') as f:
for line in f:
if line.startswith(total_line):
# print(line)
TinkE = re.findall(r'\-\d+\.*\d*', line)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_lammps_log(logfile):\n keys = None\n data = []\n read = False\n with open(logfile) as infile:\n for lines in infile:\n if lines.startswith('Step'):\n if data:\n yield keys, data\n keys = [i.lower() for i in lines.strip().split(... | [
"0.6170222",
"0.6100037",
"0.5945984",
"0.59330875",
"0.583597",
"0.58223265",
"0.573726",
"0.5724382",
"0.57241416",
"0.5691281",
"0.5658535",
"0.55970955",
"0.55613095",
"0.5531624",
"0.55298966",
"0.5528802",
"0.55086756",
"0.5499865",
"0.54951453",
"0.54804593",
"0.547738... | 0.70619804 | 0 |
Sums the QM and MM energy. Returns | def GetSum(GaussE, TinkE):
sumE = GaussE + TinkE
return sumE | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def energy(self):\n sum_energy = 0.0\n for i in range(0,self.natoms-1):\n for j in range(i+1,self.natoms):\n rij = (self.atoms[i].xyz - self.atoms[j].xyz)\n rij = rij - self.pbc_correction(rij)\n mag_rij = la.norm(rij)\n ... | [
"0.6841351",
"0.6395822",
"0.62988883",
"0.6194192",
"0.6180285",
"0.60826874",
"0.60562325",
"0.60547197",
"0.6052184",
"0.6049038",
"0.6040721",
"0.60101056",
"0.5994954",
"0.5935547",
"0.59211665",
"0.5914214",
"0.5909242",
"0.5854844",
"0.58482",
"0.5826296",
"0.5823644",... | 0.0 | -1 |
Prints out the energy breakdown as requested. Formats them to 10 decimal places. | def PrintDetailedE(GaussE, TinkE, sumE, result_format):
## Force to lowercase for search
result_format = [each_form.lower() for each_form in result_format]
if 'all' in result_format:
print("\n")
print(f"Gaussian Energy (au): {GaussE/har2ev:.10f} +")
print(f"Tinker Energy (au): {Tin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printenergy(a=atoms): # store a reference to atoms in the definition.\n epot = a.get_potential_energy() / len(a)\n ekin = a.get_kinetic_energy() / len(a)\n print('Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) '\n 'Etot = %.3feV' % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin... | [
"0.6651297",
"0.66041625",
"0.64915216",
"0.6394182",
"0.63865393",
"0.6292253",
"0.6252328",
"0.61997074",
"0.61993366",
"0.61913204",
"0.61803615",
"0.6095283",
"0.6078317",
"0.60224664",
"0.59334",
"0.5921052",
"0.5904255",
"0.5897822",
"0.582768",
"0.57853764",
"0.5727542... | 0.62866193 | 6 |
Choose a behavior class, based on the behaviorClass JSON attribute. | def get_behavior_class_from_dict(data):
# TODO: Replace with a behavior package.
class_map = {
"PlayAnim": BehaviorPlayAnim,
"PlayArbitraryAnim": BehaviorPlayArbitraryAnim,
"ReactToCliff": BehaviorReactToCliff,
"DriveOffCharger": BehaviorDriveOffCharger,
}
cls = class_map... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def behavior_for_attributes(self, attributes):\n for behavior, criteria in self.registered_behaviors:\n if criteria.evaluate(attributes):\n return behavior\n return self.event.default_behavior",
"def getBehaviorNature(self, behavior):\n if not self.proxy:\n ... | [
"0.58255094",
"0.5570628",
"0.51562303",
"0.5121632",
"0.51032513",
"0.5080963",
"0.5079439",
"0.5076947",
"0.50172156",
"0.5009232",
"0.50005877",
"0.49934128",
"0.493821",
"0.49222156",
"0.49222156",
"0.48718593",
"0.4865874",
"0.4862071",
"0.4836569",
"0.48241413",
"0.4805... | 0.72726583 | 0 |
Collect urls of images by keyword using splash api | def collect_urls_by_keyword(keyword: str, page_num: int, n_max: int, scenery: bool = False):
if scenery:
keyword += '-scenery'
r = requests.get(f'https://api.unsplash.com/search/collections?query={keyword}&page={page_num}&per_page={n_max}&client_id=1H5zbugfvk1UOnX60y2yiMyjNMrE-vdpThxGkP1y9_E')
data ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keyword_to_images(keywords):\n searchTerm = ' '.join(keywords)\n searchTerm = searchTerm.replace(' ', '%20')\n\n # Start FancyURLopener with defined version\n # myopener = MyOpener()\n\n # Notice that the start changes for each iteration in order\n # to request a new set of images for each lo... | [
"0.67936283",
"0.662286",
"0.66023016",
"0.65941745",
"0.65375906",
"0.65149903",
"0.64483434",
"0.6410244",
"0.6386181",
"0.6354036",
"0.6343934",
"0.63412344",
"0.6332881",
"0.6311104",
"0.6299738",
"0.62983704",
"0.62725866",
"0.62346876",
"0.62243366",
"0.61484414",
"0.61... | 0.7433807 | 0 |
Batch gradient descent for maximumlikelihood estimation | def fit(self, X, Y, lrate=0.01, training_steps=100, coeff_reg=0.1):#, batch_size=1):
num_instances = len(X)
num_features = len(X[0])
x = T.matrix("x")
y = T.vector("y")
w = theano.shared(np.random.random((num_features,)), name="w")
b = theano.shared(0., name="b")
#p = 1 / (1 + T.exp(-(T.do... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batchGradientDescent(x,y,theta,alpha):\n m,n = np.shape(x)\n xTran = x.transpose()\n convergence = 0.000000001\n lastCost = 0\n cost = -1 \n recurseCount = 0\n while abs(lastCost - cost) > convergence: # rcurse until converge\n lastCost = cost\n hypothesis = np.dot(x,theta... | [
"0.72205806",
"0.7206563",
"0.71251976",
"0.6894467",
"0.68875915",
"0.67967856",
"0.6775867",
"0.6730671",
"0.67216426",
"0.6704044",
"0.6699318",
"0.66864246",
"0.6653493",
"0.663533",
"0.6630918",
"0.6626834",
"0.66227376",
"0.66114336",
"0.6599626",
"0.6587141",
"0.657541... | 0.0 | -1 |
Create database VIEWS from files. | def add_views(apps, schema_editor):
connection = schema_editor.connection
with connection.cursor() as cur:
for view in reversed(OCP_ALL_VIEWS):
LOG.info(f"""Dropping materialized view "{view}" with cascade""")
cur.execute(f"""DROP MATERIALIZED VIEW "{view}" CASCADE;""")
for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export_sqlite_views(self):\r\n # Gather the names of report views in the db\r\n SQL_TRAN.execute(\"SELECT name FROM sqlite_master WHERE type='view'\")\r\n view_names = SQL_TRAN.fetchall()\r\n\r\n # Export report views to tsv files\r\n for i in view_names:\r\n\r\n q... | [
"0.6438778",
"0.6305463",
"0.6267813",
"0.61501664",
"0.57469606",
"0.57229686",
"0.5681535",
"0.56686246",
"0.56341827",
"0.5624621",
"0.5580693",
"0.55182123",
"0.5498059",
"0.5480512",
"0.54795283",
"0.54676986",
"0.5459569",
"0.54512936",
"0.5437881",
"0.54340816",
"0.541... | 0.5971611 | 4 |
Convert a caffe parameter name to a tensorflow parameter name as defined in the above model | def name_conversion(caffe_layer_name, prefix=''):
# beginning & end mapping
NAME_MAP = {
'bn_conv1/beta': 'conv0/BatchNorm/beta:0',
'bn_conv1/gamma': 'conv0/BatchNorm/gamma:0',
'bn_conv1/mean/EMA': 'conv0/BatchNorm/moving_mean:0',
'bn_conv1/variance/EMA': 'conv0/BatchNorm/moving_variance:0',... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eff_param():\n return r.TF1('photon_eff_param', eff_param_string(), 0, 7)",
"def _get_param_to_param_name(\n model: torch.nn.Module,\n) -> Dict[torch.nn.Parameter, str]:\n param_to_param_names = _get_param_to_unflat_param_names(model)\n for param_names in param_to_param_names.values():\n a... | [
"0.59476686",
"0.58388007",
"0.5772405",
"0.5701666",
"0.5692458",
"0.5617242",
"0.55691546",
"0.54260504",
"0.53634006",
"0.5344747",
"0.53117526",
"0.5303694",
"0.5301256",
"0.5296789",
"0.5279293",
"0.5278879",
"0.52710485",
"0.5232698",
"0.5229766",
"0.5218155",
"0.520569... | 0.6089701 | 1 |
Add missing padding to string and return the decoded base64 string. | def base64_decode(s):
log = logging.getLogger()
s = str(s).strip()
try:
return base64.b64decode(s)
except TypeError:
padding = len(s) % 4
if padding == 1:
log.error("Invalid base64 string: {}".format(s))
return ''
elif padding == 2:
s +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pad_base64_str(str):\n missing_padding = len(str) % 4\n if missing_padding != 0:\n str += '=' * (4 - missing_padding)\n return str",
"def decode_base64(data):\n missing_padding = 4 - len(data) % 4\n if missing_padding:\n data += b'='* missing_padding\n return base64.decodestri... | [
"0.806213",
"0.8022017",
"0.78917044",
"0.78661764",
"0.72686636",
"0.7100269",
"0.71000576",
"0.6996135",
"0.693596",
"0.6920945",
"0.6920945",
"0.6904011",
"0.68946016",
"0.68341017",
"0.6829386",
"0.6726214",
"0.6700636",
"0.6659003",
"0.66499424",
"0.65814054",
"0.6541725... | 0.7816081 | 4 |
Called by self._format_as(space), to check whether self and space have compatible sizes. Throws a ValueError if they don't. | def _check_sizes(self, space):
my_dimension = self.get_total_dimension()
other_dimension = space.get_total_dimension()
if my_dimension != other_dimension:
if isinstance(space, Conv2DSpace):
if my_dimension * space.shape[0] !=\
other_dimension:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_size(self):\n if self.type == 'grid':\n if not self.size:\n raise ChartError(\n \"Layout size must be set \"\n \"if layout type is 'grid'\")\n\n if len(self.size) != 2:\n raise ChartError('Layout size leng... | [
"0.6610175",
"0.6451334",
"0.6441938",
"0.640975",
"0.61760485",
"0.61393535",
"0.61014336",
"0.60155046",
"0.5922366",
"0.58863646",
"0.58730096",
"0.58581656",
"0.5849174",
"0.58366275",
"0.58356285",
"0.5833874",
"0.5824362",
"0.5816935",
"0.5773754",
"0.5703666",
"0.57024... | 0.76109046 | 0 |
CLI to collect random commits and analyze maintainability. | def tool(security_dataset, regular_dataset):
df = pd.read_csv(security_dataset)
add_random_regular_commits(df, regular_dataset) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n print(\"Hello World!!!\")\n print(\"Commit to DLNA\")\n print(\"Another commit\")\n print(\"Commit after PR merge\")",
"def main():\n# logging.basicConfig(level=logging.DEBUG)\n try:\n user = sys.ARGV[1]\n except:\n user = 'hmm01i'\n repos = getRepos(user)\n ... | [
"0.618323",
"0.60287666",
"0.5585191",
"0.55699843",
"0.5559813",
"0.5543677",
"0.5541772",
"0.5530489",
"0.5476184",
"0.5458055",
"0.54341",
"0.5431736",
"0.5429843",
"0.53909594",
"0.5388294",
"0.5387541",
"0.5365055",
"0.5360595",
"0.5360282",
"0.5360282",
"0.5341381",
"... | 0.6278088 | 0 |
Add refactoring commits in the dataset. | def add_random_regular_commits(rows, regular_dataset):
log.info(f"Will analyze {len(rows)} commits.")
for i, row in rows[~pd.notnull(rows['sha-reg'])][::-1].iterrows():
if 'random_commit' not in row.keys():
user = row['owner']
project = row['project']
with ghu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stage_changes(c):\n c.run(f\"git add -u\")",
"def tool(security_dataset, regular_dataset):\n df = pd.read_csv(security_dataset)\n add_random_regular_commits(df, regular_dataset)",
"def add_commit( self\n , cl\n , mark_number\n , parent_commit_list... | [
"0.6127678",
"0.5976285",
"0.56654656",
"0.553326",
"0.55086493",
"0.54893506",
"0.5359894",
"0.5359894",
"0.5341617",
"0.5340379",
"0.53341734",
"0.5282182",
"0.521549",
"0.5194299",
"0.51693976",
"0.51512754",
"0.5129469",
"0.5128068",
"0.5128068",
"0.5128068",
"0.5128068",... | 0.5277058 | 12 |
This is a utility function to obtain a bytefile from storage and load it into memory. | def get_pickle_file(file_name):
# change directory
os.chdir("../")
os.chdir("data")
# pickle activities
f = open(file_name, "rb")
python_data = pickle.load(f)
f.close()
# change directory
# change directory
os.chdir("../")
os.chdir("pathfinder")
return python_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cached_load(filepath: str) -> io.BytesIO:\n with open(filepath, 'rb') as f:\n return io.BytesIO(f.read())",
"def bz2_file_bytes_reader(path):\n return bz2.open(path, 'rb')",
"def read_as_bytes(filename):\n try:\n with open(filename, \"rb\") as file:\n bytes = a... | [
"0.68174493",
"0.6185826",
"0.6098357",
"0.6079456",
"0.6040377",
"0.6038012",
"0.6038012",
"0.60342246",
"0.59672946",
"0.59166515",
"0.5906796",
"0.58646876",
"0.5849056",
"0.58230805",
"0.5773357",
"0.5756768",
"0.5738463",
"0.57284206",
"0.57050073",
"0.5650204",
"0.56099... | 0.0 | -1 |
Return boxes with a confidence >= `min_score` | def filter_boxes(min_score, boxes, scores, classes):
n = len(classes)
idxs = []
for i in range(n):
if scores[i] >= min_score:
idxs.append(i)
filtered_boxes = boxes[idxs, ...]
filtered_scores = scores[idxs, ...]
filtered_classes = classes[idxs, ...]
return filtered_bo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_boxes(self, min_score, boxes, scores, classes):\n n = len(classes)\n idxs = []\n for i in range(n):\n if scores[i] >= min_score:\n idxs.append(i)\n \n filtered_boxes = boxes[idxs, ...]\n filtered_scores = scores[idxs, ...]\n filt... | [
"0.7317321",
"0.72855526",
"0.72492224",
"0.72279024",
"0.6647105",
"0.6314491",
"0.63112724",
"0.61915874",
"0.6165219",
"0.61569124",
"0.6156313",
"0.61135215",
"0.6062302",
"0.5995685",
"0.59620845",
"0.5960607",
"0.5950879",
"0.59485",
"0.5940718",
"0.5940718",
"0.5936835... | 0.72886777 | 1 |
The original box coordinate output is normalized, i.e [0, 1]. This converts it back to the original coordinate based on the image size. | def to_image_coords(boxes, height, width):
box_coords = np.zeros_like(boxes)
box_coords[:, 0] = boxes[:, 0] * height
box_coords[:, 1] = boxes[:, 1] * width
box_coords[:, 2] = boxes[:, 2] * height
box_coords[:, 3] = boxes[:, 3] * width
return box_coords | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __normalizeBox(self):\n self.currentBox = normalizeBox(self.currentBox)",
"def normalizeBox(box):\n x, y, w, h = box\n if w < 0:\n x += (w+1)\n w *= -1\n if h < 0:\n y += (h+1)\n h *= -1\n return (x, y, w, h)",
"def _normalize(self, x):\n # TODO: imagen... | [
"0.7233279",
"0.69938886",
"0.6768024",
"0.67188823",
"0.6718466",
"0.66769713",
"0.6532776",
"0.6505893",
"0.6494021",
"0.63477725",
"0.6327291",
"0.62319106",
"0.6229367",
"0.62115335",
"0.6191667",
"0.6175719",
"0.6174944",
"0.61304796",
"0.6116588",
"0.6073716",
"0.607182... | 0.0 | -1 |
Draw bounding boxes on the image | def draw_boxes(image, boxes, classes, thickness=4):
draw = ImageDraw.Draw(image)
for i in range(len(boxes)):
bot, left, top, right = boxes[i, ...]
class_id = int(classes[i])
color = 'blueviolet'
draw.line([(left, top), (left, bot), (right, bot), (right, top), (left, top)], width=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_bounding_boxes(self, image_path):\n img = cv.imread(image_path, cv.IMREAD_ANYDEPTH)\n bboxes = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\n unique, counts = np.unique(img, return_counts=True)\n for uni in unique:\n if uni == 0:\n continu... | [
"0.80207103",
"0.7730494",
"0.7663894",
"0.75815976",
"0.75812364",
"0.7569874",
"0.7564505",
"0.7560773",
"0.74707085",
"0.74676245",
"0.7462541",
"0.7429634",
"0.7386207",
"0.73359627",
"0.73075604",
"0.73066705",
"0.73026776",
"0.72940755",
"0.7275691",
"0.72722554",
"0.72... | 0.0 | -1 |
Loads a frozen inference graph | def load_graph(graph_file):
graph = tf.Graph()
with graph.as_default():
od_graph_def = tf.compat.v1.GraphDef()
with tf.io.gfile.GFile(graph_file, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_frozen_graph(frozen_graph_path, graph=None, session=None):\n from diplomacy_research.utils.tensorflow import tf, tf_logging\n\n # Making sure the path exists\n if not os.path.exists(frozen_graph_path):\n LOGGER.error('The frozen graph %s does not exist.', frozen_graph_path)\n raise ... | [
"0.7145618",
"0.71300054",
"0.6952633",
"0.64996564",
"0.6480352",
"0.64554673",
"0.6437847",
"0.6419772",
"0.6419772",
"0.63925844",
"0.638914",
"0.63779676",
"0.6364601",
"0.6306616",
"0.6300151",
"0.627973",
"0.6269959",
"0.6266776",
"0.6258529",
"0.62003803",
"0.6152927",... | 0.60229445 | 30 |
Read through a ped/samples file and get the names of the cases and controls. | def getCaseAndControlListsFromPedFile(pedFilePath):
CASE = "2"
CONTROL = "1"
statusIndex = 5
nameIndex = 1
names = defaultdict(list)
with open(pedFilePath, "r") as samples:
for sample in samples:
names[sample.split("\t")[statusIndex]].append(sample.split("\t")[nameIndex]) # The second spot is the ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def samples():\n f = open(config['samples'], \"r\")\n samp=[]\n for line in f:\n samp.append(line.strip().split()[0])\n return samp",
"def read_file(testing_file):\n samples = []\n with open(testing_file, 'r') as in_file:\n for line in in_file:\n info = line.strip('\\n'... | [
"0.63636255",
"0.6313014",
"0.61136013",
"0.59631413",
"0.56838787",
"0.56684047",
"0.56344813",
"0.5632566",
"0.5621312",
"0.5583971",
"0.55766374",
"0.55750257",
"0.55492824",
"0.55484843",
"0.55387455",
"0.5510029",
"0.5475519",
"0.5473172",
"0.5460236",
"0.5412151",
"0.54... | 0.6725174 | 0 |
Read through the first two lines of a _genotypes file and calculate how many total cases and controls were in the initial ATAV job. (If a sample does not have a variant, they won't show up in the file, so this total needs to be calculated separately.) | def getTotalCaseAndControlCounts(genotypesFilename):
comphetSuffix = ""
if "comphet" in genotypesFilename:
comphetSuffix = " (#1)"
# We read through the whole file. Might take a while, but easier than dealing with all edge cases.
maxCoveredCasePercentage = 0
maxCoveredControlPercentage = 0
reader = c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_total(self):\n total = 0\n rpk_total = 0.0\n with open(self.filename, 'rU') as my_htseq:\n for line in my_htseq:\n if '_' not in line:\n line = line.rstrip('\\n').split('\\t')\n ensg_id = line[0]\n gen... | [
"0.62967587",
"0.6293312",
"0.6029363",
"0.6015871",
"0.5913728",
"0.58160174",
"0.5763021",
"0.5732417",
"0.57178193",
"0.56836647",
"0.56249833",
"0.5541682",
"0.5532769",
"0.5515604",
"0.55022156",
"0.5498849",
"0.5483801",
"0.54305834",
"0.5416177",
"0.5402783",
"0.538538... | 0.7090837 | 0 |
Read through a genotypes file and get the number of QVs per sample. | def getQVcounts(genotypesFilename, caseNames, controlNames):
if "genotypes" in genotypesFilename:
caseCounts, controlCounts = getQVcountsForDominantModel(genotypesFilename, caseNames, controlNames)
elif "comphet" in genotypesFilename:
caseCounts, controlCounts = getQVsForComphetModel(genotypesFilename, case... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n(self):\n return len(self.genotypes)",
"def countgenes():\n directory = openfile('db_directory.txt')\n no_genes_file = directory+'GENES_IN_HPO.txt'\n GENES_IN_HPO = openfile(no_genes_file)\n #GENES_IN_HPO = openfile(numbergenes_file)\n return int(GENES_IN_HPO)",
"def populate(infile,... | [
"0.6377052",
"0.61921424",
"0.6050802",
"0.5921395",
"0.57854915",
"0.5723797",
"0.5702904",
"0.56815153",
"0.5647343",
"0.5629553",
"0.55353963",
"0.55299056",
"0.54956543",
"0.548101",
"0.5472195",
"0.5413845",
"0.54131746",
"0.53874993",
"0.5385036",
"0.53508884",
"0.53467... | 0.62267786 | 1 |
Read through a _genotypes file and get the variant counts for all samples, broken down into cases and controls. | def getQVcountsForDominantModel(genotypesFilename, caseNames, controlNames):
# If we have a sample file, then we have everyone's names:
if len(caseNames) != 0 or len(controlNames) != 0:
caseCounts = {name: 0 for name in caseNames}
controlCounts = {name: 0 for name in controlNames}
counts = {"case": cas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_genotypes(self, samples, records, switch):\n\n variant = np.zeros(len(samples))\n for idx, sample in enumerate(samples):\n try:\n gt = records.genotype(sample)['GT']\n except IndexError:\n print(\"something went wrong with:\")\n ... | [
"0.67506015",
"0.6729951",
"0.64543974",
"0.6217519",
"0.5930664",
"0.5902287",
"0.58747613",
"0.5775546",
"0.5687666",
"0.5658399",
"0.55744815",
"0.55508137",
"0.5545412",
"0.5542533",
"0.5530825",
"0.5470585",
"0.54633224",
"0.5454796",
"0.54509187",
"0.5425045",
"0.539496... | 0.6443562 | 3 |
Read through a _comphet file and get the variant counts for all samples, broken down into cases and controls. If a sample has 2 variants in one gene, they'll be printed to the same line as "Variant (1)" and "Variant (2)". | def getQVsForComphetModel(comphetVariantsFilename, caseNames, controlNames):
# If we have a sample file, then we have everyone's names:
if len(caseNames) != 0 or len(controlNames) != 0:
caseCounts = {name: set() for name in caseNames}
controlCounts = {name: set() for name in controlNames}
variantIDs ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTotalCaseAndControlCounts(genotypesFilename):\r\n\r\n\tcomphetSuffix = \"\"\r\n\tif \"comphet\" in genotypesFilename:\r\n\t\tcomphetSuffix = \" (#1)\"\r\n\r\n\t# We read through the whole file. Might take a while, but easier than dealing with all edge cases.\r\n\tmaxCoveredCasePercentage = 0\r\n\tmaxCovered... | [
"0.6928196",
"0.625293",
"0.58950937",
"0.58474743",
"0.5823805",
"0.56312484",
"0.5608807",
"0.5597664",
"0.5558391",
"0.55020434",
"0.54880935",
"0.5404076",
"0.53877914",
"0.53493875",
"0.53344697",
"0.52961344",
"0.5296094",
"0.5268602",
"0.5253312",
"0.52310175",
"0.5185... | 0.6625952 | 1 |
Our general logger function. | def writeToLog(logName, message, writeOrAppend):
with open(logName, writeOrAppend) as out:
out.write(message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_logger(self):",
"def logger(self):\n pass",
"def log(self, message):",
"def log(self, level, msg, *args, **kwargs):\n pass",
"def build_logger(self):\n pass",
"def log(self, message: str):",
"def _log(self, message):\n pass",
"def _log_some_info(self):\n loggin... | [
"0.76633245",
"0.7640444",
"0.73370457",
"0.7284354",
"0.72126675",
"0.7195057",
"0.71616554",
"0.71473765",
"0.7031027",
"0.6963027",
"0.6950897",
"0.69403726",
"0.6933146",
"0.68858904",
"0.68542427",
"0.6837671",
"0.6836879",
"0.6833609",
"0.6813234",
"0.6787216",
"0.67616... | 0.0 | -1 |
Write out the sample name and the number of QVs they have to a log. | def writeOutQVcounts(qvCountsLogName, casesToTheirQVcounts, controlsToTheirQVcounts, missingCases, missingControls):
log = ""
if missingCases > 0 or missingControls > 0:
log += "### A sample file may have not been submitted, and so there are some samples that do not have\n"
log += "### any QVs, but we don't... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_log(self, step, data=None):\n \n # Set mode to append to log file\n mode = 'a'\n\n if self.logfile is None:\n # Increment log counter for the class. Each instance of the class generates a new log.\n self.__class__.log_no += 1\n\n # Create a lo... | [
"0.60270923",
"0.5782031",
"0.57312113",
"0.5726678",
"0.57149386",
"0.557019",
"0.55264795",
"0.5509941",
"0.54832083",
"0.5469556",
"0.54433197",
"0.5429885",
"0.5374645",
"0.5369299",
"0.53379154",
"0.5330904",
"0.5304008",
"0.5279867",
"0.52705723",
"0.52650094",
"0.52610... | 0.6655646 | 0 |
Run Mann Whitney and write out the results. | def runMannWhitney(mannWhitneyLogName, qvsPerCase, qvsPerControl):
log = ""
log += "Checking amounts of found variants for cases vs. controls. Date: {}.\n".format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
log += "Cases (n = {}): Median: {}; mean: {}.\n".format(len(qvsPerCase), np.median(qvsPerCase), n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mann_whitney(_sample_a, _sample_b):\n res = stats.mannwhitneyu(_sample_a, _sample_b, use_continuity=True)\n print('Mann-Whitney rank test\\nU-statistic: {}\\np-value: {}'.format(res[0], res[1]))\n print('-' * 10)",
"def mann_whitney_plus_means(turnstile_weather):\n with_rain = turnst... | [
"0.6443433",
"0.62065065",
"0.6126351",
"0.60448587",
"0.58548564",
"0.55368865",
"0.552356",
"0.52770686",
"0.5268584",
"0.5214635",
"0.5069704",
"0.5024073",
"0.49422473",
"0.49388117",
"0.49314013",
"0.4907475",
"0.4886257",
"0.48828724",
"0.4872175",
"0.48712775",
"0.4866... | 0.6721948 | 0 |
Create and plot a histogram of variant counts, broken into cases and controls. | def graphQVcounts(caseCounts, controlCounts, outputName):
plt.figure(1)
caseCounter = Counter(caseCounts)
controlCounter = Counter(controlCounts)
totalCases = float(len(caseCounts))
totalControls = float(len(controlCounts))
plt.bar(caseCounter.keys(), np.array(caseCounter.values())/totalCases, facec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hist_qual(self, fontsize=16, bins=100):\n self.rewind()\n data = [x.QUAL for x in self._vcf_reader]\n pylab.hist(data, bins=bins)\n pylab.grid(True)\n pylab.xlabel(\"Variant quality\", fontsize=fontsize)",
"def generate_counthist(counts, label, view_lim=[1e-6,1e0,1e0,1e5]):... | [
"0.639714",
"0.6303354",
"0.6291766",
"0.61522007",
"0.6151823",
"0.61423516",
"0.6139937",
"0.60908663",
"0.6076454",
"0.6051278",
"0.6031893",
"0.595742",
"0.5954826",
"0.5929051",
"0.5881224",
"0.5870992",
"0.5846922",
"0.58407176",
"0.5829935",
"0.5828306",
"0.5822304",
... | 0.65548986 | 0 |
Parses the arguments of the program | def parse_user_arguments(*args, **kwds):
parser = argparse.ArgumentParser(
description = "Predict if a pair of drugs is a drug combination",
epilog = "@oliva's lab 2017")
parser.add_argument('-d1','--drug_name1',dest='drug_name1',action = 'store',
help = """ Name of... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parseArguments(self):\n iterator = iter(sys.argv[1:]) # Skip file name\n for argument in iterator:\n if len(argument) < 2 or argument[:2] != '--':\n self.error('syntax error \"{}\"'.format(argument))\n else:\n de... | [
"0.82726073",
"0.75477016",
"0.75268954",
"0.74781555",
"0.74548787",
"0.73958445",
"0.7384183",
"0.7330172",
"0.7327063",
"0.72733825",
"0.7226752",
"0.72222376",
"0.7221101",
"0.7219167",
"0.72155046",
"0.718937",
"0.7186559",
"0.7163097",
"0.7151462",
"0.7149633",
"0.71457... | 0.0 | -1 |
Predicts if a pair of drugs is a drug combination | def predict(options):
# Start marker for time measure
start = time.time()
print("\n\t\t------------------------------------------------------------------------------------------------------\n")
print("\t\tStarting Drug Interactions ANAlysis (DIANA), a program created by @OLIVA'S LAB. Third part: Predi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coxen_multi_drug_gene_selection(\n source_data,\n target_data,\n drug_response_data,\n drug_response_col,\n tumor_col,\n drug_col,\n prediction_power_measure=\"lm\",\n num_predictive_gene=100,\n generalization_power_measure=\"ccc\",\n num_generalizable_gene=50,\n union_of_singl... | [
"0.5656811",
"0.53940845",
"0.53094256",
"0.5222329",
"0.51587594",
"0.5060356",
"0.5006437",
"0.4997518",
"0.4978938",
"0.49725336",
"0.49702358",
"0.49521005",
"0.49268988",
"0.4919356",
"0.49191993",
"0.49191785",
"0.49171874",
"0.49169835",
"0.49162063",
"0.4881673",
"0.4... | 0.48015535 | 32 |
Starts a watchfolder in the user's iCloud directory | def do_start_icloud(self, args):
args = self.parse_arguments(args)
plat = get_local_platform_routines()
user = LocalUserRoutines(plat)
home_dir = user.get_home_dir()
icloud_dir = os.path.join(home_dir, "iCloudDrive", "fiepipe_watch")
if not os.path.exists(icloud_dir... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self):\n try:\n self.getEverything()\n self._watchFolder()\n except Unauthorized, e:\n self.authorize()\n self.start()\n \n #TODO: make this work\n #self._setPeriodicSync()\n \n print 'stopped'",
"def _watchFol... | [
"0.6660409",
"0.63080263",
"0.60288143",
"0.587695",
"0.57806844",
"0.577429",
"0.56855834",
"0.5651817",
"0.546844",
"0.54465985",
"0.54192054",
"0.5416022",
"0.5339537",
"0.5321164",
"0.52857655",
"0.5200085",
"0.51923317",
"0.5147048",
"0.50987595",
"0.50855106",
"0.507541... | 0.669887 | 0 |
Starts a watchfolder in the user's Documents directory | def do_start_documents(self, args):
args = self.parse_arguments(args)
plat = get_local_platform_routines()
user = LocalUserRoutines(plat)
home_dir = user.get_home_dir()
docs_dir = os.path.join(home_dir, "Documents", "fiepipe_watch")
if not os.path.exists(docs_dir):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _watchFolder(self):\n wm = pyinotify.WatchManager()\n wm.add_watch(self.gdocs_folder, pyinotify.IN_MODIFY, rec=True)\n \n handler = EventHandler(self)\n notifier = pyinotify.Notifier(wm, handler)\n \n print 'waiting for changes . . .'\n notifier.loop()",
... | [
"0.71423084",
"0.6504502",
"0.6461225",
"0.62531656",
"0.62520504",
"0.59916514",
"0.5971321",
"0.5947779",
"0.58603346",
"0.57456636",
"0.5725944",
"0.5721107",
"0.56487375",
"0.55851334",
"0.5476341",
"0.54706573",
"0.54611844",
"0.5439405",
"0.53978366",
"0.5392165",
"0.53... | 0.66735244 | 1 |
Starts a named watchfolder in a given directory | def do_start(self, args):
args = self.parse_arguments(args)
if len(args) < 1:
self.perror("No name given.")
return
if len(args) < 2:
self.perror("No path given.")
return
name = args[0]
path = args[1]
if name in self._wat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(dir_to_watch):\n event_handler = AudioCreatedHandler()\n observer = Observer()\n observer.schedule(event_handler, dir_to_watch, recursive=True)\n observer.start()\n try:\n while True:\n time.sleep(1) \n except KeyboardInterrupt:\n print \"Stopping...\"\n ... | [
"0.6714537",
"0.66689855",
"0.6548735",
"0.6480822",
"0.63712686",
"0.6312195",
"0.6257685",
"0.6201636",
"0.61205935",
"0.611318",
"0.6073615",
"0.6034104",
"0.5983241",
"0.5969944",
"0.5909975",
"0.58480537",
"0.57867706",
"0.5744905",
"0.569635",
"0.56687886",
"0.56275433"... | 0.6300915 | 6 |
Runs R correlation calculations and pvalue corrections on the given dataframe. | def run_r_corr(df, corr_type='spearman', p_correction='BH'):
num_cols = len(df.columns.values)
r_dataframe = pandas2ri.py2ri(df)
r_as = r['as.matrix']
rcorr = r['rcorr']
r_p_adjust = r['p.adjust']
result = rcorr(r_as(r_dataframe), type=corr_type)
rho = result[0]
n = result[1]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def df_corr(df, method=\"pearson\", min_periods=1):\n op = DataFrameCorr(method=method, min_periods=min_periods)\n return op(df)",
"def df_corrwith(df, other, axis=0, drop=False, method=\"pearson\"):\n axis = validate_axis(axis, df)\n if drop:\n # TODO implement with df.align(method='inner')\n... | [
"0.67682356",
"0.6436532",
"0.6363697",
"0.625707",
"0.6251887",
"0.61984104",
"0.6184104",
"0.61419874",
"0.61195624",
"0.6110142",
"0.61037296",
"0.61014676",
"0.60986847",
"0.6088977",
"0.60165393",
"0.6007464",
"0.59634864",
"0.5930247",
"0.5885391",
"0.5870298",
"0.58694... | 0.8098069 | 0 |
returns the matplotlib plt object for the specified correlations. | def build_corr_mat(corrs, p_vals, labels, title, alpha):
plt.rcParams["figure.figsize"] = [20,12]
plt.imshow(corrs)
for i in range(len(labels)):
for j in range(len(labels)):
text = "{0:.2f}".format(r_corrs[i, j])
p = p_vals[i,j]
if p < alpha / len(labels):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_corr_plot():\r\n fig = plt.figure(figsize=(12, 12))\r\n ax = fig.add_subplot",
"def correlations(self, data,label, **kwds):\n corrmat = data.corr(**kwds)\n\n fig, ax1 = plt.subplots(ncols=1, figsize=(6,5))\n\n opts = {'cmap': plt.get_cmap(\"RdBu\"),\n 'vmin': -... | [
"0.68624145",
"0.6416293",
"0.630825",
"0.62502193",
"0.62021136",
"0.6112833",
"0.6112833",
"0.6105096",
"0.61047894",
"0.60861915",
"0.6000319",
"0.5963655",
"0.5898949",
"0.58250797",
"0.58071315",
"0.57193774",
"0.571394",
"0.5691973",
"0.5680117",
"0.565944",
"0.56465924... | 0.53622854 | 49 |
Returns dataframe of features significantly correlated with the target variable. | def get_sig_features(cols, target, corrs, p_vals, exclude_cols=[], alpha=0.05):
idx = np.where(cols == target)
sel_corrs = corrs[idx]
sel_p_vals = p_vals[idx]
sel_stats = np.transpose(np.vstack((sel_corrs, sel_p_vals)))
sel_df = pd.DataFrame(sel_stats, index=cols, columns=['corr', 'p'])
si... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_feature_corr(self):\n \n return self.train_data.astype(float).corr(method='kendall')",
"def calculate_correlation(df, vars_to_corr, target_var) :\n\n\n mean = df[target_var].mean()\n sigma = df[target_var].std()\n\n correlation = []\n error = []\n\n for j in vars_to_cor... | [
"0.65806085",
"0.6303217",
"0.5886798",
"0.5873877",
"0.5863441",
"0.5858851",
"0.5834802",
"0.5786022",
"0.5741659",
"0.56739926",
"0.5565418",
"0.5546522",
"0.5505434",
"0.55022067",
"0.54964596",
"0.54573977",
"0.5441468",
"0.54347897",
"0.54161024",
"0.5409365",
"0.539591... | 0.5719083 | 9 |
Generate yaml test cases from the yaml files in the given directory | def generate_yaml_tests(directory):
for yml_file in directory.glob("*/*.yml"):
data = yaml.safe_load(yml_file.read_text())
assert "cases" in data, "A fixture needs cases to be used in testing"
# Strip the parts of the directory to only get a name without
# extension and resolver dir... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_yaml_tests(directory):\n for yml_file in directory.glob(\"*.yml\"):\n data = yaml.safe_load(yml_file.read_text())\n assert \"cases\" in data, \"A fixture needs cases to be used in testing\"\n\n # Strip the parts of the directory to only get a name without\n # extension a... | [
"0.81488127",
"0.7012131",
"0.6698927",
"0.66773045",
"0.6447837",
"0.63057554",
"0.627959",
"0.6240237",
"0.6215887",
"0.6164365",
"0.609653",
"0.60548806",
"0.6040794",
"0.6032984",
"0.5965803",
"0.59477776",
"0.5941153",
"0.5919988",
"0.5910295",
"0.5891571",
"0.58607346",... | 0.8186191 | 0 |
Give a nice parameter name to the generated function parameters | def id_func(param):
if isinstance(param, dict) and ":name:" in param:
return param[":name:"]
retval = str(param)
if len(retval) > 25:
retval = retval[:20] + "..." + retval[-2:]
return retval | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def function_name(parameters):",
"def _name_from_args(func, _, params):\n return \"{}_{}\".format(func.__name__, \"_\".join(str(arg) for arg in params.args))",
"def _formal_params(self, doclet):\n name, paren, params = self.arguments[0].partition('(')\n return ('(%s' % params) if param... | [
"0.75918895",
"0.7188827",
"0.70072734",
"0.6688677",
"0.6679166",
"0.66557956",
"0.6603848",
"0.6521158",
"0.6502662",
"0.6339839",
"0.6331608",
"0.6301998",
"0.62911433",
"0.62872463",
"0.6281126",
"0.6255605",
"0.62299716",
"0.6222758",
"0.62045634",
"0.61936885",
"0.61494... | 0.6672928 | 5 |
Creates directory if not exists | def mkdir(dirName):
raw = 'mockaroo_data/raw/' + dirName
cln = 'mockaroo_data/cln/' + dirName
call(['mkdir', raw])
call(['mkdir', cln])
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_dir(self):\n if not os.path.exists(self.d):\n try:\n os.mkdir(self.d)\n except OSError, e:\n if e.errno != 17:\n raise\n pass",
"def create_dir(path):\n if not os.path.exists(path):\n os.makedirs(path)... | [
"0.83656484",
"0.834942",
"0.82707036",
"0.82707036",
"0.82600933",
"0.8223895",
"0.82130796",
"0.82078326",
"0.82049537",
"0.8204173",
"0.8199202",
"0.8157144",
"0.8146599",
"0.81431687",
"0.81396705",
"0.8137432",
"0.8130188",
"0.8127501",
"0.8105457",
"0.80995184",
"0.8095... | 0.0 | -1 |
Creates an inline LOAD_ATTR call, using a validator. | def attr(self, attr: _PyteAugmentedValidator):
# Use the __override_opcode param and __override_list_restriction
return _AttrLoader(self, attr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visit_Attribute(self, node):\n self.generic_visit(node)\n if isinstance(node.ctx, ast.Load):\n args = [ node.value, ast.Str(node.attr) ]\n return to_call(to_name('getattr'), args)\n return node",
"def loader_for_attribute(self, attribute):\n return lambda x: ... | [
"0.5518646",
"0.53865415",
"0.53345865",
"0.528758",
"0.51410544",
"0.50560033",
"0.5017652",
"0.4997242",
"0.4987636",
"0.4981382",
"0.48947912",
"0.48831546",
"0.48165223",
"0.47417164",
"0.4713835",
"0.4696541",
"0.4672414",
"0.46377176",
"0.46348855",
"0.4614697",
"0.4609... | 0.6687772 | 0 |
Add an attribute to the chain of attributes to load. | def attr(self, item: _PyteAugmentedValidator):
self._attrs.append(item)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_attribute(self, attr):\n self.attrs.add_attribute(attr)",
"def add_attribute(self, attr):\n self.add(attr)",
"def add_attribute(self, attr):\n self.attrs.add(attr)",
"def add_attribute(self, attr: ResourceAttributeDescriptor) -> None:\n self._attributes[assert_not_none(att... | [
"0.7693865",
"0.76586586",
"0.75456613",
"0.7126628",
"0.70298725",
"0.6939387",
"0.6719474",
"0.67137754",
"0.6698703",
"0.66245776",
"0.65580535",
"0.6553192",
"0.6553192",
"0.6553192",
"0.6502369",
"0.65008056",
"0.6477134",
"0.6433667",
"0.6418253",
"0.6397711",
"0.637903... | 0.5912731 | 46 |
A method running a allreduce operation in a data parallel group. | def handle_gradient(self):
self._optimizer.sync_grad() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_run():",
"def ol_mpi_allreduce(data, operator: Union[int, str, None] = None):\n import numba_mpi\n\n if operator is None or isinstance(operator, nb.types.NoneType):\n op_id = -1 # value will not be used\n elif isinstance(operator, nb.types.misc.StringLiteral):\n op_id = Operato... | [
"0.6912629",
"0.67692804",
"0.66038615",
"0.60643405",
"0.5996911",
"0.59751207",
"0.59230024",
"0.5809717",
"0.5766782",
"0.5738034",
"0.5723741",
"0.56574804",
"0.5656459",
"0.5588614",
"0.55475324",
"0.553867",
"0.55309284",
"0.55309284",
"0.55309284",
"0.55309284",
"0.553... | 0.0 | -1 |
Parse rule about what child bags a parent bag can contain | def parse_rule(line):
parent, children_str = line.strip().split(" bags contain ")
children = {}
for child in children_str.split(", "):
match = re.match(r"(?P<quantity>\d+) (?P<color>.+?) bag", child)
if match:
children[match.group("color")] = int(match.group("quantity"))
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test__findChildBags(self):\n file = \"\"\"\n shiny gold bags contain 2 dark red bags.\n dark red bags contain 2 dark orange bags.\n dark orange bags contain 2 dark yellow bags.\n dark yellow bags contain 2 dark green bags.\n dark green bags contain 2 dark blue bags.\n dark blue bags contai... | [
"0.6878267",
"0.6853976",
"0.6154937",
"0.61455214",
"0.5890407",
"0.5784656",
"0.5481967",
"0.5432812",
"0.53975284",
"0.53018963",
"0.528658",
"0.517007",
"0.51429975",
"0.51294297",
"0.51093775",
"0.51039433",
"0.4958595",
"0.49047592",
"0.48926118",
"0.4822519",
"0.480323... | 0.6862749 | 1 |
Gets lists of lists of SubContour objects from a watershed array using ImageContour | def GetSubContoursByFrame(watershed, allValsByFrame):
scListByFrame = []
for frame in range(len(watershed)):
scList = []
for v in allValsByFrame[frame]:
boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)
# No longer needed: #contour,turns,vals = ImageContour... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def detect_contours(self):\r\n (contours, _) = cv2.findContours(self.image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\r\n return [DbugContour(cv_contour=contour) for contour in contours]",
"def contour_ice(dataarray):\n contours = dataarray.plot.contourf(vmin=0, vmax=100, levels=5)\n ... | [
"0.6358348",
"0.62865835",
"0.61682415",
"0.61467576",
"0.6096353",
"0.60877997",
"0.6076599",
"0.60685176",
"0.6063275",
"0.6045179",
"0.6035992",
"0.6009514",
"0.59757787",
"0.5924858",
"0.5912952",
"0.5906821",
"0.5885125",
"0.5875746",
"0.5873737",
"0.5834278",
"0.5828782... | 0.6689849 | 0 |
Gets lists of lists of CVLS's from a watershed array use GetSubContoursByFrame instead! | def GetContourValuesLengthsAndSubContoursByFrame(watershed, allValsByFrame):
return [
[sc.cVLS() for sc in scList]
for scList in GetSubContoursByFrame(watershed, allValsByFrame)
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = I... | [
"0.75937665",
"0.6507299",
"0.6484516",
"0.6458244",
"0.6308807",
"0.62851155",
"0.6266374",
"0.62063503",
"0.60648507",
"0.59767586",
"0.5921466",
"0.5914407",
"0.5904614",
"0.58996433",
"0.58695424",
"0.58617276",
"0.5860281",
"0.584063",
"0.577641",
"0.5762255",
"0.5724690... | 0.6806032 | 1 |
Identify every contour in the watershed segmentation for each frame as defined by each pair of cell IDs (vals). Also, return the order of contours that is needed to reconstruct the border surrounding each cell. | def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):
cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)
scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]
orderOfSCsByValueByFrame = [
cellNetworkList[i].orderOfSubContoursDict for i in range(l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = I... | [
"0.682303",
"0.62864244",
"0.6280185",
"0.60297304",
"0.59573025",
"0.5944612",
"0.58334446",
"0.57923675",
"0.5783148",
"0.5739409",
"0.56378686",
"0.55968744",
"0.5590528",
"0.55639815",
"0.5518648",
"0.54740554",
"0.5468312",
"0.5427046",
"0.5407643",
"0.5381385",
"0.53796... | 0.6968971 | 0 |
Identify every contour in the watershed segmentation for each frame as defined by each pair of cell IDs (vals). Also, return the order of contours that is needed to reconstruct the border surrounding each cell. DEPRECATED, use GetSubContoursAndOrderingByFrame instead! | def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(
watershed, allValsByFrame
):
scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(
watershed, allValsByFrame
)
cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]
return cVLSByFr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetSubContoursAndOrderingByFrame(watershed, allValsByFrame):\n cellNetworkList = GetCellNetworksByFrame(watershed, allValsByFrame)\n scListByFrame = [cellNetworkList[i].subContours for i in range(len(watershed))]\n orderOfSCsByValueByFrame = [\n cellNetworkList[i].orderOfSubContoursDict for i i... | [
"0.7544308",
"0.72690433",
"0.6326455",
"0.6134341",
"0.6090655",
"0.60881174",
"0.60103273",
"0.59323454",
"0.589878",
"0.5895224",
"0.5728049",
"0.5722162",
"0.5446987",
"0.54307616",
"0.53550386",
"0.5353401",
"0.5350056",
"0.53280115",
"0.53188914",
"0.5309465",
"0.529283... | 0.6577085 | 2 |
Turn a cVLS into a list of points (xyList) and a dictionary of index lists (into xyList) with cellID keys (polyList) polyList basically contains the information that reconstructs each individual contour from points Appends the first point to the end of each list to close the loop and makes plotting cleaner, but be caut... | def GetXYListAndPolyListFromCVLS(cVLS, allValsByFrame, orderOfSCsByValueByFrame):
numFrames = len(cVLS)
xyList = [
sorted(list(set(tuple(pt) for c in cvlsByVal for pt in c[2])))
for cvlsByVal in cVLS
]
polyList = []
for t in range(numFrames):
polyList.append({})
for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def individual_plot(z, cf_lvls, cl_lvls, cline_label_format=cline_label_format_default, log_scale=False ,\n extend=\"neither\"):\n map_plot.drawcoastlines(linewidth=.4)\n\n if log_scale:\n norm = colors.LogNorm(vmin=cf_lvls[0], vmax=cf_lvls[-1])\n else:\n norm = None\n\n ... | [
"0.57014245",
"0.5649377",
"0.56392044",
"0.55886257",
"0.5495664",
"0.54937655",
"0.5468166",
"0.54670477",
"0.54585874",
"0.5396782",
"0.5394453",
"0.5374216",
"0.53528965",
"0.5322514",
"0.53171647",
"0.5304197",
"0.5300245",
"0.52861774",
"0.52711666",
"0.526915",
"0.5230... | 0.6929526 | 0 |
Operates INPLACE, so use cautiously... | def LimitPointsBetweenSubContourNodes(scList, numInteriorPointsDict, interpolate=True):
limIntPtsFunc = (
limitInteriorPointsInterpolating if interpolate else limitInteriorPoints
)
for sc in scList:
sc.points = limIntPtsFunc(sc.points, numInteriorPointsDict[tuple(sc.values)]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mod_inplace(a, b):",
"def add_inplace(a, b):",
"def psi_inplace(a):",
"def second_inplace(a):",
"def mul_inplace(a, b):",
"def le_inplace(a,b):",
"def sub_inplace(a, b):",
"def or__inplace(a,b):",
"def inv_inplace(a):",
"def sgn_inplace(a):",
"def exp_inplace(a):",
"def ge_inplace(a,b):",... | [
"0.6320513",
"0.63055974",
"0.6295562",
"0.6247203",
"0.6221748",
"0.61597484",
"0.6049256",
"0.60334474",
"0.6032077",
"0.5932389",
"0.5925243",
"0.5923073",
"0.5862695",
"0.58618164",
"0.58565295",
"0.5828316",
"0.5803157",
"0.5762689",
"0.5715238",
"0.56960684",
"0.5693837... | 0.0 | -1 |
Return a copy of the cVLS, but trim some points between triple junctions using one of several approaches. | def GetCVLSWithLimitedPointsBetweenNodes(
cVLS, allValsByFrame, splitLength=1, fixedNumInteriorPoints=None, interpolate=True
):
allValues = list(set(tuple(flatten(allValsByFrame))))
allPairs = sorted(
list(set([tuple(c[0]) for cVLSByFrame in cVLS for c in cVLSByFrame]))
) # Value pairs...
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decomposing_line_cut_by_splicing(P, v, w):\n\n\n\tv_Point = Point(v)\n\tw_Point = Point(w)\n\n\tchain = LineString(P[0]+[P[0][0]])\n\n\tdistance_to_v = chain.project(v_Point)\n\tdistance_to_w = chain.project(w_Point)\n\n\tif not chain.intersects(v_Point):\n\t\tprint(\"decomposing_cut_as_line: V not on chain\")... | [
"0.6545068",
"0.6061567",
"0.56634015",
"0.55024093",
"0.5485883",
"0.5218839",
"0.51911056",
"0.51615465",
"0.50686365",
"0.50194067",
"0.50190455",
"0.4984925",
"0.49776727",
"0.49476588",
"0.49237248",
"0.49079263",
"0.48954168",
"0.48850134",
"0.48548362",
"0.483178",
"0.... | 0.45522165 | 67 |
Get an list of points and a connection network from a cVLS and orderOfSCsByValueByFrame; limit points between triple junctions (Applies GetCVLSWithLimitedPointsBetweenNodes and then GetXYListAndPolyListFromCVLS) | def GetXYListAndPolyListWithLimitedPointsBetweenNodes_CVLS(
cVLS,
allValsByFrame,
orderOfSCsByValueByFrame,
splitLength=1,
fixedNumInteriorPoints=None,
interpolate=True,
):
cVLS2 = GetCVLSWithLimitedPointsBetweenNodes(
cVLS,
allValsByFrame,
splitLength,
fixedN... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetCVLSWithLimitedPointsBetweenNodes(\n cVLS, allValsByFrame, splitLength=1, fixedNumInteriorPoints=None, interpolate=True\n):\n allValues = list(set(tuple(flatten(allValsByFrame))))\n allPairs = sorted(\n list(set([tuple(c[0]) for cVLSByFrame in cVLS for c in cVLSByFrame]))\n ) # Value pai... | [
"0.6758528",
"0.65826356",
"0.5632501",
"0.55175966",
"0.54169285",
"0.5379928",
"0.5346093",
"0.5311847",
"0.53098977",
"0.52789253",
"0.52344453",
"0.52038324",
"0.5167569",
"0.51378644",
"0.51114464",
"0.50953865",
"0.5084913",
"0.5053021",
"0.5044931",
"0.5041024",
"0.501... | 0.71487695 | 0 |
Make 2 simplified subcontour networks, one for scListRef and another for scList with a 1to1 mapping to the first | def GetMatchedSubContourLists(
scListRef,
scList,
allValsByFrame,
orderOfSCsByValue,
splitLength=1,
fixedNumInteriorPoints=None,
):
## NOT DONE! MERGE LATER??
return simplifiedSCListRef, simplifiedSCList | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetMatchedSubContourListsCollapsing(scListA, scListB):\n\n if (\n scListA == scListB\n ): # if we got the same object for some reason, just return 2 shallow clones\n return scListA, scListB\n\n scsMatchedInB = [] # This keeps us from looping over both lists\n\n scsMatchedInB, remove... | [
"0.6174592",
"0.5594567",
"0.5401644",
"0.53908986",
"0.5365256",
"0.5335248",
"0.5255532",
"0.5243055",
"0.5222066",
"0.5215828",
"0.5205438",
"0.5200392",
"0.5197557",
"0.51619846",
"0.51185894",
"0.5075667",
"0.5075613",
"0.5074813",
"0.5073621",
"0.50514334",
"0.50234973"... | 0.6822347 | 0 |
Check all the subcontours in A to see if they have a match in B and return them Also check for flipped matches; in the event of a flip, both sc's are flagged for removal | def FindMatchesAndRemovals(scListA, scListB, searchInds=None):
scsMatchedInB = []
removeFromA = []
removeFromB = []
if searchInds is None:
searchInds = list(range(len(scListA)))
for ind in searchInds:
sca = scListA[ind]
# Look for each sc from A in B:
matchTuples = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetMatchedSubContourListsCollapsing(scListA, scListB):\n\n if (\n scListA == scListB\n ): # if we got the same object for some reason, just return 2 shallow clones\n return scListA, scListB\n\n scsMatchedInB = [] # This keeps us from looping over both lists\n\n scsMatchedInB, remove... | [
"0.67644656",
"0.5664181",
"0.55579877",
"0.5505676",
"0.5449042",
"0.5422501",
"0.53664684",
"0.535521",
"0.5319952",
"0.53025115",
"0.5284908",
"0.5258869",
"0.52418005",
"0.52386093",
"0.52161735",
"0.5211302",
"0.51943326",
"0.5173569",
"0.51730245",
"0.51399046",
"0.5133... | 0.64999247 | 1 |
Make 2 simplified subcontour networks, making sure that there is a 1to1 mapping between all points; this function collapses pairs of subcontours that do not match but are in between the same 4 cells | def GetMatchedSubContourListsCollapsing(scListA, scListB):
if (
scListA == scListB
): # if we got the same object for some reason, just return 2 shallow clones
return scListA, scListB
scsMatchedInB = [] # This keeps us from looping over both lists
scsMatchedInB, removeFromA, removeF... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multiple_intersections():\n levels = np.array([966., 937.2, 925., 904.6, 872.6, 853., 850., 836., 821., 811.6, 782.3,\n 754.2, 726.9, 700., 648.9, 624.6, 601.1, 595., 587., 576., 555.7,\n 534.2, 524., 500., 473.3, 400., 384.5, 358., 343., 308.3, 300., 276.,\n ... | [
"0.5663014",
"0.55421275",
"0.5500052",
"0.54700613",
"0.54657197",
"0.5435926",
"0.54106635",
"0.540982",
"0.5407893",
"0.54021794",
"0.5359405",
"0.5358323",
"0.5355261",
"0.53323746",
"0.5324935",
"0.5305605",
"0.53029805",
"0.5296254",
"0.5277591",
"0.5276798",
"0.5273874... | 0.6103664 | 0 |
Go all the way from raw 2d+t array to an pointList,indexes format | def MakePolygonNetworkFromWaterSeg(
waterArr, minSplit=30, allValsByFrame=None, cVLS=None
):
if allValsByFrame is None:
allValsByFrame = [list(set(w.flat)) for w in waterArr]
if cVLS is None:
cVLS = GetContourValuesLengthsAndSubContoursByFrame(waterArr, allValsByFrame)
allPtsList = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _point_array(self, objects, unique_id):\n points = []\n ids = []\n for idx, row in tqdm(objects.iterrows(), total=objects.shape[0]):\n if row[\"geometry\"].type in [\"Polygon\", \"MultiPolygon\"]:\n poly_ext = row[\"geometry\"].boundary\n else:\n ... | [
"0.62952024",
"0.6216155",
"0.6199011",
"0.60683894",
"0.6059465",
"0.6004489",
"0.5989433",
"0.5935704",
"0.5931404",
"0.59047157",
"0.5871109",
"0.58357066",
"0.58297163",
"0.5827456",
"0.58271873",
"0.582091",
"0.57979715",
"0.57417595",
"0.5718235",
"0.57016736",
"0.57009... | 0.0 | -1 |
Tests whether ``limit_string_length`` works as intended. | def test__limit_string_length(string, max_length):
return limit_string_length(string, max_length) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_string_max_length(self, value):\n if self.max_length is not None:\n return len(str(value)) <= self.max_length\n else:\n return True",
"def _str_len_check(text, min_len, max_len):\n if not isinstance(text, str):\n raise ValueError(\"expected string type\... | [
"0.7828164",
"0.74206644",
"0.7354528",
"0.73487365",
"0.730151",
"0.7263644",
"0.721242",
"0.7049977",
"0.7049977",
"0.696591",
"0.69547063",
"0.6921804",
"0.68282324",
"0.68267554",
"0.6825206",
"0.6779123",
"0.67705727",
"0.66442156",
"0.66199005",
"0.65304154",
"0.6527428... | 0.87113315 | 0 |
Makes sure that an element is only once in a set | def making_sets(lists):
empty_set = []
lists =lists.split()
for elements in lists:
if elements == " ":
next
else:
if elements not in empty_set:
empty_set.append(elements)
return empty_set | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_duplicates_set(L):\r\n return len(L) != len(set(L))",
"def is_unique(x):\n return len(set(x)) == len(x)",
"def contains_duplicate_fast_set(self, nums: List[int]) -> bool:\n visited = set()\n for i in nums:\n if i in visited:\n return True\n visit... | [
"0.7018525",
"0.69216627",
"0.6786688",
"0.67724",
"0.65951574",
"0.6533579",
"0.6502767",
"0.6317338",
"0.62912786",
"0.6264362",
"0.6228308",
"0.62009895",
"0.61905575",
"0.61454374",
"0.6141629",
"0.6129668",
"0.61090344",
"0.6108465",
"0.6100084",
"0.6098274",
"0.6094932"... | 0.0 | -1 |
Creates the intersection for both sets | def intersection(A,B):
set_A = A
set_B = B
sorted_intersection = []
for elements in set_A:
if elements in set_B:
sorted_intersection.append(elements)
return sorted_intersection | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_intersection(set_a, set_b):\n \n intersection = set_b & set_a\n \n return intersection",
"def intersection(self, *other):\n new_ordered_set = OrderedSet()\n\n for element in self:\n for obj in other:\n if element not in obj:\n break\n ... | [
"0.8064488",
"0.759755",
"0.7544426",
"0.75385064",
"0.7532488",
"0.751954",
"0.7467276",
"0.7437161",
"0.7419048",
"0.74105626",
"0.7405655",
"0.7400201",
"0.7389499",
"0.7355031",
"0.7274344",
"0.7242505",
"0.7151147",
"0.7141193",
"0.7128307",
"0.71257377",
"0.7113491",
... | 0.71919143 | 16 |
Creates the union for both sets | def union(A,B):
set_A = A
set_B = B
sorted_union = []
for elements in set_A:
if elements not in sorted_union:
sorted_union.append(elements)
for elements in set_B:
if elements not in sorted_union:
sorted_union.append(elements)
return sorted_union | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def union(set1, set2):",
"def union(self, other):\n # initialize new Set from the elements in the first Set\n union_set = Set(self.get_elements())\n\n # add every element in the second Set to a new Set and return it\n for element in other.get_elements():\n union_set.add(ele... | [
"0.91032857",
"0.8199574",
"0.81561077",
"0.8112362",
"0.8112362",
"0.8079239",
"0.7954901",
"0.78030175",
"0.7769405",
"0.7736159",
"0.7602489",
"0.7571999",
"0.75703096",
"0.75657684",
"0.7470459",
"0.7423027",
"0.7389487",
"0.7339673",
"0.7271273",
"0.72401893",
"0.7232426... | 0.78106946 | 7 |
Merge thing classes to one class. In PanopticFPN, the background labels will be reset from `0` to `self.num_stuff_classes1`, the foreground labels will be merged to `self.num_stuff_classes`th channel. | def _set_things_to_void(self, gt_semantic_seg):
gt_semantic_seg = gt_semantic_seg.int()
fg_mask = gt_semantic_seg < self.num_things_classes
bg_mask = (gt_semantic_seg >= self.num_things_classes) * (
gt_semantic_seg < self.num_things_classes + self.num_stuff_classes)
new_gt_s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_class_labels(classes,group):\n classes=np.asarray(classes)\n if (classes.dtype != int) and (classes.dtype != 'int64') and (classes.dtype != 'int32'):\n classes_merged=np.zeros(classes.shape,dtype=object)\n for subgroup in group:\n subgroup_label='+'.join(subgroup)\n ... | [
"0.5646296",
"0.5563238",
"0.55517465",
"0.524863",
"0.5160917",
"0.5154303",
"0.51411086",
"0.5111963",
"0.5110147",
"0.50583875",
"0.50512093",
"0.50234336",
"0.50105685",
"0.50064385",
"0.5000355",
"0.49941373",
"0.49783427",
"0.4972571",
"0.49269307",
"0.49222225",
"0.491... | 0.0 | -1 |
The loss of PanopticFPN head. Things classes will be merged to one class in PanopticFPN. | def loss(self, seg_preds, gt_semantic_seg):
gt_semantic_seg = self._set_things_to_void(gt_semantic_seg)
return super().loss(seg_preds, gt_semantic_seg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_loss(self):\n raise NotImplementedError",
"def get_loss(self):\n raise NotImplementedError",
"def compute_loss(self):",
"def loss(self):\n return self._loss",
"def loss(self) -> KernelLoss:\n return self._loss",
"def loss(self):\n return self._get(\"loss\")",
... | [
"0.70618695",
"0.69945925",
"0.6858851",
"0.67771924",
"0.6720419",
"0.67067975",
"0.6667089",
"0.66429305",
"0.6599716",
"0.65971327",
"0.65931565",
"0.6573648",
"0.65692914",
"0.65643126",
"0.649664",
"0.6443536",
"0.6420886",
"0.64154387",
"0.64138764",
"0.6337381",
"0.628... | 0.0 | -1 |
Split A at q and merge together in order. | def merge(A, p, q, r):
n_1 = q-p+1
n_2 = r-q
L = []
R = []
for i in range(n_1):
L.append(A[p+i])
for j in range(n_2):
R.append(A[q+j+1])
L.append(math.inf)
R.append(math.inf)
i = 0
j = 0
for k in range(p, r+1):
if L[i] <= R[j]:
A[k] = L[i]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(A, p, q, r):\n\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\n n1 = q - p + 1 # will hold A[p..q]\n n2 = r - q # will hold A[q+1..r]\n\n L = [0] * (n1 + 1)\n R = [0] * (n2 + 1)\n \n for i in range(n1):\n L[i] = A[p+i]\n for j in range(n2):\n R[j] = A[q+j... | [
"0.61172956",
"0.5973977",
"0.5877295",
"0.5761929",
"0.556019",
"0.52428263",
"0.5225745",
"0.51877797",
"0.5173802",
"0.513103",
"0.5128278",
"0.5124813",
"0.511389",
"0.5050456",
"0.50198215",
"0.4964687",
"0.4958875",
"0.49537897",
"0.49401355",
"0.48680025",
"0.48670024"... | 0.58953327 | 2 |
Split A at q and merge together in order. | def merge_in_place(A, p, q, r):
n_1 = q - p + 1
n_2 = r - q
L = 0
R = 0
for k in range(p, r+1):
if A[p] <= A[q + 1]:
A.insert(r+1, A[p])
del A[p]
L += 1
q -= 1
else:
A.insert(r+1, A[q+1])
del A[q+1]
R... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(A, p, q, r):\n\n # Split A[p..r] into L = A[p..q] and R = A[q+1..r]\n n1 = q - p + 1 # will hold A[p..q]\n n2 = r - q # will hold A[q+1..r]\n\n L = [0] * (n1 + 1)\n R = [0] * (n2 + 1)\n \n for i in range(n1):\n L[i] = A[p+i]\n for j in range(n2):\n R[j] = A[q+j... | [
"0.6118815",
"0.58961606",
"0.5878436",
"0.57619405",
"0.5558039",
"0.5241369",
"0.5224264",
"0.5186988",
"0.5172165",
"0.51325655",
"0.5128098",
"0.51249146",
"0.51147157",
"0.5049574",
"0.5020555",
"0.49630874",
"0.49623552",
"0.49531335",
"0.49419618",
"0.48679426",
"0.486... | 0.5974006 | 1 |
Sort array elements in A between p and r using mergesort. | def mergesort(A, p, r):
if p < r:
q = (p+r)//2
mergesort(A, p, q)
mergesort(A, q + 1, r)
merge(A, p, q, r) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort(self, A, index, p, r, rc_arr):\n\n if p < r:\n q = (p + r) // 2\n\n self.sort(A, index, p, q, rc_arr)\n self.sort(A, index, q + 1, r, rc_arr)\n self.merge(A, index, p, q, r, rc_arr)",
"def mergesort_ip(A, p, r):\n if p < r:\n q = (p+r)//2\n ... | [
"0.83909804",
"0.82299715",
"0.7800592",
"0.752118",
"0.74472076",
"0.74064726",
"0.7010142",
"0.69270617",
"0.6911257",
"0.6762529",
"0.6758566",
"0.67509073",
"0.6742108",
"0.6702788",
"0.66815907",
"0.6673625",
"0.6635363",
"0.656472",
"0.65487516",
"0.6545953",
"0.6545235... | 0.86928904 | 0 |
Sort array elements in A between p and r using mergesort inplace. | def mergesort_ip(A, p, r):
if p < r:
q = (p+r)//2
mergesort(A, p, q)
mergesort(A, q + 1, r)
merge_in_place(A, p, q, r) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mergesort(A, p, r):\n if p < r:\n q = (p+r)//2\n mergesort(A, p, q)\n mergesort(A, q + 1, r)\n merge(A, p, q, r)",
"def sort(self, A, index, p, r, rc_arr):\n\n if p < r:\n q = (p + r) // 2\n\n self.sort(A, index, p, q, rc_arr)\n self.sort... | [
"0.84125704",
"0.83105433",
"0.7512306",
"0.7361288",
"0.73299336",
"0.7286003",
"0.6971325",
"0.69071525",
"0.689582",
"0.6885693",
"0.68768835",
"0.6779977",
"0.66591114",
"0.662605",
"0.6586384",
"0.65090984",
"0.6479134",
"0.64221436",
"0.64146775",
"0.64103496",
"0.63233... | 0.83402205 | 1 |
Store an object's key. | def save(self, object_id, object_key, unique_type=None):
self.storage.save("", object_id, {
"object_key": object_key,
"unique_type": unique_type
})
self.key_object[object_key] = object_id
if unique_type:
if unique_type not in self.unique_objects:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def store(self, key, obj):\n attrs = self.load_attrs()\n attrs[key] = obj\n self.store_attrs(attrs)",
"def store(self, key, value):\n pass",
"def setKey(self, key):\n if hasattr(key, '__class__') and issubclass(key.__class__, ObjectKey):\n key = key.getKey()\n\n ... | [
"0.7458511",
"0.71172404",
"0.6803623",
"0.6750187",
"0.6709677",
"0.66902435",
"0.6667568",
"0.6667568",
"0.6667472",
"0.66614276",
"0.6657352",
"0.6639487",
"0.66291237",
"0.66127026",
"0.65728253",
"0.65728253",
"0.6540316",
"0.6503544",
"0.649624",
"0.64704573",
"0.645637... | 0.68876964 | 2 |
Get an object's element key. | def get_key(self, object_id):
try:
info = self.storage.load("", object_id)
return info["object_key"]
except KeyError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def object_key(self) -> str:\n return self._values.get('object_key')",
"def get_key(self, item):\r\n return item[0]",
"def key(self):\n raise NotImplementedError(\"'key' not implemented for Element subclass\")",
"def obj_key(objname):\n return OBJ_PREFIX + objname",
"def get_key(sel... | [
"0.7112568",
"0.705819",
"0.6947471",
"0.6844022",
"0.6839712",
"0.67814183",
"0.67632306",
"0.67580813",
"0.6720763",
"0.6639502",
"0.6636918",
"0.66335106",
"0.6631516",
"0.6629096",
"0.6537854",
"0.6537854",
"0.6499949",
"0.6489818",
"0.64673126",
"0.6444907",
"0.6434619",... | 0.7098794 | 1 |
Get an object by its element key. | def get_object_id(self, key):
try:
return self.key_object[key]
except KeyError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, key):\n return self()[key]",
"def __getitem__(self, key):\n if self.containsKey(key):\n return self.get(key)\n else:\n raise IndexError()",
"def __getitem__(self, key):\n return self._[key]",
"def _single_getitem(self, key):\n ret... | [
"0.6758728",
"0.6676352",
"0.6675846",
"0.6639574",
"0.66102517",
"0.6604584",
"0.6603278",
"0.6603278",
"0.6603278",
"0.6601982",
"0.6601982",
"0.66018176",
"0.66018176",
"0.66018176",
"0.66018176",
"0.65997744",
"0.6594028",
"0.65724087",
"0.6571191",
"0.656945",
"0.6553533... | 0.0 | -1 |
Get an object by its element key. | def get_unique_objects(self, unique_type):
try:
return self.unique_objects[unique_type]
except KeyError:
return {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, key):\n return self()[key]",
"def __getitem__(self, key):\n if self.containsKey(key):\n return self.get(key)\n else:\n raise IndexError()",
"def __getitem__(self, key):\n return self._[key]",
"def _single_getitem(self, key):\n ret... | [
"0.6758728",
"0.6676352",
"0.6675846",
"0.6639574",
"0.66102517",
"0.6604584",
"0.6603278",
"0.6603278",
"0.6603278",
"0.6601982",
"0.6601982",
"0.66018176",
"0.66018176",
"0.66018176",
"0.66018176",
"0.65997744",
"0.6594028",
"0.65724087",
"0.6571191",
"0.656945",
"0.6553533... | 0.0 | -1 |
Setup of creation of shared libraries in 2 Steps. | def _shared_library_in_2steps(env):
if not config.shared_library_1st in env['BUILDERS']:
# The 1st builder
shlinkcom_name = config.shared_library_1st + "COM"
env[shlinkcom_name] = "${TEMPFILE('$AR /DEF $ARFLAGS /OUT:$TARGET $SOURCES')}"
ar_action = SCons.Action.Action("$" + shlinkcom_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_lib(CLIB):\n # {{ SETUP_LIB }}",
"def setup_module():\n common_setup_module()",
"def initialize_library():\n # return the handle to the shared object\n if os.name == \"nt\":\n pass\n # libc = load_windows_dll()\n else:\n libc = load_linux_so()\n return libc",
... | [
"0.69693637",
"0.6318507",
"0.62593526",
"0.61885273",
"0.6175638",
"0.61054045",
"0.6081299",
"0.60247236",
"0.6005774",
"0.59742194",
"0.59631056",
"0.59508246",
"0.59508246",
"0.59334606",
"0.5921951",
"0.5921951",
"0.5921951",
"0.5921951",
"0.5921951",
"0.5915148",
"0.590... | 0.761938 | 0 |
Convert `url` into a hashed filename in a repeatable way. If `etag` is specified, append its hash to the url's, delimited by a period. | def url_to_filename(url, etag=None):
url_bytes = url.encode("utf-8")
url_hash = sha256(url_bytes)
filename = url_hash.hexdigest()
if etag:
etag_bytes = etag.encode("utf-8")
etag_hash = sha256(etag_bytes)
filename += "." + etag_hash.hexdigest()
return filename | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def url_to_filename(url, etag=None):\n\turl_bytes = url.encode ('utf-8')\n\turl_hash = sha256 (url_bytes)\n\tfilename = url_hash.hexdigest ()\n\n\tif etag:\n\t\tetag_bytes = etag.encode ('utf-8')\n\t\tetag_hash = sha256 (etag_bytes)\n\t\tfilename += '.' + etag_hash.hexdigest ()\n\n\treturn filename",
"def url_to... | [
"0.84432817",
"0.84120035",
"0.672716",
"0.64712",
"0.62056106",
"0.61464995",
"0.6029297",
"0.59602135",
"0.59466934",
"0.59007996",
"0.58756745",
"0.5849285",
"0.57746124",
"0.57643247",
"0.57582027",
"0.57522213",
"0.574183",
"0.5723955",
"0.5720462",
"0.57145333",
"0.5713... | 0.8393963 | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.